Suivi d'Orientation avec Arduino et Accéléromètre ADXL345 : Guide Pas à Pas

Introduction

Dans ce tutoriel, nous allons apprendre à mesurer l'angle et suivre l'orientation avec Arduino et le capteur accéléromètre ADXL345. Vous pouvez regarder la vidéo ou lire le tutoriel écrit ci-dessous pour plus de détails.

Vue d'Ensemble

D'abord, j'expliquerai le fonctionnement du capteur et comment lire ses données, puis avec l'environnement Processing, nous ferons une visualisation 3D de l'orientation de l'accéléromètre.

Comment Fonctionne l'Accéléromètre ADXL345

Regardons comment fonctionne le capteur ADXL345. C'est un accéléromètre 3 axes qui mesure les forces d'accélération statiques et dynamiques. La force gravitationnelle terrestre est un exemple typique de force statique, tandis que les forces dynamiques peuvent être causées par des vibrations, mouvements, etc.

L'unité de mesure de l'accélération est le m/s². Cependant, les accéléromètres expriment généralement les mesures en "g" (gravité). 1 "g" = force gravitationnelle terrestre = 9,8 m/s².

Si l'accéléromètre est à plat, axe Z vers le haut (opposé à la gravité), la sortie Z sera 1g. Les sorties X et Y seront nulles car la gravité est perpendiculaire à ces axes.

Si on retourne le capteur, la sortie Z sera -1g. Les sorties dues à l'orientation par rapport à la gravité varient donc de -1g à +1g.

Grâce à ces données et un peu de trigonométrie, on peut calculer l'angle d'inclinaison du capteur.

Comment Lire les Données ADXL345 avec Arduino

Ce capteur utilise le protocole I2C pour communiquer avec Arduino : 2 fils pour la communication, 2 pour l'alimentation.

Composants Nécessaires

• Accéléromètre ADXL345 – Amazon / Banggood / AliExpress
• Carte Arduino
• Plaque d'essai et fils de connexion

Code Arduino ADXL345

Voici le code pour lire les données de l'ADXL345.

/* Arduino et ADXL345 Accéléromètre par Dejan, https://howtomechatronics.com */
#include <Wire.h> // Bibliothèque Wire pour I2C
int ADXL345 = 0x53; // Adresse I2C ADXL345
float X_out, Y_out, Z_out; // Sorties

void setup() {
  Serial.begin(9600);
  Wire.begin();
  
  // Mise en mode mesure
  Wire.beginTransmission(ADXL345);
  Wire.write(0x2D); // Registre POWER_CTL - 0x2D
  Wire.write(8);    // (8dec -> 0000 1000 binaire) Bit D3 HIGH pour activer mesure
  Wire.endTransmission();
  delay(10);
}

void loop() {
  // === Lecture accéléromètre ===
  Wire.beginTransmission(ADXL345);
  Wire.write(0x32); // Registre ACCEL_XOUT_H
  Wire.endTransmission(false);
  Wire.requestFrom(ADXL345, 6, true); // Lit 6 registres (2 par axe)
  
  X_out = (Wire.read() | Wire.read() << 8); // X
  X_out = X_out / 256; // Pour ±2g, diviser par 256 (datasheet)
  Y_out = (Wire.read() | Wire.read() << 8); // Y
  Y_out = Y_out / 256;
  Z_out = (Wire.read() | Wire.read() << 8); // Z
  Z_out = Z_out / 256;
  
  Serial.print("Xa= "); Serial.print(X_out);
  Serial.print(" Ya= "); Serial.print(Y_out);
  Serial.print(" Za= "); Serial.println(Z_out);
}

Description

On inclut Wire.h pour l'I2C. Chaque dispositif I2C a une adresse unique (dans la datasheet ADXL345). Une fois l'adresse et variables définies, dans setup(), on initialise Wire et on met l'accéléromètre en mode mesure. Selon la datasheet, il faut mettre le bit D3 du registre POWER_CTL à HIGH.

Avec beginTransmission() on démarre la communication, write() pour choisir le registre, et encore write() pour mettre le bit D3 HIGH en écrivant 8 (décimal = 0000 1000 binaire).

Wire.beginTransmission(ADXL345);
Wire.write(0x2D); // POWER_CTL
Wire.write(8);    // Bit D3 HIGH
Wire.endTransmission();

Dans loop(), on lit les données. Chaque axe sur 2 octets/registres. Adresses dans la datasheet.

On commence au premier registre, avec requestFrom() on demande 6 registres. Avec read() on lit chaque registre, et comme les sorties sont en complément à deux, on les combine correctement.

Wire.beginTransmission(ADXL345);
Wire.write(0x32); // ACCEL_XOUT_H
Wire.endTransmission(false);
Wire.requestFrom(ADXL345, 6, true);
X_out = (Wire.read() | Wire.read() << 8);
X_out = X_out / 256;
Y_out = (Wire.read() | Wire.read() << 8);
Y_out = Y_out / 256;
Z_out = (Wire.read() | Wire.read() << 8);
Z_out = Z_out / 256;

Les valeurs de sortie dépendent de la sensibilité choisie (±2g à ±16g). Défaut ±2g, donc division par 256 pour obtenir -1 à +1g. 256 LSB/g = 256 comptes par g.

Selon l'application, on peut choisir une autre sensibilité via le registre DATA_FORMAT et ses bits D1, D0.

Calibration de l'Accéléromètre ADXL345

Une fois les données lues, on les affiche sur le moniteur série pour vérifier. Dans mon cas, les valeurs n'étaient pas exactes, surtout l'axe Z avec une erreur notable de 0,1g.

Pour corriger, on calibre avec les 3 registres d'offset de calibration. Voici comment : positionner le capteur à plat, afficher les valeurs BRUTES (sans diviser par 256).

On voit de combien les sorties sont décalées. Dans mon cas, Z ≈ 283 (différence +27). On divise par 4 → valeur à écrire dans le registre d'offset Z. Après téléversement, Z sortira exactement 256 (1g).

// Ce code va dans SETUP
// Calibration Offset
// Axe X
Wire.beginTransmission(ADXL345);
Wire.write(0x1E); // Registre offset X
Wire.write(1);
Wire.endTransmission();
delay(10);
// Axe Y
Wire.beginTransmission(ADXL345);
Wire.write(0x1F); // Registre offset Y
Wire.write(-2);
Wire.endTransmission();
delay(10);
// Axe Z
Wire.beginTransmission(ADXL345);
Wire.write(0x20); // Registre offset Z
Wire.write(-7);
Wire.endTransmission();
delay(10);

Si nécessaire, calibrer les autres axes pareil. Note : cette calibration n'est pas écrite de façon permanente dans les registres. Il faut réécrire ces valeurs à chaque mise sous tension du capteur.

Une fois calibré, on calcule enfin le Roulis (Roll) et le Tangage (Pitch), soit la rotation autour de l'axe X et Y en degrés, avec ces formules :

// Calcul Roll et Pitch (rotation axe X, rotation axe Y)
roll = atan(Y_out / sqrt(pow(X_out, 2) + pow(Z_out, 2))) * 180 / PI;
pitch = atan(-1 * X_out / sqrt(pow(Y_out, 2) + pow(Z_out, 2))) * 180 / PI;

Pour plus de détails sur ces formules, consultez cette note d'application Freescale Semiconductor.

Arduino et ADXL345 – Suivi d'Orientation Visualisation 3D

Faisons l'exemple de visualisation 3D de l'accéléromètre.

On utilise le même code qui envoie Roll et Pitch par le port série. Voici le code Arduino complet :

/* Arduino et ADXL345 Accéléromètre - Visualisation 3D par Dejan, https://howtomechatronics.com */
#include <Wire.h>
int ADXL345 = 0x53;
float X_out, Y_out, Z_out;
float roll, pitch, rollF, pitchF = 0;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  
  Wire.beginTransmission(ADXL345);
  Wire.write(0x2D);
  Wire.write(8);
  Wire.endTransmission();
  delay(10);
  
  // Calibration Offset
  Wire.beginTransmission(ADXL345); Wire.write(0x1E); Wire.write(1); Wire.endTransmission(); delay(10);
  Wire.beginTransmission(ADXL345); Wire.write(0x1F); Wire.write(-2); Wire.endTransmission(); delay(10);
  Wire.beginTransmission(ADXL345); Wire.write(0x20); Wire.write(-9); Wire.endTransmission(); delay(10);
}

void loop() {
  Wire.beginTransmission(ADXL345);
  Wire.write(0x32);
  Wire.endTransmission(false);
  Wire.requestFrom(ADXL345, 6, true);
  
  X_out = (Wire.read() | Wire.read() << 8); X_out = X_out / 256;
  Y_out = (Wire.read() | Wire.read() << 8); Y_out = Y_out / 256;
  Z_out = (Wire.read() | Wire.read() << 8); Z_out = Z_out / 256;
  
  roll = atan(Y_out / sqrt(pow(X_out, 2) + pow(Z_out, 2))) * 180 / PI;
  pitch = atan(-1 * X_out / sqrt(pow(Y_out, 2) + pow(Z_out, 2))) * 180 / PI;
  
  // Filtre passe-bas
  rollF = 0.94 * rollF + 0.06 * roll;
  pitchF = 0.94 * pitchF + 0.06 * pitch;
  
  Serial.print(rollF); Serial.print("/"); Serial.println(pitchF);
}

Dans Processing, on reçoit ces valeurs et on les utilise pour faire pivoter l'objet 3D. Voici le code Processing complet :

/* Arduino et ADXL345 Accéléromètre - Visualisation 3D par Dejan, https://howtomechatronics.com */
import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;

Serial myPort;
String data="";
float roll, pitch;

void setup() {
  size(960, 640, P3D);
  myPort = new Serial(this, "COM8", 9600);
  myPort.bufferUntil('\n');
}

void draw() {
  translate(width/2, height/2, 0);
  background(33);
  textSize(22);
  text("Roll: " + int(roll) + " Pitch: " + int(pitch), -100, 265);
  
  rotateX(radians(roll));
  rotateZ(radians(-pitch));
  
  textSize(30);
  fill(0, 76, 153);
  box(386, 40, 200);
  
  textSize(25);
  fill(255, 255, 255);
  text("www.HowToMechatronics.com", -183, 10, 101);
}

void serialEvent(Serial myPort) {
  data = myPort.readStringUntil('\n');
  if (data != null) {
    data = trim(data);
    String items[] = split(data, '/');
    if (items.length > 1) {
      roll = float(items[0]);
      pitch = float(items[1]);
    }
  }
}

Description

On inclut la bibliothèque série, on définit le port série et le baud rate (doit correspondre au sketch Arduino). On lit les données entrantes et on les met dans les variables roll et pitch. Dans draw(), on utilise ces valeurs pour faire pivoter l'objet 3D (un pavé coloré avec texte).

En lançant le sketch, l'objet 3D apparaît et suit l'orientation de l'accéléromètre. L'objet est un peu tremblant car l'accéléromètre capte non seulement la gravité mais aussi les petites forces des mouvements de la main. Pour lisser, on utilise un filtre passe-bas simple. Je l'ai implémenté dans le code Arduino : il prend 94% de l'état précédent et ajoute 6% de l'état/angle actuel.

// Filtre passe-bas
rollF = 0.94 * rollF + 0.06 * roll;
pitchF = 0.94 * pitchF + 0.06 * pitch;

Avec ce filtre, l'objet bouge plus doucement, mais avec un effet de bord : réactivité plus lente. On note aussi l'absence de Yaw (rotation axe Z). Avec seulement un accéléromètre 3 axes, on ne peut pas calculer le Yaw.

Pour l'obtenir et améliorer les performances globales, il faut ajouter un gyroscope et fusionner ses données avec l'accéléromètre.

Soit on utilise l'ADXL345 avec un gyroscope séparé, soit le MPU6050 IMU qui intègre accéléromètre 3 axes et gyroscope 3 axes sur une seule puce. Tutoriel détaillé sur ce capteur dans ma prochaine vidéo.

J'espère que ce tutoriel vous a plu. Posez vos questions dans les commentaires et consultez ma collection de projets Arduino.