Tutoriel sur l'accéléromètre et le gyroscope Arduino et MPU6050

Dans ce didacticiel, nous apprendrons à utiliser le capteur d'accéléromètre et de gyroscope MPU6050 avec l'Arduino. Tout d'abord, je vais vous expliquer comment fonctionne le MPU6050 et comment en lire les données, puis nous ferons deux exemples pratiques.

Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.

Aperçu

Dans le premier exemple, en utilisant l'environnement de développement Processing, nous ferons une visualisation 3D de l'orientation du capteur, et dans le deuxième exemple nous ferons une simple plate-forme auto-stabilisante ou un DIY Gimbal. Sur la base de l'orientation du MPU6050 et de ses données fusionnées d'accéléromètre et de gyroscope, nous contrôlons les trois servos qui maintiennent le niveau de la plate-forme.

Comment ça marche

L'IMU MPU6050 possède à la fois un accéléromètre 3 axes et un gyroscope 3 axes intégrés sur une seule puce.

Le gyroscope mesure la vitesse de rotation ou le taux de changement de la position angulaire dans le temps, le long des axes X, Y et Z. Il utilise la technologie MEMS et l'effet Coriolis pour la mesure, mais pour plus de détails à ce sujet, vous pouvez consulter mon tutoriel particulier sur le fonctionnement des capteurs MEMS. Les sorties du gyroscope sont en degrés par seconde, donc pour obtenir la position angulaire, il suffit d'intégrer la vitesse angulaire.

D'autre part, l'accéléromètre MPU6050 mesure l'accélération de la même manière qu'expliqué dans la vidéo précédente pour le capteur accéléromètre ADXL345. En bref, il peut mesurer l'accélération gravitationnelle le long des 3 axes et en utilisant des calculs de trigonométrie, nous pouvons calculer l'angle auquel le capteur est positionné. Ainsi, si nous fusionnons ou combinons les données de l'accéléromètre et du gyroscope, nous pouvons obtenir des informations très précises sur l'orientation du capteur.

L'IMU MPU6050 est également appelé dispositif de suivi de mouvement à six axes ou dispositif 6 DoF (six degrés de liberté), en raison de ses 6 sorties, ou des 3 sorties de l'accéléromètre et des 3 sorties du gyroscope.

Arduino et MPU6050

Voyons comment nous pouvons connecter et lire les données du capteur MPU6050 à l'aide de l'Arduino. Nous utilisons le protocole I2C pour communiquer avec l'Arduino, nous n'avons donc besoin que de deux fils pour le connecter, plus les deux fils pour l'alimentation.

Vous pouvez obtenir les composants nécessaires pour ce didacticiel Arduino à partir des liens ci-dessous :

IMU MPU6050 …………………………..…. Amazon / Banggood /AliExpress
Carte Arduino ………………………….…..
Breadboard et Jump Wires …………

Code Arduino MPU6050

Voici le code Arduino pour lire les données du capteur MPU6050. Sous le code, vous trouverez une description détaillée de celui-ci.

/*
   Arduino and MPU6050 Accelerometer and Gyroscope Sensor Tutorial
   by Dejan, https://howtomechatronics.com
*/
#include <Wire.h>
const int MPU = 0x68; // MPU6050 I2C address
float AccX, AccY, AccZ;
float GyroX, GyroY, GyroZ;
float accAngleX, accAngleY, gyroAngleX, gyroAngleY, gyroAngleZ;
float roll, pitch, yaw;
float AccErrorX, AccErrorY, GyroErrorX, GyroErrorY, GyroErrorZ;
float elapsedTime, currentTime, previousTime;
int c = 0;
void setup() {
  Serial.begin(19200);
  Wire.begin();                      // Initialize comunication
  Wire.beginTransmission(MPU);       // Start communication with MPU6050 // MPU=0x68
  Wire.write(0x6B);                  // Talk to the register 6B
  Wire.write(0x00);                  // Make reset - place a 0 into the 6B register
  Wire.endTransmission(true);        //end the transmission
  /*
  // Configure Accelerometer Sensitivity - Full Scale Range (default +/- 2g)
  Wire.beginTransmission(MPU);
  Wire.write(0x1C);                  //Talk to the ACCEL_CONFIG register (1C hex)
  Wire.write(0x10);                  //Set the register bits as 00010000 (+/- 8g full scale range)
  Wire.endTransmission(true);
  // Configure Gyro Sensitivity - Full Scale Range (default +/- 250deg/s)
  Wire.beginTransmission(MPU);
  Wire.write(0x1B);                   // Talk to the GYRO_CONFIG register (1B hex)
  Wire.write(0x10);                   // Set the register bits as 00010000 (1000deg/s full scale)
  Wire.endTransmission(true);
  delay(20);
  */
  // Call this function if you need to get the IMU error values for your module
  calculate_IMU_error();
  delay(20);
}
void loop() {
  // === Read acceleromter data === //
  Wire.beginTransmission(MPU);
  Wire.write(0x3B); // Start with register 0x3B (ACCEL_XOUT_H)
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true); // Read 6 registers total, each axis value is stored in 2 registers
  //For a range of +-2g, we need to divide the raw values by 16384, according to the datasheet
  AccX = (Wire.read() << 8 | Wire.read()) / 16384.0; // X-axis value
  AccY = (Wire.read() << 8 | Wire.read()) / 16384.0; // Y-axis value
  AccZ = (Wire.read() << 8 | Wire.read()) / 16384.0; // Z-axis value
  // Calculating Roll and Pitch from the accelerometer data
  accAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * 180 / PI) - 0.58; // AccErrorX ~(0.58) See the calculate_IMU_error()custom function for more details
  accAngleY = (atan(-1 * AccX / sqrt(pow(AccY, 2) + pow(AccZ, 2))) * 180 / PI) + 1.58; // AccErrorY ~(-1.58)
  // === Read gyroscope data === //
  previousTime = currentTime;        // Previous time is stored before the actual time read
  currentTime = millis();            // Current time actual time read
  elapsedTime = (currentTime - previousTime) / 1000; // Divide by 1000 to get seconds
  Wire.beginTransmission(MPU);
  Wire.write(0x43); // Gyro data first register address 0x43
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true); // Read 4 registers total, each axis value is stored in 2 registers
  GyroX = (Wire.read() << 8 | Wire.read()) / 131.0; // For a 250deg/s range we have to divide first the raw value by 131.0, according to the datasheet
  GyroY = (Wire.read() << 8 | Wire.read()) / 131.0;
  GyroZ = (Wire.read() << 8 | Wire.read()) / 131.0;
  // Correct the outputs with the calculated error values
  GyroX = GyroX + 0.56; // GyroErrorX ~(-0.56)
  GyroY = GyroY - 2; // GyroErrorY ~(2)
  GyroZ = GyroZ + 0.79; // GyroErrorZ ~ (-0.8)
  // Currently the raw values are in degrees per seconds, deg/s, so we need to multiply by sendonds (s) to get the angle in degrees
  gyroAngleX = gyroAngleX + GyroX * elapsedTime; // deg/s * s = deg
  gyroAngleY = gyroAngleY + GyroY * elapsedTime;
  yaw =  yaw + GyroZ * elapsedTime;
  // Complementary filter - combine acceleromter and gyro angle values
  roll = 0.96 * gyroAngleX + 0.04 * accAngleX;
  pitch = 0.96 * gyroAngleY + 0.04 * accAngleY;
  
  // Print the values on the serial monitor
  Serial.print(roll);
  Serial.print("/");
  Serial.print(pitch);
  Serial.print("/");
  Serial.println(yaw);
}
void calculate_IMU_error() {
  // We can call this funtion in the setup section to calculate the accelerometer and gyro data error. From here we will get the error values used in the above equations printed on the Serial Monitor.
  // Note that we should place the IMU flat in order to get the proper values, so that we then can the correct values
  // Read accelerometer values 200 times
  while (c < 200) {
    Wire.beginTransmission(MPU);
    Wire.write(0x3B);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU, 6, true);
    AccX = (Wire.read() << 8 | Wire.read()) / 16384.0 ;
    AccY = (Wire.read() << 8 | Wire.read()) / 16384.0 ;
    AccZ = (Wire.read() << 8 | Wire.read()) / 16384.0 ;
    // Sum all readings
    AccErrorX = AccErrorX + ((atan((AccY) / sqrt(pow((AccX), 2) + pow((AccZ), 2))) * 180 / PI));
    AccErrorY = AccErrorY + ((atan(-1 * (AccX) / sqrt(pow((AccY), 2) + pow((AccZ), 2))) * 180 / PI));
    c++;
  }
  //Divide the sum by 200 to get the error value
  AccErrorX = AccErrorX / 200;
  AccErrorY = AccErrorY / 200;
  c = 0;
  // Read gyro values 200 times
  while (c < 200) {
    Wire.beginTransmission(MPU);
    Wire.write(0x43);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU, 6, true);
    GyroX = Wire.read() << 8 | Wire.read();
    GyroY = Wire.read() << 8 | Wire.read();
    GyroZ = Wire.read() << 8 | Wire.read();
    // Sum all readings
    GyroErrorX = GyroErrorX + (GyroX / 131.0);
    GyroErrorY = GyroErrorY + (GyroY / 131.0);
    GyroErrorZ = GyroErrorZ + (GyroZ / 131.0);
    c++;
  }
  //Divide the sum by 200 to get the error value
  GyroErrorX = GyroErrorX / 200;
  GyroErrorY = GyroErrorY / 200;
  GyroErrorZ = GyroErrorZ / 200;
  // Print the error values on the Serial Monitor
  Serial.print("AccErrorX: ");
  Serial.println(AccErrorX);
  Serial.print("AccErrorY: ");
  Serial.println(AccErrorY);
  Serial.print("GyroErrorX: ");
  Serial.println(GyroErrorX);
  Serial.print("GyroErrorY: ");
  Serial.println(GyroErrorY);
  Serial.print("GyroErrorZ: ");
  Serial.println(GyroErrorZ);
}Code language: Arduino (arduino)

Description du code : Nous devons donc d'abord inclure la bibliothèque Wire.h qui est utilisée pour la communication I2C et définir certaines variables nécessaires au stockage des données.

Dans la section de configuration, nous devons initialiser la bibliothèque de fils et réinitialiser le capteur via le registre de gestion de l'alimentation. Pour ce faire, nous devons consulter la fiche technique du capteur d'où nous pouvons voir l'adresse du registre.

De plus, si nous le voulons, nous pouvons sélectionner la plage pleine échelle pour l'accéléromètre et le gyroscope à l'aide de leurs registres de configuration. Pour cet exemple, nous utiliserons la plage par défaut de +- 2g pour l'accéléromètre et la plage de 250 degrés/s pour le gyroscope, je vais donc laisser cette partie du code commentée.

// Configure Accelerometer Sensitivity - Full Scale Range (default +/- 2g)
  Wire.beginTransmission(MPU);
  Wire.write(0x1C);                  //Talk to the ACCEL_CONFIG register (1C hex)
  Wire.write(0x10);                  //Set the register bits as 00010000 (+/- 8g full scale range)
  Wire.endTransmission(true);
  // Configure Gyro Sensitivity - Full Scale Range (default +/- 250deg/s)
  Wire.beginTransmission(MPU);
  Wire.write(0x1B);                   // Talk to the GYRO_CONFIG register (1B hex)
  Wire.write(0x10);                   // Set the register bits as 00010000 (1000deg/s full scale)
  Wire.endTransmission(true);
  */Code language: Arduino (arduino)

Dans la section boucle, nous commençons par lire les données de l'accéléromètre. Les données de chaque axe sont stockées dans deux octets ou registres et nous pouvons voir les adresses de ces registres à partir de la fiche technique du capteur.

Afin de tous les lire, nous commençons par le premier registre, et en utilisant la fonction requiestFrom() nous demandons de lire les 6 registres pour les axes X, Y et Z. Ensuite, nous lisons les données de chaque registre, et comme les sorties sont complémentaires à deux, nous les combinons de manière appropriée pour obtenir les valeurs correctes.

// === Read acceleromter data === //
  Wire.beginTransmission(MPU);
  Wire.write(0x3B); // Start with register 0x3B (ACCEL_XOUT_H)
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true); // Read 6 registers total, each axis value is stored in 2 registers
  //For a range of +-2g, we need to divide the raw values by 16384, according to the datasheet
  AccX = (Wire.read() << 8 | Wire.read()) / 16384.0; // X-axis value
  AccY = (Wire.read() << 8 | Wire.read()) / 16384.0; // Y-axis value
  AccZ = (Wire.read() << 8 | Wire.read()) / 16384.0; // Z-axis valueCode language: Arduino (arduino)

Afin d'obtenir des valeurs de sortie de -1g à +1g, adaptées au calcul des angles, nous divisons la sortie avec la sensibilité précédemment sélectionnée.

Enfin, à l'aide de ces deux formules, nous calculons les angles de roulis et de tangage à partir des données de l'accéléromètre.

// Calculating Roll and Pitch from the accelerometer data
  accAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * 180 / PI) - 0.58; // AccErrorX ~(0.58) See the calculate_IMU_error()custom function for more details
  accAngleY = (atan(-1 * AccX / sqrt(pow(AccY, 2) + pow(AccZ, 2))) * 180 / PI) + 1.58; // AccErrorY ~(-1.58)Code language: Arduino (arduino)

Ensuite, en utilisant la même méthode, nous obtenons les données du gyroscope.

Nous lisons les six registres du gyroscope, combinons leurs données de manière appropriée et divisons par la sensibilité précédemment sélectionnée afin d'obtenir la sortie en degrés par seconde.

// === Read gyroscope data === //
  previousTime = currentTime;        // Previous time is stored before the actual time read
  currentTime = millis();            // Current time actual time read
  elapsedTime = (currentTime - previousTime) / 1000; // Divide by 1000 to get seconds
  Wire.beginTransmission(MPU);
  Wire.write(0x43); // Gyro data first register address 0x43
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true); // Read 4 registers total, each axis value is stored in 2 registers
  GyroX = (Wire.read() << 8 | Wire.read()) / 131.0; // For a 250deg/s range we have to divide first the raw value by 131.0, according to the datasheet
  GyroY = (Wire.read() << 8 | Wire.read()) / 131.0;
  GyroZ = (Wire.read() << 8 | Wire.read()) / 131.0;Code language: Arduino (arduino)

Ici, vous pouvez remarquer que je corrige les valeurs de sortie avec quelques petites valeurs d'erreur calculées, que j'expliquerai comment nous les obtenons en une minute. Donc, comme les sorties sont en degrés par seconde, nous devons maintenant les multiplier par le temps pour obtenir juste des degrés. La valeur de temps est capturée avant chaque itération de lecture à l'aide de la fonction millis().

// Correct the outputs with the calculated error values
  GyroX = GyroX + 0.56; // GyroErrorX ~(-0.56)
  GyroY = GyroY - 2; // GyroErrorY ~(2)
  GyroZ = GyroZ + 0.79; // GyroErrorZ ~ (-0.8)
  // Currently the raw values are in degrees per seconds, deg/s, so we need to multiply by sendonds (s) to get the angle in degrees
  gyroAngleX = gyroAngleX + GyroX * elapsedTime; // deg/s * s = deg
  gyroAngleY = gyroAngleY + GyroY * elapsedTime;
  yaw =  yaw + GyroZ * elapsedTime;Code language: Arduino (arduino)

Enfin, nous fusionnons les données de l'accéléromètre et du gyroscope à l'aide d'un filtre complémentaire. Ici, nous prenons 96% des données du gyroscope car il est très précis et ne souffre pas de forces externes. L'inconvénient du gyroscope est qu'il dérive ou qu'il introduit une erreur dans la sortie au fil du temps. Par conséquent, sur le long terme, nous utilisons les données de l'accéléromètre, 4 % dans ce cas, de quoi éliminer l'erreur de dérive du gyroscope.

// Complementary filter - combine acceleromter and gyro angle values
  roll = 0.96 * gyroAngleX + 0.04 * accAngleX;
  pitch = 0.96 * gyroAngleY + 0.04 * accAngleY;Code language: Arduino (arduino)

Cependant, comme nous ne pouvons pas calculer le Yaw à partir des données de l'accéléromètre, nous ne pouvons pas implémenter le filtre complémentaire sur celui-ci.

Avant de jeter un coup d'œil aux résultats, laissez-moi vous expliquer rapidement comment obtenir les valeurs de correction d'erreur. Pour calculer ces erreurs, nous pouvons appeler la fonction personnalisée calculate_IMU_error() pendant que le capteur est en position immobile. Ici, nous effectuons 200 lectures pour toutes les sorties, nous les additionnons et les divisons par 200. Comme nous maintenons le capteur à plat, les valeurs de sortie attendues doivent être de 0. Ainsi, avec ce calcul, nous pouvons obtenir l'erreur moyenne du capteur. fait.

void calculate_IMU_error() {
  // We can call this funtion in the setup section to calculate the accelerometer and gyro data error. From here we will get the error values used in the above equations printed on the Serial Monitor.
  // Note that we should place the IMU flat in order to get the proper values, so that we then can the correct values
  // Read accelerometer values 200 times
  while (c < 200) {
    Wire.beginTransmission(MPU);
    Wire.write(0x3B);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU, 6, true);
    AccX = (Wire.read() << 8 | Wire.read()) / 16384.0 ;
    AccY = (Wire.read() << 8 | Wire.read()) / 16384.0 ;
    AccZ = (Wire.read() << 8 | Wire.read()) / 16384.0 ;
    // Sum all readings
    AccErrorX = AccErrorX + ((atan((AccY) / sqrt(pow((AccX), 2) + pow((AccZ), 2))) * 180 / PI));
    AccErrorY = AccErrorY + ((atan(-1 * (AccX) / sqrt(pow((AccY), 2) + pow((AccZ), 2))) * 180 / PI));
    c++;
  }
  //Divide the sum by 200 to get the error value
  AccErrorX = AccErrorX / 200;
  AccErrorY = AccErrorY / 200;
  c = 0;
  // Read gyro values 200 times
  while (c < 200) {
    Wire.beginTransmission(MPU);
    Wire.write(0x43);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU, 6, true);
    GyroX = Wire.read() << 8 | Wire.read();
    GyroY = Wire.read() << 8 | Wire.read();
    GyroZ = Wire.read() << 8 | Wire.read();
    // Sum all readings
    GyroErrorX = GyroErrorX + (GyroX / 131.0);
    GyroErrorY = GyroErrorY + (GyroY / 131.0);
    GyroErrorZ = GyroErrorZ + (GyroZ / 131.0);
    c++;
  }
  //Divide the sum by 200 to get the error value
  GyroErrorX = GyroErrorX / 200;
  GyroErrorY = GyroErrorY / 200;
  GyroErrorZ = GyroErrorZ / 200;
  // Print the error values on the Serial Monitor
  Serial.print("AccErrorX: ");
  Serial.println(AccErrorX);
  Serial.print("AccErrorY: ");
  Serial.println(AccErrorY);
  Serial.print("GyroErrorX: ");
  Serial.println(GyroErrorX);
  Serial.print("GyroErrorY: ");
  Serial.println(GyroErrorY);
  Serial.print("GyroErrorZ: ");
  Serial.println(GyroErrorZ);
}Code language: Arduino (arduino)

Nous imprimons simplement les valeurs sur le moniteur série et une fois que nous les connaissons, nous pouvons les implémenter dans le code comme indiqué précédemment, à la fois pour le calcul du roulis et du tangage, ainsi que pour les 3 sorties du gyroscope.

Enfin, en utilisant la fonction Serial.print, nous pouvons imprimer les valeurs de roulis, de tangage et de lacet sur le moniteur série et voir si le capteur fonctionne correctement.

Suivi d'orientation MPU6050 - Visualisation 3D

Ensuite, pour créer l'exemple de visualisation 3D, il nous suffit d'accepter ces données que l'Arduino envoie via le port série dans l'environnement de développement de traitement. Voici le code de traitement complet :

/*
    Arduino and MPU6050 IMU - 3D Visualization Example 
     by Dejan, https://howtomechatronics.com
*/
import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;
Serial myPort;
String data="";
float roll, pitch,yaw;
void setup() {
  size (2560, 1440, P3D);
  myPort = new Serial(this, "COM7", 19200); // starts the serial communication
  myPort.bufferUntil('\n');
}
void draw() {
  translate(width/2, height/2, 0);
  background(233);
  textSize(22);
  text("Roll: " + int(roll) + "     Pitch: " + int(pitch), -100, 265);
  // Rotate the object
  rotateX(radians(-pitch));
  rotateZ(radians(roll));
  rotateY(radians(yaw));
  
  // 3D 0bject
  textSize(30);  
  fill(0, 76, 153);
  box (386, 40, 200); // Draw box
  textSize(25);
  fill(255, 255, 255);
  text("www.HowToMechatronics.com", -183, 10, 101);
  //delay(10);
  //println("ypr:\t" + angleX + "\t" + angleY); // Print the values to check whether we are getting proper values
}
// Read data from the Serial Port
void serialEvent (Serial myPort) { 
  // reads the data from the Serial Port up to the character '.' and puts it into the String variable "data".
  data = myPort.readStringUntil('\n');
  // if you got any bytes other than the linefeed:
  if (data != null) {
    data = trim(data);
    // split the string at "/"
    String items[] = split(data, '/');
    if (items.length > 1) {
      //--- Roll,Pitch in degrees
      roll = float(items[0]);
      pitch = float(items[1]);
      yaw = float(items[2]);
    }
  }
}Code language: Arduino (arduino)

Ici, nous lisons les données entrantes de l'Arduino et les mettons dans les variables Roll, Pitch et Yaw appropriées. Dans la boucle de dessin principale, nous utilisons ces valeurs pour faire pivoter l'objet 3D, dans ce cas, il s'agit d'une simple boîte avec une couleur particulière et du texte dessus.

Si nous exécutons l'esquisse, nous pouvons voir à quel point le capteur MPU6050 est bon pour le suivi de l'orientation. L'objet 3D suit l'orientation du capteur de manière assez précise et il est également très réactif.

Comme je l'ai mentionné, le seul inconvénient est que le Yaw va dériver avec le temps car nous ne pouvons pas utiliser le filtre complémentaire pour cela. Pour améliorer cela, nous devons utiliser un capteur supplémentaire. Il s'agit généralement d'un magnétomètre qui peut être utilisé comme correction à long terme de la dérive de lacet du gyroscope. Cependant, le MPU6050 possède en fait une fonctionnalité appelée processeur de mouvement numérique qui est utilisée pour les calculs embarqués des données et qui est capable d'éliminer la dérive de lacet.

Voici le même exemple 3D avec le processeur de mouvement numérique utilisé. Nous pouvons voir à quel point le suivi de l'orientation est maintenant précis, sans la dérive de lacet. Le processeur embarqué peut également calculer et produire des quaternions qui sont utilisés pour représenter les orientations et les rotations d'objets en trois dimensions. Dans cet exemple, nous utilisons en fait des quaternions pour représenter l'orientation qui ne souffre pas non plus du verrouillage de cardan qui se produit lors de l'utilisation des angles d'Euler.

Néanmoins, obtenir ces données du capteur est un peu plus compliqué que ce que nous avons expliqué précédemment. Tout d'abord, nous devons connecter un fil supplémentaire à une broche numérique Arduino. C'est une broche d'interruption qui est utilisée pour lire ce type de données à partir du MPU6050.

Le code est également un peu plus compliqué, c'est pourquoi nous allons utiliser la bibliothèque i2cdevlib de Jeff Rowberg. Cette bibliothèque peut être téléchargée à partir de GitHub et j'inclurai un lien vers l'article du site Web.

Une fois que nous avons installé la bibliothèque, nous pouvons ouvrir l'exemple MPU6050_DMP6 à partir de la bibliothèque. Cet exemple est bien expliqué avec des commentaires pour chaque ligne.

Ici, nous pouvons sélectionner le type de sortie que nous voulons, les quaternions, les angles d'Euler, le lacet, le tangage et le roulis, la valeur des accélérations ou les quaternions pour la visualisation 3D. Cette bibliothèque comprend également une esquisse de traitement pour l'exemple de visualisation 3D. Je l'ai juste modifié pour obtenir la forme de la boîte comme dans l'exemple précédent. Voici le code de traitement de visualisation 3D qui fonctionne avec l'exemple MPU6050_DPM6, pour la sortie "OUTPUT_TEAPOT" sélectionnée :

/*
    Arduino and MPU6050 IMU - 3D Visualization Example 
     by Dejan, https://howtomechatronics.com
*/
import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;
Serial myPort;
String data="";
float roll, pitch,yaw;
void setup() {
  size (2560, 1440, P3D);
  myPort = new Serial(this, "COM7", 19200); // starts the serial communication
  myPort.bufferUntil('\n');
}
void draw() {
  translate(width/2, height/2, 0);
  background(233);
  textSize(22);
  text("Roll: " + int(roll) + "     Pitch: " + int(pitch), -100, 265);
  // Rotate the object
  rotateX(radians(-pitch));
  rotateZ(radians(roll));
  rotateY(radians(yaw));
  
  // 3D 0bject
  textSize(30);  
  fill(0, 76, 153);
  box (386, 40, 200); // Draw box
  textSize(25);
  fill(255, 255, 255);
  text("www.HowToMechatronics.com", -183, 10, 101);
  //delay(10);
  //println("ypr:\t" + angleX + "\t" + angleY); // Print the values to check whether we are getting proper values
}
// Read data from the Serial Port
void serialEvent (Serial myPort) { 
  // reads the data from the Serial Port up to the character '.' and puts it into the String variable "data".
  data = myPort.readStringUntil('\n');
  // if you got any bytes other than the linefeed:
  if (data != null) {
    data = trim(data);
    // split the string at "/"
    String items[] = split(data, '/');
    if (items.length > 1) {
      //--- Roll,Pitch in degrees
      roll = float(items[0]);
      pitch = float(items[1]);
      yaw = float(items[2]);
    }
  }
}Code language: Arduino (arduino)

Donc, ici, en utilisant la fonction serialEvent(), nous recevons les quaternions provenant de l'Arduino, et dans la boucle de dessin principale, nous les utilisons pour faire pivoter l'objet 3D. Si nous exécutons l'esquisse, nous pouvons voir à quel point les quaternions sont bons pour faire pivoter des objets en trois dimensions.

Afin de ne pas surcharger ce tutoriel, j'ai placé le deuxième exemple, la plate-forme DIY Arduino Gimbal ou Self-Stabilizing, dans un article séparé.

N'hésitez pas à poser toute question liée à ce tutoriel dans la section des commentaires ci-dessous et n'oubliez pas de consulter ma collection de projets Arduino.

Comment configurer GRBL et contrôler la machine CNC avec Arduino Comment suivre l'orientation avec Arduino et l'accéléromètre ADXL345