Le problème, c'est que les interruptions sont chroniques, elles apparaissent chaque 20ms toutes les 1 à 2 ms. Même si on touche pas à la radio, le récepteur envoie les infos en continue =/

Ah je vois... Dans ce cas là comment je fais moi ^^ Si je peux pas debug par serial comment peux t-on faire autrement ?
Et juste au cas où, personne vois pourquoi de base ça ne marche pas ? 

Bonjour,

Depuis un moment je butte sur un problème: j'ai un bug dans mon code (jusque là tout paraît normal ^^ ) je debug donc comme d'habitude par le Serial histoire de voir ce qui ne va pas et surprise...
Enfin si on peut appeler ça comme tel. J'ai mis tout un panel de Serial.println(), et au final je n'ai que deux lettres qui apparaissent dans le moniteur série, alors que mes println comportent plus de 2 caractères. Quelque soit l'endroit ou il y a le premier println je n'ai que le deux premiers caractères.
Après quelques essaies j'ai pu déterminer que le problème se posait que quand j'appelle le fonction Radio.Initialisation()

Est-ce que quelqu'un a déjà eu ce problème ou saurait m'aider ?

Je poste les pages qui posent problème

Code:

#include <I2C.h>
#include <Servo.h>
#include "configuration.h"
#include "def.h"
#include <RADIOCOMMAND.h>
#include <QUADRICOPTER.h>

RADIOCOMMAND Radio;
//QUADRICOPTER Quadri(MOT_A_PIN, MOT_B_PIN, MOT_C_PIN, MOT_D_PIN, PULSE_MOTOR_WIDTH_MIN, PULSE_MOTOR_WIDTH_MAX, BATT_PIN, LED_BATT_PIN);

void setup()
{
  Serial.begin(9600);
  I2c.begin();
  I2c.setSpeed(1);
  Serial.println("nono");
  pinMode(Q_LED_GREEN, OUTPUT);
  pinMode(Q_LED_YELLOW, OUTPUT);
  pinMode(Q_LED_RED, OUTPUT);
  pinMode(MOT_A_PIN, OUTPUT);
  pinMode(MOT_B_PIN, OUTPUT);
  pinMode(MOT_C_PIN, OUTPUT);
  pinMode(MOT_D_PIN, OUTPUT);
  
  //Quadri.GyroInit();
  Serial.println("ppp");
  Radio.Initialisation();
}

void loop()
{
  int val = 2;

  //val = digitalRead(THROTTLE_PIN);
  Serial.println(val);
  /*Serial.print("\t");
  Serial.print(Radio.Pitch());
  Serial.print("\t");
  Serial.print(Radio.Roll());
  Serial.print("\t");
  Serial.println(Radio.Yaw());*/
  
  delay(10);
  
}

RADIOCOMMAND.h

Code:

#ifndef RADIO_H
#define RADIO_H

#include <Arduino.h>

//** définitions indispensables à la bibliothèque RADIOCOMMAND **//
// cablage du recepteur
// PORT K utilisé
#define RX_PORT PORTK
#define RX_PIN PINK
#define ROLL_PIN 0x01 // pin 0
#define PITCH_PIN 0x02 // pin 1
#define THROTTLE_PIN 0x04 // pin 2
#define YAW_PIN 0x08 // pin 3
#define AUX1_PIN 0x10 // pin 4
#define AUX2_PIN 0x20 // pin 5
#define AUX3_PIN 0x40 // pin 6
#define AUX4_PIN 0x80 // pin 7
#define Q_INIT_RX DDRK=0;PORTK=255
#define Q_INIT_RX_INT PCMSK2=255

#define RX_PIN0 PORTK&ROLL_PIN
#define RX_PIN1 PORTK&PITCH_PIN
#define RX_PIN2 PORTK&THROTTLE_PIN
#define RX_PIN3 PORTK&YAW_PIN
#define RX_PIN4 PORTK&AUX1_PIN
#define RX_PIN5 PORTK&AUX2_PIN
#define RX_PIN6 PORTK&AUX3_PIN
#define RX_PIN7 PORTK&AUX4_PIN

class RADIOCOMMAND
{
public:
RADIOCOMMAND(void);

void Initialisation(void);

uint8_t Throttle(void);
uint8_t Roll(void);
uint8_t Pitch(void);
uint8_t Yaw(void);
uint8_t Aux1(void);
uint8_t Aux2(void);
uint8_t Aux3(void);
uint8_t Aux4(void);
boolean MotorLock(void);

boolean isRTF(void);

//friend void __vector_11(RADIOCOMMAND *);

private:
uint8_t throttle;
uint8_t yaw;
uint8_t pitch;
uint8_t roll;
uint8_t aux1;
uint8_t aux2;
uint8_t aux3;
uint8_t aux4;
boolean motorLock;
};

#endif

RADIOCOMMAND.cpp

Code:

// radiocommand.cpp

#include <Arduino.h>
#include "RADIOCOMMAND.h"

RADIOCOMMAND::RADIOCOMMAND(void)
{
throttle = 0;
yaw = 0;
pitch = 0;
roll = 0;
motorLock = true;
}

void RADIOCOMMAND::Initialisation(void)
{
unsigned long pTime;
Serial.println("azerty");
boolean initialisationOn = true;
Serial.println("good1");
noInterrupts(); // pas d'interruption afin de ne pas perturber l'init
Serial.println("good2");
while(initialisationOn)
{Serial.println("good3");
if (!(RX_PIN0 || RX_PIN1 || RX_PIN2 || RX_PIN3 || RX_PIN4 || RX_PIN5 || RX_PIN6 || RX_PIN7))
{Serial.println("good4");
pTime = micros();
Serial.println("good5");
while ((!(RX_PIN0 || RX_PIN1 || RX_PIN2 || RX_PIN3 || RX_PIN4 || RX_PIN5 || RX_PIN6 || RX_PIN7)))
{Serial.println("good6");
if ((micros() - pTime) >= 5000)
{Serial.println("good7");
initialisationOn = false;
Serial.println("good8");
break;
}
}
}
}
interrupts();
Serial.println("good9");
Q_INIT_RX;
Serial.println("good10");
Q_INIT_RX_INT;
Serial.println("good11");
}

uint8_t RADIOCOMMAND::Throttle(void)
{
return RADIOCOMMAND::throttle;
}

uint8_t RADIOCOMMAND::Roll(void)
{
return RADIOCOMMAND::roll;
}

uint8_t RADIOCOMMAND::Pitch(void)
{
return RADIOCOMMAND::pitch;
}

uint8_t RADIOCOMMAND::Yaw(void)
{
return RADIOCOMMAND::yaw;
}

uint8_t RADIOCOMMAND::Aux1(void)
{
return RADIOCOMMAND::aux1;
}

uint8_t RADIOCOMMAND::Aux2(void)
{
return RADIOCOMMAND::aux2;
}

uint8_t RADIOCOMMAND::Aux3(void)
{
return RADIOCOMMAND::aux3;
}

uint8_t RADIOCOMMAND::Aux4(void)
{
return RADIOCOMMAND::aux4;
}

boolean RADIOCOMMAND::isRTF(void)
{
return (RADIOCOMMAND::motorLock) ? false : true;
}

/*void __vector_11(RADIOCOMMAND * rad) // routine d'interruption unique à toutes les interruptions
{ // interruptions utilisée uniquement pour le recepteur
static unsigned long previousTime;
static uint8_t currentInterruption = 0;
uint16_t largeurImpulsion = 0;

switch(currentInterruption)
{
// ROLL
case 0: previousTime = micros(); currentInterruption++; break;
case 1: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->roll = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

// PITCH
case 2: previousTime = micros(); currentInterruption++; break;
case 3: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->pitch = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

// THROTTLE
case 4: previousTime = micros(); currentInterruption++; break;
case 5: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->throttle = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

// YAW
case 6: previousTime = micros(); currentInterruption++; break;
case 7: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->yaw = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX1
case 8: previousTime = micros(); currentInterruption++; break;
case 9: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->aux1 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX2
case 10: previousTime = micros(); currentInterruption++; break;
case 11: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->aux2 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX3
case 12: previousTime = micros(); currentInterruption++; break;
case 13: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->aux3 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption++;
break;

//AUX4
case 14: previousTime = micros(); currentInterruption++; break;
case 15: largeurImpulsion = micros() - previousTime; //temps d'une pulse
// protection dépassements de temps d'impulsion
largeurImpulsion = (largeurImpulsion < 1000) ? 1000 : largeurImpulsion;
largeurImpulsion = (largeurImpulsion > 2000) ? 2000 : largeurImpulsion;
// conversion microseconde / byte
rad->aux4 = ((255.0/1000.0)*(largeurImpulsion) - 255);
currentInterruption = 0;
break;
}
}*/

Merci d'avance  

Bonsoir !

Ce soir je viens demander de l'aide à ceux qui ont déjà touché aux gyroscopes.
Je possède une CRIUS AIO PRO V1.1 . Elle comporte un gyro MPU-6050.
Après moult manipulations et tests, j'ai enfin réussi à récupérer les infos gyroscopiques et à recalculer tout ça sous forme d'un nombre proportionnel à l'angle . Victoire pour moi ! Finalement pas complètement  

J'ai fais une boucle qui met à jour l'angle courant, et je l'affiche par serial sur le pc. Je prend donc la carte en main et je la tourne au fur et a mesure. Jusque là tout fonctionne à vue d'oeil plutôt bien.
Je remet donc la carte bien à plat (comme elle était à l'initialisation) et (mauvaise) surprise... ça ne renvoit plus 0 (le nombre obtenu après init à plat). J'ai fais quelques mouvement plus ou moins rapide et le nombre change bien, le signe est bon en fonction du sens du mouvement, mais j'ai l'impression que l'évolution n'est pas linéaire...
De plus, si je bouge lentement sans à-coup la valeur n'évolue plus. J'ai donc essayé de baisser la valeur du dernier delay jusqu'à le supprimer et c'est encore pire, il ne détecte plus rien avant un bon coup franc sur la carte.
J'ai essayé d'obtenir une courbe avec processing mais je comprend pas la gestion du signe et des envoies sur 16bits... Ca me renvoie n'importe quoi quand ça passe sous 0.

Je poste donc le code en pièce jointe

Quelqu'un peut me dire pourquoi le gyroscope réagit comme ça ? Ou est-ce mon programme qui est faux ?

Merci d'avance à tous ceux qui pourront m'aider !

PS: le code complet concernant le gyroscope est dans la bibliothèque QUADRICOPTER

EDIT: Pour ceux qui ne peuvent pas télécharger le fichier (erreur 503) voici un lien http://dl.free.fr/cKKdG224k

Problème trouvé !

Pour information, quand on reset le gyrosocope, il faut mettre le bit à 1 dans le registre MPU6050_PWR_MGMT_1. Mais il faut pas oublier de le remettre à 0 !

Bonne journée à tous

Le reset physique ne change strictement rien... Par contre si j'enlève les lignes qui "reset" le capteur tout fonctionne... Je suppose donc que les registres du MPU sont gardés en mémoire en eeprom ?? et surtout que le fait de mettre le bit de reset à 1 fait redémarrer en boucle le gyro jusqu'à ce qu'il soit remit à 0...

En tout cas merci ! Encore un problème résolu

Bonjour,

Je m'excuse pour ce titre si peut explicite, mais je n'ai pas réussi à le résumer autrement....
Je m'explique donc:

Je fais un projet Quadricoptère avec une carte CRIUS AIO PRO v1.1 . Jusque là pas de souci.
J'ai donc essayé de récupérer les infos du gyroscope MPU-6050 dans un premier temps. J'ai eu tout un tas de problème dont les solutions m'ont été donné ici ^^ (et je vous en remercie)
Récemment je bloque sur la récupération de donnée par l'I²C de mon gyro. Mes programmes ne fonctionnent pas et je comprend pas pourquoi... (je profite pour faire un UP de mon topic ici )
Je me suis donc remis à la recherche de programme tout fait pour comprendre comment ça marche... et je suis tombé sur ce programme finalement. Hier soir il ne fonctionnait pas, je ré essaie ce matin ça fonctionne. Je réupload le mien juste après (en pièce jointe) qui ne fonctionne toujours pas. et depuis le seul qui voulait me donner quelque chose de correct, ne fonctionne plus...
J'avais sous la main le programme multi wii v2.1 , je le renvoie donc pour voir si ça veut bien marcher et comme par hasard... miracle celui ci fonctionne bien.
Après une série de tests et d'upload de tout un tas de programme, je me suis rendu compte que c'était mon programme personnel qui faisait que les suivant ne fonctionne plus.
Le seul moyen pour que je puisse les faire tous refonctionner après passage du mien, c'est d'uploader le multi wii d'abord...  

Cette fois encore j'ai besoin de votre expérience dans l'arduino  

Merci d'avance !!

Bonne nuit !

Je passe ici histoire d'une minute pour dire que moi aussi j'ai des problèmes avec ce MPU-6050 !
J'ai installé la biblio, et jai compilé ton code, je ne reçois en sortie que des 0...
(en théorie je n'ai pas de problème de câblage, j'utilise la CRIUS AIO PRO v1.1)

En espérant que ça fasse avancer le schmilblik  


EDIT: Maintenant ça fonctionne aussi pour moi... Oo

Bonne nuit =)

Hé bien voici une de magnifiques réponses ! 

C'est vrai que du point de vue "qui est fait quand" c'est tout à fait logique !
Je pense qu'il va falloir que j'adopte cette manière de raisonner moi 

Encore merci !

Bonjour,

Est-ce que quelqu'un qui a déjà codé quelque chose peut me dire pourquoi ceci

Code:

void GYROSCOPE::request_Zout(void)
{
// Récupération des 8 bits de poids fort
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_ZOUT_H);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, true);
while(Wire.available() < 0);
Zout = Wire.read();

Serial.print("Z= ");
Serial.println(Zout, DEC);

/* Récupération des 8 bits de poids faible
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_ZOUT_L);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, true);
while(Wire.available() < 0);
Zout |= Wire.read();*/
}

me renvoie toujours 0 dans Zout ???
Je ne m'en sors plus avec ce gyroscope... Je n'arrive à rien avec en orienté objet.

Voici les define que j'utilise:

Code:

//définition des adresses de registres
#define MPU6050_GYRO_XOUT_H 0x43   // R  
#define MPU6050_GYRO_XOUT_L 0x44   // R  
#define MPU6050_GYRO_YOUT_H 0x45   // R  
#define MPU6050_GYRO_YOUT_L 0x46   // R  
#define MPU6050_GYRO_ZOUT_H 0x47   // R  
#define MPU6050_GYRO_ZOUT_L 0x48   // R

#define WHO_AM_I 0x75 //R
#define MPU6050_PWR_MGMT_1 0x6B   // R/W
#define GYRO_CONFIG 0x1B  // RW

#define MPU6050_I2C_ADDRESS 0x68

Merci d'avance ! Moi je fais une pause avant destruction massive de matériel  

J'ai étudié les deux lib pour le pcf (skywodd et toi),

Chez skywodd il n'y a pas le Wire.begin() dans le constructeur. Chez toi il n'y a pas de Wire.begin() tout court 

J'ai donc fait plein de test et les résultats de tous mes tests indiquent que de l'I²C dans le constructeur de ma classe ça ne marche pas du tout... le programme plante tout le temps (même quand je met pas le Wire.begin()).
La seule solution que j'ai trouvé est de d'initialiser tout ça à la main, hors constructeur... J'aime pas je trouve pas ça très propre 

Une idée pour pouvoir utiliser l'i²C dans le constructeur ?

PS: ligne 40 de ta lib est-ce normal les double point virgule ? " return Wire.read();; "

Hmm j'hésite !

Je vais me contenter de cliquer sur le petit lien je crois x)

Bonjour !

Quand le téléchargement du zip nous renvoie une magnifique erreur 503 on doit faire quoi ^^

Bonsoir,

Est-ce que quelqu'un sait ou a déjà utilisé les communications séries et I²C dans une classe ? Et pourrait me dire comment faire, malgré tous mes tests je n'aboutis à rien !
Impossible de faire marcher mon MPU6050 par I²C et impossible de voir d'où ça vient parce que je n'arrive pas à faire fonctionner les com série à l'intérieur de ma classe.

Merci d'avance,

Bonne nuit

Si ça peut servir le prog principal et la class incriminée:

Code:

#include <Wire.h>
#include <Servo.h>
#include "configuration.h"
#include "def.h"
#include <RADIOCOMMAND.h>
#include <QUADRICOPTER.h>

RADIOCOMMAND Radio(THROTTLE_PIN, YAW_PIN, PITCH_PIN, ROLL_PIN, MOT_LOCK_PIN);
QUADRICOPTER Quadri(MOT_A_PIN, MOT_B_PIN, MOT_C_PIN, MOT_D_PIN, PULSE_MOTOR_WIDTH_MIN, PULSE_MOTOR_WIDTH_MAX, BATT_PIN, LED_BATT_PIN);

void setup()
{
  /*Serial.begin(9600);
Wire.begin();
  while (!Serial);
  
  Serial.println("TEST");*/
}

void loop()
{
  // Petit Check batterie
  if (Quadri.etatBatterie() == Q_BAT_HS)
    Quadri.LED_etatBatterie(Q_BLINK);
  
  // Condition de mise route
 // if (Quadri.motorsRotate() == false) // si tous les moteurs sont arrêtés
   // while (Radio.isRTF() == Q_NOT_READY_TO_FLY);// et que l'inter est actif : on attend
  
  /***************************/
  /* PHASE DE CONTROL DE VOL */
  /***************************/
  Quadri.setConsignesDeVol(/*quelque chose*/);
  Quadri.CorrectionsDeVol(/* éventuellement quelques chose *unknown 4 the moment* */);
  
  Serial.println("bah ouai ca marche =) ");
  
  delay(1000);
  
}

Code:

#ifndef GYROSCOPE_H
#define GYROSCOPE_H

#include <Arduino.h>
#include <Wire.h>

//définition des adresses de registres
#define MPU6050_GYRO_XOUT_H 0x43   // R  
#define MPU6050_GYRO_XOUT_L 0x44   // R  
#define MPU6050_GYRO_YOUT_H 0x45   // R  
#define MPU6050_GYRO_YOUT_L 0x46   // R  
#define MPU6050_GYRO_ZOUT_H 0x47   // R  
#define MPU6050_GYRO_ZOUT_L 0x48   // R

#define MPU6050_PWR_MGMT_1 0x6B   // R/W
#define GYRO_CONFIG 0x1B  // RW

#define MPU6050_I2C_ADDRESS 0x68

class GYROSCOPE
{
public:
GYROSCOPE(void); // only 4 motors

void Update(void);
void Initialisation(void);

void request_Xout(void);
void request_Yout(void);
void request_Zout(void);

private:
uint16_t Xout;
uint16_t Yout;
uint16_t Zout;
};

#endif //GYROSCOPE_H

Code:

// gyroscope.cpp

#include <Arduino.h>
#include <Wire.h>
#include "gyroscope.h"

GYROSCOPE::GYROSCOPE(void)
{
Serial.begin(9600);
Serial.println("azertyuio");
Wire.begin();
Initialisation();
}

void GYROSCOPE::Update(void)
{
request_Xout();
request_Yout();
request_Zout();
}

void GYROSCOPE::Initialisation(void)
{
//Wire.begin();
// COPIÉ COLLÉ DE MULTI WII
TWBR = ((16000000L / 400000L) - 16) / 2; // change the I2C clock rate to 400kHz
Serial.println("1");
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Serial.println("2");
Wire.write(MPU6050_PWR_MGMT_1);
Serial.println("3");
Wire.write(0x80);
Serial.println("4");
Wire.endTransmission(true);
Serial.println("5");
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_PWR_MGMT_1);
Wire.write(0x03); //PWR_MGMT_1    -- SLEEP 0; CYCLE 0; TEMP_DIS 0; CLKSEL 3 (PLL with Z Gyro reference)
Wire.endTransmission(false);

Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(GYRO_CONFIG);
Wire.write(0x18); //GYRO_CONFIG   -- FS_SEL = 3: Full scale set to 2000 deg/sec
Wire.endTransmission(true);
}

void GYROSCOPE::request_Xout(void)
{
// Récupération des 8 bits de poids fort
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_XOUT_H);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, false);
while(Wire.available() < 0);
Xout = Wire.read() << 8;

// Récupération des 8 bits de poids faible
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_XOUT_L);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, true);
while(Wire.available() < 0);
Xout |= Wire.read();
}

void GYROSCOPE::request_Yout(void)
{
// Récupération des 8 bits de poids fort
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_YOUT_H);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, false);
while(Wire.available() < 0);
Yout = Wire.read() << 8;

// Récupération des 8 bits de poids faible
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_YOUT_L);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, true);
while(Wire.available() < 0);
Yout |= Wire.read();
}

void GYROSCOPE::request_Zout(void)
{
// Récupération des 8 bits de poids fort
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_ZOUT_H);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, false);
while(Wire.available() < 0);
Zout = Wire.read() << 8;

// Récupération des 8 bits de poids faible
Wire.beginTransmission(MPU6050_I2C_ADDRESS);
Wire.write(MPU6050_GYRO_ZOUT_L);
Wire.endTransmission(false);

Wire.requestFrom(MPU6050_I2C_ADDRESS, 1, true);
while(Wire.available() < 0);
Zout |= Wire.read();
}

Ok, merci pour toutes ces réponses ! Problème résolu