Bonjour !!

J'explique mon problème:

Cela fait plusieurs mois que je suis sur un projet ou mon but est de simplement, à l'aide du célèbre gyroscope/acceleromètre MPU6050 et d'arduino, faire tourner ( ou rotater ) un objet sur Unity, le logiciel de création de jeux vidéo.

Du coup sur Unity tout est nickel, il récupère les valeurs de l'arduino et les applique sur l'objet ( un cube par exemple ), le problème est que le cube tourne bien mais se décale, c'est à dire que si je bouge le gyroscope disons de 20° sur la gauche puis de 40° en vertical etc et que je reviens à la position initiale du gyroscope, le cube lui n'est plus à sa position initiale.. Je me suis rendu compte après que les valeurs du gyroscope n'était plus à 0, le problème vient donc d'Arduino et du capteur..

Rentrons dans le vif du sujet, voilà comment le système devrait fonctionner:

Le capteur à sa position initiale, donc lorsque le programme démarre, renvoie comme valeurs pitch = 0 roll = 0 et raw = 0 ( ou plus simplement x = 0, y = 0 et z = 0)

Cette partie fonctionne, du coup si je tourne le capteurs sur la gauche, x va voir sa valeur augmenter ou diminuer et pareil pour les autres valeurs, en vertical y va changer.

Cette partie là aussi fonctionne maintenant imaginons que les valeurs valent x = 20, y = -30 et z = 5, et que je remet le capteur dans sa position initiale, les valeurs ne valent pas 0 mais des choses du genre x = 8 y = -17 et z = 1, alors qu'elle devrait me renvoyer 0..

Voilà mon problème se trouve là j'aimerais obtenir des valeurs fixe par rapport à la position initiale.

Voici le code:

/*
    MPU6050 Triple Axis Gyroscope & Accelerometer. Pitch & Roll & Yaw Gyroscope Example.
    Read more: http://www.jarzebski.pl/arduino/czujniki-i-sensory/3-osiowy-zyroskop-i-akcelerometr-mpu6050.html
    GIT: https://github.com/jarzebski/Arduino-MPU6050
    Web: http://www.jarzebski.pl
    (c) 2014 by Korneliusz Jarzebski
*/

#include <Wire.h>
#include <MPU6050.h>

MPU6050 mpu;


// Timers
unsigned long timer = 0;
float timeStep = 0.01;

// Pitch, Roll and Yaw values
float pitch = 0;
float roll = 0;
float yaw = 0;

void setup() 
{
  
  Serial.begin(115200);

  // Initialize MPU6050
  while(!mpu.begin(MPU6050_SCALE_2000DPS, MPU6050_RANGE_2G))
  {
    Serial.println("Could not find a valid MPU6050 sensor, check wiring!");
    delay(500);
  }
  
  // Calibrate gyroscope. The calibration must be at rest.
  // If you don't want calibrate, comment this line.
  mpu.calibrateGyro();

  // Set threshold sensivty. Default 3.
  // If you don't want use threshold, comment this line or set 0.
  mpu.setThreshold(1);
}

void loop()
{
  timer = millis();


  // READ DATA FROM DBP //////////
  ////////////////////////////////

  int dataFromDbp = Serial.read() - '0';
  if(dataFromDbp != 49) {

    if(dataFromDbp == 1) {   // IF DBP ASK TO CALIBRATE
      calibrate();
    }
    
  }

  ////////////////////////////////
  ////////////////////////////////
  

  // Read normalized values
  Vector norm = mpu.readNormalizeGyro();

  // Calculate Pitch, Roll and Yaw
  pitch = pitch + norm.YAxis * timeStep;
  roll = roll + norm.XAxis * timeStep;
  yaw = yaw + norm.ZAxis * timeStep;

  // Output raw
  Serial.print(" Pitch = ");
  Serial.print(pitch);
  Serial.print(" Roll = ");
  Serial.print(roll);  
  Serial.print(" Yaw = ");
  Serial.println(yaw);

  // Wait to full timeStep period
  delay((timeStep*1000) - (millis() - timer));
}


void calibrate() {
  pitch = 0;
  roll = 0;
  yaw = 0;
}

Du coup ce code est un code pris sur internet et adapté, c'est le 5ème type de système ( de librairie ) que j'essaie pour faire fonctionner correctement le MPU6050, et je trouve que c'est celui qui fonctionne le mieux et qui est le plus simple à comprendre, voilà voilà

la ligne mpu.setThreshold(1) sert à régler les valeurs que nous renvoie le capteur par rapport à la vitesse de rotation ( si on le tourne vite est-ce qu les valeurs changent ou pas, si on veut une précision max sur le moindre changement etc.. ) Le problème est que à mpu.setThreshold(0), les valeurs changent toutes seules alors que le capteur est immobile..

La partie: "READ DATA FROM DBP" sert à ce que si l'on envoie 1 au arduino, il va définir la position du capteur comme une position initiale, et donc remettre les valeurs du capteur à 0 en appelant la fonction calibrate()

Voilà j'implore votre aide !

Merci à tous d'avance !

Là, tu as un problème de précision et d'intégration de données.

Explications:

Ton gyroscope ne te donne pas une position mais une vitesse de rotation.

Par exemple, si ton gyroscope te dit x=2, cela signifie que sa vitesse de rotation est de 2°/s.

Imaginons que ton gyroscope te donne x=2 en permanence, cela signifie qu'il tourne en permanence à 2°/s.

Du coup, l'angle de celui-ci augmente de 2° toutes les secondes : 2, 4, 6, 8...

Au bout de 10.5 secondes, tu devrais alors avoir un angle de 21°.

En bref, on a : NouveauAngle = AncienAngle + VitesseRotation * Temps

C'est d'ailleurs le calcul que tu fais avec la ligne : pitch = pitch + norm.YAxis * timeStep

Maintenant, si ton gyroscopete donne x=-2, cela signifie qu'il tourne dans l'autre sens, à 2°/s.

Donc l'angle devrait décroitre progressivement, jusqu'à revenir à 0 si il te donne -2 pendant les 10.5 prochaines secondes.

Maintenant, revenons en aux problèmes :

Problème 1 : l'intégration:

Ton code fait une mesure toutes les 0.01 secondes et l'utilise pour ces calculs.

La mesure est supposée fixe pendant tout l’intervalle de mesure mais c'est faux...

En effet, la vitesse de rotation n'est jamais fixe mais peut varier plus ou moins.

Imaginons que ton capteur tourne de plus en plus vite, à chaque mesure, tu vas relever une vitesse plus élevée : 2.0°/s la première fois, 2.5°/s la seconde 3.0°/s la troisième fois et ainsi de suite.

Ce qui revient à faire des calculs avec une vitesse qui augmente par bond alors qu'en réalité, la vitesse augmente linéairement.

Pour résoudre ce problème, il faudrait faire des mesures plus souvent.

Mais attention... en faisant des mesures plus souvent, tu vas trouver des chiffres beaucoup plus faible, ce qui posera probablement des problèmes avec les float.

Problème 2 : la précision:

Un MPU-6050 est un petit circuit intégré à moins de 2€, il ne faut pas trop lui en demander...

La précision de celui-ci n'est pas absolue, la valeur mesurée ne correspond pas exactement à la réalité.

Serte, il ne va pas te donner +15°/s alors qu'il aurait du donner +22°/s mais il peut très bien donner +22.5°/s à la place de +22°/s.

----------

Sur les avions de lignes, on utilise une centrale inertielle qui enregistre toutes les accélérations et rotations pour en déduire le déplacement exacte de l'avion.

Ce type d'appareil coute plusieurs dizaines de milliers d'euros donc il ne faut pas pouvoir espérer faire la même chose avec un capteur à 1€ plus un arduino.

----------

Bref, essayes de jouer sur le paramètre threshold et timeStep pour essayer d'avoir de meilleurs résultat.

Et quand tu veux replacer ton objet à 0,0,0, il te suffit d'envoyer '1' à l'arduino pour qu'il fasse un reset de la position.

Super réponse bien détaillé je comprend mieux maintenant  ! 

J'ai à peu près compris mais du coup j'ai encore des questions

Premièrement je vais juste expliquer plus en détails ce sur quoi mon projet est censé aboutir: Avec plusieurs gyroscopes placés sur différentes parties du corps comme la main, l'avant bras, le bras, le torse etc, en bougeant, cela doit aussi bouger un personnage dans Unity. Donc pour l'instant ça bouge très bien, mais seulement au début puisque après il y a un décalage.. Donc je voudrais réaliser ça avec des mpu6050, si il y a des décalages au début qui sont constants ce n'est pas un souci, le problème c'est que ici les décalages s'accumulent très vite.. J'ai déjà vu ce genre de projet avec des gyroscopes placés sur le corps qui en bougeant bougeait en même temps certaines partie du corps sur l'ordinateur, ce n'était pas de si lourd projet que ça, cela devait être des TP d'étudiants ou dans le genre, donc je ne pense pas qu'il avait de super gyroscopes d'avions de ligne ( quoique peut être ).

Ensuite ma première question: Comme je l'ai dit plus haut, il y a déjà eu des projets de ce genre donc celui-ci devrait être possible sans autant de décalage ou peut être avec une autre méthode non ? Et on peut penser aussi aux gyroscopes dans les smartphones, par exemple avec une application qui nous dit lorsque le smartphone est sur une surface plate, c'est vraiment très précis et ce dans n'importe quel situation, et même dans certains jeux ou applications ça l'est, ont-ils de puissant gyroscopes minuscules ?

Et en vérité je n'aurais qu'une dernière question, après tes explications je doute maintenant beaucoup sur la compatibilité de mes gyroscopes et du projet, Est-ce que un projet dans ce genre est réalisable avec des MPU-6050 ? Parce que si on plie simplement l'avant bras et que sur l'écran le bras se tord en arrière à cause du manque de précision et/ou de rapidité du gyroscope, cela deviendra inquiétant..

Salut,

Pour faire suite au message de "Lorrio", je suis totalement d'accord sur le fait que tout composant a ses capacités et ses possibilités.

Ton projet et très intéressant et *faisable* avec les composants que tu as à ta disposition. Malheureusement, comme le dit "Lorrio", la précision est un fait, et il faut faire avec.

Le plus intéressant pour toi serait de refaire ta manip', en plaçant ton gyroscope sur un cube en papier ou carton n'importe, afin de te rendre compte du décalage.

Tu pourras aussi faire des mesures et comparer plusieurs gyroscopes du marché!

 Bye!

Hello. l'algo du gyro seul aboutit fatalement sur un décalage d'attitude (drift) à court terme, le conseil de Lorrio n'y changera donc rien. Pour corriger ce 'drift' faudra nécessairement filtrer puis combiner les mesures des deux capteurs : gyro + acceléro. Cela implique un algo totalement différent. Je te laisse googleler tout ça

-
Edité par MizAmbal 31 octobre 2017 à 15:44:52

En effet en recherchant j'ai trouvé ce code:

/* Copyright (C) 2012 Kristian Lauszus, TKJ Electronics. All rights reserved.

 This software may be distributed and modified under the terms of the GNU
 General Public License version 2 (GPL2) as published by the Free Software
 Foundation and appearing in the file GPL2.TXT included in the packaging of
 this file. Please note that GPL2 Section 2[b] requires that all works based
 on this software must also be made publicly available under the terms of
 the GPL2 ("Copyleft").

 Contact information
 -------------------

 Kristian Lauszus, TKJ Electronics
 Web      :  http://www.tkjelectronics.com
 e-mail   :  kristianl@tkjelectronics.com
 */

#include <Wire.h>
#include <Kalman.h> // Source: https://github.com/TKJElectronics/KalmanFilter

#define RESTRICT_PITCH // Comment out to restrict roll to ±90deg instead - please read: http://www.freescale.com/files/sensors/doc/app_note/AN3461.pdf

Kalman kalmanX; // Create the Kalman instances
Kalman kalmanY;

/* IMU Data */
double accX, accY, accZ;
double gyroX, gyroY, gyroZ;
int16_t tempRaw;

double gyroXangle, gyroYangle; // Angle calculate using the gyro only
double compAngleX, compAngleY; // Calculated angle using a complementary filter
double kalAngleX, kalAngleY; // Calculated angle using a Kalman filter

uint32_t timer;
uint8_t i2cData[14]; // Buffer for I2C data

// TODO: Make calibration routine

void setup() {
  Serial.begin(115200);
  Wire.begin();
#if ARDUINO >= 157
  Wire.setClock(400000UL); // Set I2C frequency to 400kHz
#else
  TWBR = ((F_CPU / 400000UL) - 16) / 2; // Set I2C frequency to 400kHz
#endif

  i2cData[0] = 7; // Set the sample rate to 1000Hz - 8kHz/(7+1) = 1000Hz
  i2cData[1] = 0x00; // Disable FSYNC and set 260 Hz Acc filtering, 256 Hz Gyro filtering, 8 KHz sampling
  i2cData[2] = 0x00; // Set Gyro Full Scale Range to ±250deg/s
  i2cData[3] = 0x00; // Set Accelerometer Full Scale Range to ±2g
  while (i2cWrite(0x19, i2cData, 4, false)); // Write to all four registers at once
  while (i2cWrite(0x6B, 0x01, true)); // PLL with X axis gyroscope reference and disable sleep mode

  while (i2cRead(0x75, i2cData, 1));
  if (i2cData[0] != 0x68) { // Read "WHO_AM_I" register
    Serial.print(F("Error reading sensor"));
    while (1);
  }

  delay(100); // Wait for sensor to stabilize

  /* Set kalman and gyro starting angle */
  while (i2cRead(0x3B, i2cData, 6));
  accX = (int16_t)((i2cData[0] << 8) | i2cData[1]);
  accY = (int16_t)((i2cData[2] << 8) | i2cData[3]);
  accZ = (int16_t)((i2cData[4] << 8) | i2cData[5]);

  // Source: http://www.freescale.com/files/sensors/doc/app_note/AN3461.pdf eq. 25 and eq. 26
  // atan2 outputs the value of -π to π (radians) - see http://en.wikipedia.org/wiki/Atan2
  // It is then converted from radians to degrees
#ifdef RESTRICT_PITCH // Eq. 25 and 26
  double roll  = atan2(accY, accZ) * RAD_TO_DEG;
  double pitch = atan(-accX / sqrt(accY * accY + accZ * accZ)) * RAD_TO_DEG;
#else // Eq. 28 and 29
  double roll  = atan(accY / sqrt(accX * accX + accZ * accZ)) * RAD_TO_DEG;
  double pitch = atan2(-accX, accZ) * RAD_TO_DEG;
#endif

  kalmanX.setAngle(roll); // Set starting angle
  kalmanY.setAngle(pitch);
  gyroXangle = roll;
  gyroYangle = pitch;
  compAngleX = roll;
  compAngleY = pitch;

  timer = micros();
}

void loop() {
  /* Update all the values */
  while (i2cRead(0x3B, i2cData, 14));
  accX = (int16_t)((i2cData[0] << 8) | i2cData[1]);
  accY = (int16_t)((i2cData[2] << 8) | i2cData[3]);
  accZ = (int16_t)((i2cData[4] << 8) | i2cData[5]);
  tempRaw = (int16_t)((i2cData[6] << 8) | i2cData[7]);
  gyroX = (int16_t)((i2cData[8] << 8) | i2cData[9]);
  gyroY = (int16_t)((i2cData[10] << 8) | i2cData[11]);
  gyroZ = (int16_t)((i2cData[12] << 8) | i2cData[13]);;

  double dt = (double)(micros() - timer) / 1000000; // Calculate delta time
  timer = micros();

  // Source: http://www.freescale.com/files/sensors/doc/app_note/AN3461.pdf eq. 25 and eq. 26
  // atan2 outputs the value of -π to π (radians) - see http://en.wikipedia.org/wiki/Atan2
  // It is then converted from radians to degrees
#ifdef RESTRICT_PITCH // Eq. 25 and 26
  double roll  = atan2(accY, accZ) * RAD_TO_DEG;
  double pitch = atan(-accX / sqrt(accY * accY + accZ * accZ)) * RAD_TO_DEG;
#else // Eq. 28 and 29
  double roll  = atan(accY / sqrt(accX * accX + accZ * accZ)) * RAD_TO_DEG;
  double pitch = atan2(-accX, accZ) * RAD_TO_DEG;
#endif

  double gyroXrate = gyroX / 131.0; // Convert to deg/s
  double gyroYrate = gyroY / 131.0; // Convert to deg/s

#ifdef RESTRICT_PITCH
  // This fixes the transition problem when the accelerometer angle jumps between -180 and 180 degrees
  if ((roll < -90 && kalAngleX > 90) || (roll > 90 && kalAngleX < -90)) {
    kalmanX.setAngle(roll);
    compAngleX = roll;
    kalAngleX = roll;
    gyroXangle = roll;
  } else
    kalAngleX = kalmanX.getAngle(roll, gyroXrate, dt); // Calculate the angle using a Kalman filter

  if (abs(kalAngleX) > 90)
    gyroYrate = -gyroYrate; // Invert rate, so it fits the restriced accelerometer reading
  kalAngleY = kalmanY.getAngle(pitch, gyroYrate, dt);
#else
  // This fixes the transition problem when the accelerometer angle jumps between -180 and 180 degrees
  if ((pitch < -90 && kalAngleY > 90) || (pitch > 90 && kalAngleY < -90)) {
    kalmanY.setAngle(pitch);
    compAngleY = pitch;
    kalAngleY = pitch;
    gyroYangle = pitch;
  } else
    kalAngleY = kalmanY.getAngle(pitch, gyroYrate, dt); // Calculate the angle using a Kalman filter

  if (abs(kalAngleY) > 90)
    gyroXrate = -gyroXrate; // Invert rate, so it fits the restriced accelerometer reading
  kalAngleX = kalmanX.getAngle(roll, gyroXrate, dt); // Calculate the angle using a Kalman filter
#endif

  gyroXangle += gyroXrate * dt; // Calculate gyro angle without any filter
  gyroYangle += gyroYrate * dt;
  //gyroXangle += kalmanX.getRate() * dt; // Calculate gyro angle using the unbiased rate
  //gyroYangle += kalmanY.getRate() * dt;

  compAngleX = 0.93 * (compAngleX + gyroXrate * dt) + 0.07 * roll; // Calculate the angle using a Complimentary filter
  compAngleY = 0.93 * (compAngleY + gyroYrate * dt) + 0.07 * pitch;

  // Reset the gyro angle when it has drifted too much
  if (gyroXangle < -180 || gyroXangle > 180)
    gyroXangle = kalAngleX;
  if (gyroYangle < -180 || gyroYangle > 180)
    gyroYangle = kalAngleY;

  /* Print Data */
#if 0 // Set to 1 to activate
  Serial.print(accX); Serial.print("\t");
  Serial.print(accY); Serial.print("\t");
  Serial.print(accZ); Serial.print("\t");

  Serial.print(gyroX); Serial.print("\t");
  Serial.print(gyroY); Serial.print("\t");
  Serial.print(gyroZ); Serial.print("\t");

  Serial.print("\t");
#endif

  Serial.print(roll); Serial.print("\t");
  Serial.print(gyroXangle); Serial.print("\t");
  Serial.print(compAngleX); Serial.print("\t");
  Serial.print(kalAngleX); Serial.print("\t");

  Serial.print("\t");

  Serial.print(pitch); Serial.print("\t");
  Serial.print(gyroYangle); Serial.print("\t");
  Serial.print(compAngleY); Serial.print("\t");
  Serial.print(kalAngleY); Serial.print("\t");

#if 0 // Set to 1 to print the temperature
  Serial.print("\t");

  double temperature = (double)tempRaw / 340.0 + 36.53;
  Serial.print(temperature); Serial.print("\t");
#endif

  Serial.print("\r\n");
  delay(2);
}

Le filtre Kalman a l'air assez connu, je ne comprend pas exactement son fonctionnement mais il y a moins voir même plus aucun 'drift'

D'ailleurs je ne vois pas trop la différence entre compAngle et kalAngle dans le programme, il n'y a pas trop de différences dans les résultats pourtant les calculs sont très différents entre les deux dans le programme...

Le gros problème est qu'il n'y a pas le calcul de "yaw", et donc pas de compAngleZ ni de kalAngleZ, et vu la complexité du programme pour avoir les valeurs en x et y, je serais incapable de déterminer z.. Avez vous des idées ? Les seules choses que j'ai trouvé sur internet sont des parties théoriques auxquels je ne comprend que très peu, ou trop peu de choses..

-
Edité par Playsky 31 octobre 2017 à 20:06:07

la flemme de lire un code de plus de 5 lignes ... Mais j'imagine que s'il fait l'impasse sur le calcul du yaw c'est qu'il doit utiliser en plus un magnétomètre pour le déterminer, c'est d'ailleurs la méthode plus efficace car elle permet de s'orienter au plus précis par rapport à l’environnement géographique, quelque soit l'angle de départ, et sans drift sur le long terme. Essaye les sources "mpu-6050.rar"de ce youtubeur : http://les-electroniciens.com/videos/la-centrale-inertielle-mpu-6050 Excellente chaine YT au passage, et en plus il répond aux commentaires

Malheureusement oui... Après de nombreuses recherches sur internet j'en conclue que:

Le MPU6050 ne dérive quasiment pas avec les pitch et roll ( très peu lorsqu'il y a des filtres et même sans on voit que même lorsqu'ils dérivent, ils reviennent assez rapidement en place et ne s'éloigne jamais trop.. ), mais le yaw part totalement en vrille et c'est pour ça que le mpu6050 est très souvent couplé à un magnétomètre, ou alors il existe des composants comme le mpu9250 qui a tout ( accéléromètre gyroscope magnétomètre )

Du coup un mpu9250 avec un programme qui récupère les valeurs et les filtre donnerait certainement quelque chose de vraiment bon avec des valeurs assez précises, pour la vitesse cela devrait être légèrement plus lent de ce que j'ai lu sur internet, m'enfin j'attend de tester ce composant.. ( Comme un débile j'ai acheté plusieurs mpu6050 alors que c'est le 9250 qu'il me faut )

Voilà de ce que je sais, merci pour vos réponses en tout cas !

-
Edité par Playsky 3 novembre 2017 à 0:18:33

Playsky a écrit:

Malheureusement oui... Après de nombreuses recherches sur internet j'en conclue que:

Le MPU6050 ne dérive quasiment pas avec les pitch et roll ( très peu lorsqu'il y a des filtres et même sans on voit que même lorsqu'ils dérivent, ils reviennent assez rapidement en place et ne s'éloigne jamais trop.. ), mais le yaw part totalement en vrille et c'est pour ça que le mpu6050 est très souvent couplé à un magnétomètre, ou alors il existe des composants comme le mpu9250 qui a tout ( accéléromètre gyroscope magnétomètre )

Du coup un mpu9250 avec un programme qui récupère les valeurs et les filtre donnerait certainement quelque chose de vraiment bon avec des valeurs assez précises, pour la vitesse cela devrait être légèrement plus lent de ce que j'ai lu sur internet, m'enfin j'attend de tester ce composant.. ( Comme un débile j'ai acheté plusieurs mpu6050 alors que c'est le 9250 qu'il me faut )

Voilà de ce que je sais, merci pour vos réponses en tout cas !

-
Edité par Playsky 3 novembre 2017 à 0:18:33

Salut , ton projet est très proche du mien, je veux deplacer un sac de boxe virtuel en fonction des données d’une centrale inertielle. Tu ne parles pas de la partie sur UNITY. Pourrais tu partager tes connaissances ?

bonjour

J'ai le même problème, je veux utiliser le module MPU6050 pour faire tourner un robot avec une angle de 90 degrée,mais le problème que la rotation sur l'axe z "yaw" n'est pas fixe et déclanche pas toujours à zero par contre les deux autres angles (pitch et roll) sont bien adaptées.

le changement de l'angle z est parfait il est adéquat avec se que j'ai besoin mais si je veux tourner avec une angle de 90 par raport l'angle initiale ça peut depasser le 180 (ou bien -180) et donne une valeur par défaut ex (si le gyroscope affiche -150 et si je veux tourner avec -90 mal fonctionnement)

j'utilise le programme qui combine l'acceleromètre avec le gyroscope. si quelq'un peut me aider à fixer à chaque fois la valeur de départ pour ne dépasse pas les limites (180 et -180) et merci..