Construire une Boussole Numérique Temps Réel avec Arduino et Processing

Dans ce projet Arduino, nous verrons comment réaliser cette boussole au look cool en utilisant un Arduino, un magnétomètre MEMS et l'IDE Processing. Voici une vidéo de démonstration de la boussole :

Vue d'Ensemble

Pour ce projet, nous avons besoin d'un magnétomètre MEMS pour mesurer le champ magnétique terrestre, une carte Arduino et quelques fils de connexion. Comme exemple, j'utiliserai le HMC5883L, un magnétomètre 3 axes intégré sur la carte d'extension GY-80.

Comment Fonctionne la Boussole

Partie Arduino

D'abord, nous devons récupérer les données du capteur via l'Arduino en utilisant le protocole I2C. Ensuite, en utilisant les valeurs des axes X et Y du capteur, nous calculerons le cap (heading) et enverrons sa valeur à l'IDE Processing via le port série. Le code suivant fait ce travail :

/* Boussole Arduino
 * par Dejan Nedelkovski,
 * www.HowToMechatronics.com
 */
#include  // Bibliothèque I2C Arduino
#define Magnetometer_mX0 0x03
#define Magnetometer_mX1 0x04
#define Magnetometer_mZ0 0x05
#define Magnetometer_mZ1 0x06
#define Magnetometer_mY0 0x07
#define Magnetometer_mY1 0x08
int mX0, mX1, mX_out;
int mY0, mY1, mY_out;
int mZ0, mZ1, mZ_out;
float heading, headingDegrees, headingFiltered, declination;
float Xm, Ym, Zm;
#define Magnetometer 0x1E // Adresse I2C 7 bits du HMC5883

void setup() {
  // Initialisation communications Série et I2C
  Serial.begin(115200);
  Wire.begin();
  delay(100);
  Wire.beginTransmission(Magnetometer);
  Wire.write(0x02); // Sélection registre mode
  Wire.write(0x00); // Mode mesure continue
  Wire.endTransmission();
}

void loop() {
  //---- Axe X
  Wire.beginTransmission(Magnetometer);
  Wire.write(Magnetometer_mX1);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer, 1);
  if(Wire.available() <= 1) { mX0 = Wire.read(); }
  Wire.beginTransmission(Magnetometer);
  Wire.write(Magnetometer_mX0);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer, 1);
  if(Wire.available() <= 1) { mX1 = Wire.read(); }
  //---- Axe Y
  Wire.beginTransmission(Magnetometer);
  Wire.write(Magnetometer_mY1);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer, 1);
  if(Wire.available() <= 1) { mY0 = Wire.read(); }
  Wire.beginTransmission(Magnetometer);
  Wire.write(Magnetometer_mY0);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer, 1);
  if(Wire.available() <= 1) { mY1 = Wire.read(); }
  //---- Axe Z
  Wire.beginTransmission(Magnetometer);
  Wire.write(Magnetometer_mZ1);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer, 1);
  if(Wire.available() <= 1) { mZ0 = Wire.read(); }
  Wire.beginTransmission(Magnetometer);
  Wire.write(Magnetometer_mZ0);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer, 1);
  if(Wire.available() <= 1) { mZ1 = Wire.read(); }
  //---- Axe X
  mX1 = mX1 << 8;
  mX_out = mX0 + mX1; // Données brutes
  // Selon datasheet: 0.92 mG/digit
  Xm = mX_out * 0.00092; // Unité Gauss
  //* Le champ magnétique terrestre varie de 0.25 à 0.65 Gauss, ces sont les valeurs approximatives attendues.
  //---- Axe Y
  mY1 = mY1 << 8;
  mY_out = mY0 + mY1;
  Ym = mY_out * 0.00092;
  //---- Axe Z
  mZ1 = mZ1 << 8;
  mZ_out = mZ0 + mZ1;
  Zm = mZ_out * 0.00092;
  // ==============================
  // Calcul du cap (heading)
  heading = atan2(Ym, Xm);
  // Correction du cap avec l'angle de déclinaison selon votre position
  // Trouvez votre angle de déclinaison sur: https://www.ngdc.noaa.gov/geomag-web/
  // À ma position, c'est 4.2 degrés => 0.073 rad
  declination = 0.073;
  heading += declination;
  // Correction quand les signes sont inversés
  if(heading < 0) heading += 2*PI;
  // Correction due à l'addition de la déclinaison
  if(heading > 2*PI) heading -= 2*PI;
  headingDegrees = heading * 180/PI; // Cap en degrés
  // Lissage de l'angle de sortie / Filtre passe-bas
  headingFiltered = headingFiltered * 0.85 + headingDegrees * 0.15;
  // Envoi de la valeur du cap via le port série vers Processing IDE
  Serial.println(headingFiltered);
  delay(50);
}

Si vous avez besoin de plus de détails sur le fonctionnement du magnétomètre MEMS et comment récupérer ses données, consultez mon tutoriel sur les capteurs MEMS.

Partie IDE Processing

Ici, nous devons d'abord recevoir les valeurs de cap provenant du port série. Pour plus de détails sur la façon dont cela se fait, consultez mon tutoriel Arduino et Processing.

La boussole est en fait une image, ou plus précisément, elle est composée de plusieurs images transparentes chargées dans l'IDE Processing. Les images doivent être situées dans le répertoire de travail du sketch. Après avoir défini les objets images dans la section draw(), en utilisant la fonction image(), on charge l'image de fond (optionnelle, on peut utiliser une simple couleur). Ensuite, l'image de la boussole est chargée et, grâce à la fonction rotateZ(), elle est tournée avec les valeurs du cap. Par-dessus, l'image de la flèche de boussole est chargée.

Voici le code de l'IDE Processing :

/* Boussole Arduino
 * par Dejan Nedelkovski,
 * www.HowToMechatronics.com
 */
import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;
Serial myPort;
PImage imgCompass;
PImage imgCompassArrow;
PImage background;
String data = "";
float heading;

void setup() {
  size(1920, 1080, P3D);
  smooth();
  imgCompass = loadImage("Compass.png");
  imgCompassArrow = loadImage("CompassArrow.png");
  background = loadImage("Background.png");
  myPort = new Serial(this, "COM4", 115200); // Communication série
  myPort.bufferUntil('\n');
}

void draw() {
  image(background, 0, 0); // Charge l'image de fond
  pushMatrix();
  translate(width/2, height/2, 0); // Translateur le système de coordonnées au centre
  rotateZ(radians(-heading)); // Rotation de la boussole autour de l'axe Z
  image(imgCompass, -960, -540); // Charge l'image boussole (demi-taille écran)
  popMatrix(); // Ramène le système de coordonnées à 0,0,0
  image(imgCompassArrow, 0, 0); // Charge la flèche (non affectée par rotateZ grâce à popMatrix)
  textSize(30);
  text("Cap: " + heading, 40, 40); // Affiche la valeur du cap
  delay(40);
}

// Lecture des données du port série
void serialEvent(Serial myPort) {
  data = myPort.readStringUntil('\n'); // Lit les données jusqu'à '\n'
  heading = float(data); // Convertit la valeur String en Float
}

Vous pouvez télécharger les fichiers du projet, les images et les codes sources ici :