Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Arduino] Connaître l'inclinaison avec un MPU-6050

    18 août 2013 à 12:33:54

    Bonjour,

    j'ai acquis ce composant https://www.sparkfun.com/products/11028 souhaitant connaître la position angulaire d'un système selon trois axes.
    Il y a quelque chose d'étrange il me semble ici : https://www.sparkfun.com/pages/accel_gyro_guide. On peut en effet lire "Gyroscopes measure angular velocity". Ce ne serait pas plutôt le rôle d'un gyromètre ?

    En tout cas, ce composant est également pourvu d'un accéléromètre.
    Il semblerait qu'il faille combiner les données du "gyro[...]" et de l'accéléromètre pour connaître l'angle cherché. ... ?
    Par ailleurs, la communication se fait par I²C. Je ne l'ai jamais utilisé. J'ai consulté cette page : http://fr.wikipedia.org/wiki/I2C. Je sais que l'on utilise Wire (enfin je crois :p ) pour établir ces communications avec l'Arduino.

    Pour faire simple, je suis plutôt perdu pour ce qui est de la résolution de mon problème.
    Pouvez m'aidez à mettre en œuvre le dispositif que je cherche à réaliser à partir du MPU-6050 ?

    Merci d'avance,
    Soaocohoa 

    -
    Edité par Soaocohoa 18 août 2013 à 12:34:29

    • Partager sur Facebook
    • Partager sur Twitter
      18 août 2013 à 16:23:54

      Tu vas poster un post par composant jusqu'à ce que ton drone vole ? :D

      Pour l'I²C, ce ne sont pas les exemples qui manque sur le web (avec effectivement la librairie Wire) et une simple recherche "Arduino [composant]" t'aurais donné ce premier résultat qui donne pas mal d'infos ! (notamment qu'il faut une alim 3.3V et éventuellement un level shifter pour les bonne tensions...) Personne n'est contre filer un coup de main, et tu parais investi dans ton projet, mais essaie de faire un peu plus de recherche avant de poser des questions si vague et auquel une simple recherche google donne pas mal d'infos...

      • Partager sur Facebook
      • Partager sur Twitter
        18 août 2013 à 17:09:11

        I need that one @.@ ... @Eskimon : est ce que tu pourrais donner plus d'informations sur ces "level shifter" ? :)
        • Partager sur Facebook
        • Partager sur Twitter
          18 août 2013 à 17:30:04

          nicolay1 : Ce n'est pas réellement le sujet, ouvre en un autre pour qu'on en parle ;)

          • Partager sur Facebook
          • Partager sur Twitter
            18 août 2013 à 19:12:46

            Merci pour la réponse.
            En fait, ce qui me gênait le plus était de savoir comment (même le principe) avoir l'inclinaison en "combinant" divers valeurs insolites retournées par l'appareil, car d'après ce que j'avais compris, on ne va pas lire : 30°, 60°, 90° ! :p 

            Une question sur une histoire de magnétomètre, et je devrais cesser cette frénétique création de sujets :)

            Merci :)

            EDIT : sous-entendu : je ne sais toujours pas comment je vais pouvoir déduire l'inclinaison => help !
            (merci :p
            Puis pour ce qui était bizarre dans les explications de Sparkfun... 

            -
            Edité par Soaocohoa 19 août 2013 à 1:14:13

            • Partager sur Facebook
            • Partager sur Twitter
              21 août 2013 à 15:58:05

              Comme tu sembles l'avoir compris (je ne sais pas si c'était très difficile :p), il est prévu de l'embarquer dans un engin volant.
              Différents points de la page que tu m'as donné ne sont pas très rassurant.
              Dès le début :

              "It can be easy, or not.

              Voilà le problème suivant :

              "The raw values changes a lot due to a number of reasons. The default sensitivity is high, and the sensor returnes 16 bits, but the actual valid number of bits is less than 16 bits. Since they are 16 bits, a variation of 50 is just a very small variation.

              The next measurement were done in these conditions:

              • The sensor was placed as horizontal as possible.
              • It was placed on concreet, not a wooden table.
              • During the measurements, there was no traffic in the street.
              • An battery of 12V was used, not the less stable voltage from the USB bus. I used a battery instead of an adapter to avoid any mains noise.
              • The circuit was on for 15 minutes, to stabalize any temperature influence.
              • The room temperature was 25 degrees Celcius."
              Il n'est pas prévu qu'il y ait des conditions de laboratoires avec tous les paramètres réglés précisément dans l'engin !
              Il n'est pas non plus prévu de démarrer le circuit un quart d'heure avant de démarrer l'appareil. En bref, tout ce qui est écrit dans ce paragraphe semble impensable.

              Si j'ai compris, il faut que j'utilise la classe (apparemment inachevé mais j'espère suffisante pour ce que je veux faire) écrite par Jeff Rowberg ?
              Cela a l'air plutôt vaste... :p
              Je n'arrive pas vraiment à voir comment je vais faire... 
              Pour un problème avec le NFC, la solution était que comme ce n'était pas indispensable, je pouvais m'en passer pour le moment.
              Mais là je crois que le gyroscope, gyromètre, accéléromètre ou je ne sais plus quoi est indispensable !

              Conclusion : · · · — — — · · ·

              -
              Edité par Soaocohoa 21 août 2013 à 15:58:56

              • Partager sur Facebook
              • Partager sur Twitter
                21 août 2013 à 17:17:12

                à priori son code à l'air plutot... pas mal ^^ faut juste arriver à installer les deux librairies I2Cdev et MPU6050 :
                #include "I2Cdev.h"
                #include "MPU6050.h"
                vu que wire est par défaut installé ta pas à t'en préoccuper :)
                • Partager sur Facebook
                • Partager sur Twitter
                  21 août 2013 à 18:28:57

                  Soaocohoa a écrit:

                  Comme tu sembles l'avoir compris (je ne sais pas si c'était très difficile :p), il est prévu de l'embarquer dans un engin volant.
                  Différents points de la page que tu m'as donné ne sont pas très rassurant.
                  Dès le début :

                  "It can be easy, or not.

                  Voilà le problème suivant :

                  "The raw values changes a lot due to a number of reasons. The default sensitivity is high, and the sensor returnes 16 bits, but the actual valid number of bits is less than 16 bits. Since they are 16 bits, a variation of 50 is just a very small variation.

                  The next measurement were done in these conditions:

                  • The sensor was placed as horizontal as possible.
                  • It was placed on concreet, not a wooden table.
                  • During the measurements, there was no traffic in the street.
                  • An battery of 12V was used, not the less stable voltage from the USB bus. I used a battery instead of an adapter to avoid any mains noise.
                  • The circuit was on for 15 minutes, to stabalize any temperature influence.
                  • The room temperature was 25 degrees Celcius."
                  Il n'est pas prévu qu'il y ait des conditions de laboratoires avec tous les paramètres réglés précisément dans l'engin !
                  Il n'est pas non plus prévu de démarrer le circuit un quart d'heure avant de démarrer l'appareil. En bref, tout ce qui est écrit dans ce paragraphe semble impensable.
                  -
                  Edité par Soaocohoa il y a environ 1 heure

                  Tout instrument de mesure possède des conditions d'utilisation qui permettent 2 choses principales :

                  - Les conditions de test (25°C, alimentation stable, etc) permettent d'avoir des conditions idéales pour faire des relevés précis des caractéristiques du composant ainsi que pouvoir les reproduire le cas échéant.

                  - Garantir une plage de fonctionnement : le fabricant s'engage à ce que le composant fonctionne correctement dans une plage de température, de tension, etc. Toute mesure effectuée en dehors de ces conditions de fonctionnement n'est pas garantie comme "bonne".

                  Pour revenir à ton composant : 

                  Il a une précision de 16 bits mais en fait il faut utiliser beaucoup moins de bits pour avoir des mesures utiles, car la précision est trop grande et si tu utilise les 16 bits tu va avoir des valeurs différentes simplement lorsqu'une voiture passe dans la rue... A toi de voir la précision dont tu as besoin et d'utiliser le nombre de bits correspondant.

                  Pour la température c'est tout à fait normal, le composant atteindra sa précision maximale lorsque sa température sera stabilisée. J'ai utilisé un appareil de mesure qui nécessité vraiment de chauffer pendant au moins 30 minutes, sinon entre la calibration (on va dire à t0 + 5 min) et le moment où tu fais tes mesures (on va dire t0 + 15 min) ton "0" a pu bouger on va dire de 100 mA facilement, ce qui peut être gênant quand c'est la précision de la mesure que tu veux faire. (L'appareil était une pince ampèremétrique). Si tu utilise les 8 MSB, il se peut que les valeurs renvoyées pendant la stabilisation de la température ne soient pas trop affectées, mais faut faire des tests.

                  La température ne joue pas forcément en soi (si le composant est capable de la corriger) mais ce sont les variations qui sont chiantes, car même si le composant corrige les résultats selon la température, il va mettre un certain temps. Tu peux très bien avoir un fonctionnement correct à 50°C en permanence et des résultats de merde lorsque la température varie rapidement et en permanence entre 10 et 30°C.

                  Enfin pour l'alimentation, bah en général un appareil de mesure à parfois besoin d'une tension de référence : si ta référence n'est pas stable, tes résultats ne seront pas stables non plus. Selon la précision dont tu as besoin, prendre une référence de tension peut être utile.
                  • Partager sur Facebook
                  • Partager sur Twitter
                    21 août 2013 à 20:03:00

                    Merci pour vos réponses. Je vois.


                    "à priori son code à l'air plutot... pas mal"
                    Je ne remet pas en cause son code ^^
                    ... mais mes aptitudes à arriver à en faire quelque chose.
                    Comme vous le voyez mon problème initial est simple.
                    Par exemple, je veux connaître une distance. Je trouve ce capteur : http://snootlab.com/adafruit/294-capteur-de-distance-maxbotix-lv-ez1-ez-1.html, j'arrive rapidement à l'utiliser. Je veux stocker des données. J'achète des 24LC128. Je ne connais pas l'I²C. Pourtant je trouve ce tutoriel :

                    http://tronixstuff.com/2010/10/20/tutorial-arduino-and-the-i2c-bus/
                    http://tronixstuff.com/2010/10/29/tutorial-arduino-and-the-i2c-bus-part-two/ 

                    et mon problème est résolu.

                    Là, je voudrais connaître l'inclinaison d'un système selon trois axes... J'achète un MPU-6050... Aïe, je n'arrive même pas à comprendre comment je peux envisager d'apprendre ce qu'il faut que je fasse pour pouvoir espérer y arriver peut-être... un jour. Pourtant j'en ai vraiment besoin. :euh:

                    C'est la raison de ce sujet. 

                    Merci :):):)

                    -
                    Edité par Soaocohoa 21 août 2013 à 20:04:15

                    • Partager sur Facebook
                    • Partager sur Twitter
                      22 août 2013 à 15:53:33

                      ah ^^ bah... => http://www.invensense.com/mems/gyro/documents/RM-MPU-6000A.pdf p7 :D par exemple pour lire la valeur de la composante de mg sur x il faut lire les registres à l'adresse 3B et 3C :) sachant qu'a la fin ça doit te donner un truc comme ça :

                      byte lowXAcc;
                      byte higXAcc;
                      higXAcc=SPI_read(0x3B);
                      lowXAcc=SPI_read(0x3C);
                      int valXAcc=0;
                      valXAcc=(higXAcc<<8)|lowXAcc;

                      note : j'ai jamais utilisé la librairie wire donc je connais pas les fonctions pour lire les data :/ "byte SPI_read(int)" n'existe très certainement pas ^^' regarde ce tuto, il t'expliquera comment procéder pour lire dans tes registres : http://www.hobbytronics.co.uk/arduino-external-eeprom

                      Une fois que ta les 6 axes bah... c'est de la géométe dans l'espace :/

                      -
                      Edité par nicolay1 22 août 2013 à 16:00:43

                      • Partager sur Facebook
                      • Partager sur Twitter
                        23 août 2013 à 19:12:45

                        "Pourtant je trouve ce tutoriel :

                        http://tronixstuff.com/2010/10/20/tutorial-arduino-and-the-i2c-bus/

                        http://tronixstuff.com/2010/10/29/tutorial-arduino-and-the-i2c-bus-part-two/"

                        Il explique la même chose que le lien que tu m'as passé il me semble ^^
                        Donc pour ce point, c'est OK.

                        Mais j'en reviens en premier lieu à une de mes premières questions.
                        "Il y a quelque chose d'étrange il me semble ici : https://www.sparkfun.com/pages/accel_gyro_guide. On peut en effet lire "Gyroscopes measure angular velocity". Ce ne serait pas plutôt le rôle d'un gyromètre ?"

                        Si je ne sais même pas ce que je vais mesurer au final, c'est problématique pour débuter.
                        Puis il vaut mieux que je manipule le composant en utilisant la classe de Jeff Rowberg non 

                        Lorsque j'essaie de chercher, je me perds encore plus : je ne sais pas exactement quoi chercher, je ne trouve rien de clair qui puisse réellement m'aider...
                        En fait, concrètement... est-ce que quelqu'un y comprend quelque chose ? :p

                        • Partager sur Facebook
                        • Partager sur Twitter
                          23 août 2013 à 20:55:11

                           http://fr.wikipedia.org/wiki/Gyromètre  Paragraphe Définition.

                          Ensuite pour ton composant vu qu'on parle de degrés par seconde (°/s) cela correspond à une vitesse angulaire.

                          Oui c'est clair pour moi : tu as un gyroscope + accéléromètre dont tu peux récupérer les données par I2C ou SPI.

                          Maintenant ton problème c'est qu'en fait tu veux faire un drone mais tu ne sais pas vraiment à quoi servent les valeurs que tu veux récupérer. Ou alors tu veux récupérer certaines valeurs mais tu ne sais pas à quoi elles correspondent et tu ne sais donc pas quel capteur il te faut.

                          • Partager sur Facebook
                          • Partager sur Twitter
                            23 août 2013 à 22:33:47

                            "http://fr.wikipedia.org/wiki/Gyromètre  Paragraphe Définition.

                            Ensuite pour ton composant vu qu'on parle de degrés par seconde (°/s) cela correspond à une vitesse angulaire."

                            ... Euh... Tu ne te contredis pas tout seul ? En fait tu as écrit (il me semble, en résumé) : "ce qui écrit correspond à un gyromètre donc c'est un gyroscope"... N'est-ce pas un raisonnement quelque peu singulier ? 

                            "Maintenant ton problème c'est qu'en fait tu veux faire un drone"
                            Peut-on rester sur le sujet ? Ici, ce n'est pas la question. 
                            "mais tu ne sais pas vraiment à quoi servent les valeurs que tu veux récupérer. Ou alors tu veux récupérer certaines valeurs mais tu ne sais pas à quoi elles correspondent
                            Exprimé de façon plus simple et plus exacte (j'écris cela car je pense connaître mon problème :p ) : je veux connaître l'inclinaison autour de trois axes, si cela est mal formulé, alors formulons-le de façon encore moins correcte, il n'y aura pas de doute sur le caractère intelligible : "je voudrais savoir comment est penché le capteur". "tu ne sais donc pas quel capteur il te faut"... J'aurais une légère tendance à parier beaucoup que ce capteur peut permettre de résoudre mon problème.

                            Maintenant, je ne sais pas comment, c'est pour cela que je demande votre aide. Merci d'avance.

                            • Partager sur Facebook
                            • Partager sur Twitter
                              23 août 2013 à 22:35:43

                              moi à ta place je me mettrais pas zeqL à dos, c'est quand même une des pointures du forum électronique... :-°

                              • Partager sur Facebook
                              • Partager sur Twitter
                                23 août 2013 à 22:43:54

                                Mais je ne dis pas qu'il est incompétent ! Vu mon niveau, je ne risque pas de me le permettre :p
                                Pour la définition, ce que je dis n'est pas faux.

                                ""Maintenant ton problème c'est qu'en fait tu veux faire un drone"
                                Peut-on rester sur le sujet ? Ici, ce n'est pas la question. "

                                D'accord, j'aurais pu noyer cela dans plusieurs ligne pour que la formulation puisse paraître plus sympathique.
                                Etant personnellement, je pense, peu susceptible de m'arrêter sur les formulations, je préfère être plus direct, cela fait économiser un temps précieux à tout le monde.
                                Enfin (je continue de chercher ce qui pourrait poser problème dans mon message), je ne remet pas en cause les facultés de quiconque à comprendre à un problème (si personne ne le comprend, le problème, c'est peut-être plutôt moi, le problème :p ), je veux juste être simple... Et ce n'est pas évident quand tout semble compliqué.

                                Merci

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  23 août 2013 à 22:46:47

                                  "Maintenant ton problème c'est qu'en fait tu veux faire un drone"
                                  Si vous tenez tant à en parler : ce capteur est un point majeur, arriver à l'utiliser ou pas est décisif pour mon projet.
                                  J'ai donc plus ou moins mon projet (sur lequel je réfléchis depuis longtemps) qui dépend de ce sujet. C'est pourquoi j'espère vraiment que quelqu'un pourra m'aider.

                                  EDIT : Je viens de tomber sur ce message par hasard :

                                  Eskimon a écrit:

                                  nicolay1 : Ce n'est pas réellement le sujet, ouvre en un autre pour qu'on en parle ;)


                                  Mis à part qu'il y a une émoticône à la fin, cette phrase m'en rappelle étrangement une autre :p 

                                  -
                                  Edité par Soaocohoa 23 août 2013 à 22:49:46

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    23 août 2013 à 23:19:49

                                    Bon voilà je pensais que j'allais passer genre 1/2h ou plus à te répondre, en fait non, 3 minutes à ouvir la datasheet et à trouver ce dont tu as besoin :

                                    page 21 de la datasheet en bas à droite (ou aussi page 44)

                                    Mais effectivement il manque les registres I2C pour savoir comment récupérer les infos. Un petit tour sur le site du fabriquant : http://www.invensense.com/mems/gyro/catalog.html -> MPU-6050 et tu télécharge le pdf "RM" (qui est commun avec le MPU-6000).

                                    Ensuite tu verras qu'il y a des registres pour récupérer les valeurs du gyroscope et de l'accéléromètre sur chacun des 3 axes.

                                    Le problème c'est que tu as ouvert 50 000 milliards de posts sur le forum électronique ainsi qu'un post sur le forum maths. Tu pars dans toutes les directions en même temps et tu ne prend pas le temps de lire les datasheet ou les infos qu'on peut trouver sur le net. Enfin tu va me dire oui tu lis, mais il y a lire et lire : lire et comprendre le mot, ok ca tout le monde le fait, mais lire et comprendre la phrase et le paragraphe ca c'est autre chose. Je passe mon temps à lire de la doc plus ou moins complexe, parfois je lis pour lire, j'ai compris le sens mais je n'ai pas pris de recul pour bien comprendre.

                                    La documentation donnée, en parcourant vite fait semble bien fournie et assez bien aérée, ce qui facilite la compréhension. Et il n'y a qu'une cinquantaine de pages.

                                    Sur le projet sur lequel je suis, la documentation du microprocesseur fait 1500 pages et est en version préliminaire (le processeur n'a pas encore été envoyé à la fonderie), et il y a une fonction, le DMA, que l'on veut utiliser avec un FPGA. Sur ces 1500 pages le chapitre DMA doit faire moins de 50 pages avec pas mal de chronogrammes. Et bien pendant plusieurs jours on essayait de décortiquer le sens de plusieurs phrases pour être sûr d'avoir bien compris et de ne pas foirer la carte. Pour cela, on relis toute la partie DMA et on essaie de trouver les endroits où ils parlent des choses sur lesquelles on a un doute et on essaie de mettre ces morceaux ensemble pour voir s'il n'y a pas de contradiction et arriver à un consensus.

                                    Je m'étais dit : on va poser la question au fabriquant pour être sûr mais nan, finalement avec un peu de temps, et d'utilisation du cerveau, et bien on trouve la réponse, alors oui ce n'est pas sûr à 100%, et peut-être que la question sera posée quand même pour avoir une certaine garantie, mais ce n'était pas non plus une perte de temps inutile car derrière en se penchant vraiment sur la doc, tu comprend beaucoup mieux.

                                    Donc poses-toi un peu, un drone ca ne se fait pas en 1 mois surtout si on est débutant et pas à plein temps dessus. Le temps que tu va perdre à essayer de bien comprendre ne sera pas du temps perdu, sur tes prochains projets tu gagnera du temps car tu saura les infos dont tu as besoin dans la datasheet pour déjà faire du tri. Et au fur et à mesure que tu auras de l'expérience, tu repérera les sociétés qui font de bonnes datasheet, donnent pas mal d'infos, de celles qui font le minimum syndical et enfin d'obscures sociétés chinoises qui fournissent un semblant de datasheet inutilisable et qui font regretter l'économie de 3€...

                                    -
                                    Edité par zeqL 23 août 2013 à 23:35:07

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      24 août 2013 à 0:35:21

                                      [[Ceci est une grande parenthèse entre crochets

                                      Je te remercie de bien vouloir passer "1/2 h ou plus à me répondre".
                                      Par contre ce n'est pas évident de lire l'explication parsemée de diverses remarques. 
                                      "Donc poses-toi un peu, un drone ca ne se fait pas en 1 mois". Je suis conscient des risques du projet.
                                       "Le problème c'est que tu as ouvert 50 000 milliards de posts sur le forum électronique ainsi qu'un post sur le forum maths."
                                      Tu y es presque ! :p
                                      Mais tu oublies divers messages sur le forum de C++ (d'ailleurs il faut que j'en poste un :p), un message sur le forum Windows, et de très nombreux messages sur d'autres sites :D

                                      Je ne suis pas ingénieur conception électronique et je n'ai pas fait 5 ans d'école d'ingénieur.
                                      Je suis lycéen.

                                      Ce composant est vraisemblablement le plus compliqué que j'ai à utiliser.]]

                                      Donc,
                                      réponse au message :

                                      zeqL a écrit:

                                      [...] ce dont tu as besoin :

                                      page 21 de la datasheet en bas à droite (ou aussi page 44)

                                      Mais effectivement il manque les registres I2C pour savoir comment récupérer les infos. Un petit tour sur le site du fabriquant : http://www.invensense.com/mems/gyro/catalog.html -> MPU-6050 et tu télécharge le pdf "RM" (qui est commun avec le MPU-6000).

                                      Ensuite tu verras qu'il y a des registres pour récupérer les valeurs du gyroscope et de l'accéléromètre sur chacun des 3 axes.

                                      Je suis allé télécharger ce document... Mais c'est bien celui dont il était déjà question, non ? (pas de sous-entendu, ironie ou autre, merci :) )
                                      Mais je me noie un peu dans une telle documentation technique.
                                      Ce dont j'aurais besoin, c'est en fait d'une explication pour démarrer. Comprendre le fonctionnement, comment lire la "datasheet" (et même plus précisément, comment aller chercher les informations utiles dans la "datasheet" - non, je ne suis pas convaincu que tout me soit toujours utile), comprendre à quoi correspondent les données que je vais acquérir et comment les transformer.
                                      Et puis, pour la bibliothèque "monoclasse" que j'ai évoquée, qu'en est-il ? 

                                      Merci d'avance ^^

                                      -
                                      Edité par Soaocohoa 24 août 2013 à 0:36:05

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        24 août 2013 à 0:52:51

                                        Bah faut la lire déjà, si tu le fais pas, tu ne le feras jamais, et 2 x 50 pages c'est faisable même pour un (faux) débutant. Quand tu verras les datasheet de microcontroleur ou microprocesseur qui font facilement dans les 100 pages minimum jusqu'à 1500 pages (et même plus car il n'y a pas qu'un seul document : la datasheet, le reference manual, etc.).

                                        Donc je répètes : arrêtes-toi, fait une pause, concentres-toi sur ce gyroscope/accéléromètre et prend le temps de lire la doc. Normalement avec le week-end ca devrait être faisable.

                                        Quand au soft, même si j'en ai fait et que je suis parfaitement capable d'en faire, si c'est pas moi qui code ca me fait juste chier à mort de regarder sur code (ou tout ce qui est relatif au code) pour quelqu'un d'autre et encore plus si c'est pour expliquer sur un forum.

                                        Normalement si tu comprend pas le code (enfin la librairie) : soit y a pas de doc donc dans ce cas, passe ton chemin et fait tout toi-même, soit, et c'est le cas, t'as pas lu la doc ou pris le temps de regarder le code et les exemples.

                                        http://www.i2cdevlib.com/-> Usages et y a même un Forum où tu devrais je pense trouver des posts de débutants ou au minimum des exemples.
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          24 août 2013 à 11:14:48

                                          Merci, je vais voir ce que je peux faire.

                                          EDIT : Pour l'instant en pause : le composant semble ne pas fonctionner :(
                                          J'ai contacté Sparkfun. 

                                          EDIT : Il fonctionne :
                                          On peut le tester comme ceci : 

                                          VDD - 3.3v
                                          GND - GND
                                          SCL - SCL (ou A5)
                                          SDA - SDA (ou A4)
                                          VIO - 3.3v

                                          -
                                          Edité par Soaocohoa 21 octobre 2013 à 12:21:16

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            11 décembre 2013 à 15:50:54

                                            Plop !

                                            J'arrive un peu (beaucoup) au milieu de la discussion (ou à la fin?), mais as-tu réussi à lire les données qui t'intéressaient sur le MPU / réussi à lire les angles d'inclinaison ?

                                            En ce moment dans mes temps libres je me code une petite classe "simple" pour récupérer les données de mon MPU6050, je n'ai jusqu'à présent implémenté aucun traitement des données d'entrée, mais je récupère les angles entre le vecteur de force et les trois axes. Si quelqu'un est intéressé, je peux tenter de poster une photo du montage "breadboard" et les quelques lignes de code que j'utilise.

                                            Naik

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            (\ _ /) (='.'=) Voici Lapinou. Aidez le à conquérir le monde (")-(") en le reproduisant.
                                              11 décembre 2013 à 22:51:43

                                              Salut :)

                                              Merci pour l'aide que tu proposes !

                                              Je n'ai encore pas vraiment achevé ce qui concerne cette partie du projet sur lequel je travaille, mais j'ai quand même bien avancé, et je peux (plus ou moins), en effet, calculer l'inclinaison du capteur.

                                              Je fais cela en transposant les explications données à cette adresse : http://www.geekmomprojects.com/gyroscopes-and-accelerometers-on-a-chip/ en un code Arduino utilisant i2cdevlib.

                                              Peut-être que plus tard, (un jour, qui sait ? :ange:), si je réussi mon projet (ce n'est pas gagné :p ), je pourrai écrire quelques explications (pourquoi pas en mini-tutoriels) sur l'exploitation de quelques composants que j'aurai utilisés ^^

                                              -
                                              Edité par Soaocohoa 11 décembre 2013 à 22:52:15

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                14 janvier 2014 à 11:17:22

                                                @Naik : Je serais intéressé par ton code et la photo de ton montage, pour m'en servir comme base de test.

                                                (Je poste en public parce que ces éléments pourraient servir à d'autres aussi, j'imagine)

                                                Merci d'avance!

                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  15 janvier 2014 à 14:34:07

                                                  Plop !

                                                  Je poste vite fait, j'ai peu de temps en ce moment, donc désolé du caractère un peu "brouillon" de la chose.

                                                  Pour mes petits tests, j'ai utilisé un module tout fait, le GY-52, carte sur laquelle est implantée le MPU-6050, son électronique, mais surtout un régulateur; j'attire donc votre attention sur le fait que les informations que je donne correspondent à CE montage et doivent être adaptées au votre avant d'être appliquées "bêtement". Je me dégage de toute responsabilité si vous faites crâmer vos composants ! :ninja:

                                                  Câblage:

                                                  Matériel utilisé:

                                                  • Arduino Nano (Atmel Mega 328p)(si besoin je devrais pouvoir prendre photos sur une Arduino Mega 2560)
                                                  • GY-52 (PCB avec un MPU-6050 et son électronique "de base").
                                                  • Quelques fils de jonction

                                                  Connexion:

                                                  • la pin VCC du GY-52 connectée au +5V du Arduino Nano;
                                                  • la pin GND du GY-52 connectée au GND de l'Arduino;
                                                  • la pin SCL du GY-52 connectée à la pin A5 de l'Arduino;
                                                  • la pin SDA du GY-52 connectée à la pin A4 de l'Arduino;
                                                  ATTENTION - le GY-52 possède un régulateur de tension, on peut donc l'alimenter en +5V sans problème, mais de mémoire le MPU-6050 travaille en +3.3V ! Bien vérifier les caractéristiques des composants avant tout câblage/mise sous tension.

                                                  Photos du montage:

                                                  Note:

                                                  • +5V en rouge
                                                  • GND en noir
                                                  • SDA en violet
                                                  • SCL en jaune

                                                  Les photos:

                                                  • Vue de l'Arduino Nano:

                                                  Câblage MCU-6050 - Arduino Nano 

                                                  • Vue du GY-52:

                                                  Câblage MPU-6050 - GY-52

                                                  Le code:

                                                  Pour le code je me suis "inspiré" ( --> fait de gros copier/coller :ange: ) de plusieurs sites:

                                                  En gros j'ai récupéré le code pour accéder au MPU sur l'Arduino Playground, la manière de faire pour calculer l'angle sur Starlino, et j'ai encapsulé le tout dans une classe vite fait pour simplifier l'accès.

                                                  C'est très brouillon, pas du tout optimisé, mais ça permet de récupérer les données et de les afficher, pour le moment je n'ai pas encore eu le temps d'aller plus loin.

                                                  Je ne code pas avec l'IDE Arduino, donc je ne sais pas trop comment ça se passe lorsqu'on a plusieurs fichiers, mais si besoin est je peux chercher comment faire.

                                                  La classe s'appelle Mpu6050  (  ...surprise... ), normalement elle est compréhensible, mais là encore si besoin je peux documenter.

                                                  N'hésitez pas à proposer des améliorations, je suis preneur ;)

                                                  Le fichier Mpu6050.h

                                                  #ifndef MPU6050_H
                                                  #define MPU6050_H
                                                  
                                                  #include <Arduino.h>
                                                  
                                                  
                                                  
                                                  class Mpu6050
                                                  {
                                                  public:
                                                      Mpu6050();
                                                  
                                                      bool    init(String *argErrorString=0);
                                                  
                                                      uint8_t whoAmI(void) const;
                                                  
                                                  
                                                      void    clearData(void);
                                                      bool    updateData(void);
                                                  
                                                  
                                                      int16_t rawAccelX(void) const;
                                                      int16_t rawAccelY(void) const;
                                                      int16_t rawAccelZ(void) const;
                                                  
                                                      int16_t rawGyroX(void) const;
                                                      int16_t rawGyroY(void) const;
                                                      int16_t rawGyroZ(void) const;
                                                  
                                                      int16_t rawTemperature(void) const;
                                                  
                                                  
                                                  
                                                      double  accelX_g(void) const;
                                                      double  accelY_g(void) const;
                                                      double  accelZ_g(void) const;
                                                  
                                                      double  gyroX_deg_s(void) const;
                                                      double  gyroY_deg_s(void) const;
                                                      double  gyroZ_deg_s(void) const;
                                                  
                                                      double  temperature_celsius(void) const;
                                                  
                                                  
                                                      double  angleX_deg(void) const;
                                                      double  angleY_deg(void) const;
                                                      double  angleZ_deg(void) const;
                                                  
                                                  
                                                  private:
                                                  
                                                  
                                                      enum    AccelerometerRange {
                                                          AccelerometerRange_2g   =   0,
                                                          AccelerometerRange_4g   =   1,
                                                          AccelerometerRange_8g   =   2,
                                                          AccelerometerRange_16g  =   3
                                                      };
                                                  
                                                      enum    GyroRange {
                                                          GyroRange250deg_s   = 0,
                                                          GyroRange500deg_s   = 1,
                                                          GyroRange1000deg_s  = 2,
                                                          GyroRange2000deg_s  = 3
                                                      };
                                                  
                                                      // Declaring an union for the registers and the axis values.
                                                      // The byte order does not match the byte order of
                                                      // the compiler and AVR chip.
                                                      // The AVR chip (on the Arduino board) has the Low Byte
                                                      // at the lower address.
                                                      // But the MPU-6050 has a different order: High Byte at
                                                      // lower address, so that has to be corrected.
                                                      // The register part "reg" is only used internally,
                                                      // and are swapped in code.
                                                      typedef union accel_t_gyro_union
                                                      {
                                                        struct
                                                        {
                                                          uint8_t x_accel_h;
                                                          uint8_t x_accel_l;
                                                          uint8_t y_accel_h;
                                                          uint8_t y_accel_l;
                                                          uint8_t z_accel_h;
                                                          uint8_t z_accel_l;
                                                          uint8_t t_h;
                                                          uint8_t t_l;
                                                          uint8_t x_gyro_h;
                                                          uint8_t x_gyro_l;
                                                          uint8_t y_gyro_h;
                                                          uint8_t y_gyro_l;
                                                          uint8_t z_gyro_h;
                                                          uint8_t z_gyro_l;
                                                        } reg;
                                                        struct
                                                        {
                                                          int16_t x_accel;
                                                          int16_t y_accel;
                                                          int16_t z_accel;
                                                          int16_t temperature;
                                                          int16_t x_gyro;
                                                          int16_t y_gyro;
                                                          int16_t z_gyro;
                                                        } value;
                                                      };
                                                  
                                                  
                                                  
                                                      AccelerometerRange  m_accelerometerRange;
                                                      accel_t_gyro_union  m_data;
                                                      double              m_forceVector;
                                                      GyroRange           m_gyroRange;
                                                      uint8_t             m_whoAmI;
                                                  
                                                  
                                                  
                                                      /**
                                                       * @brief accelerometerCountsPerG   Returns the constant corresponding to
                                                       * the number of "counts" there is in a G depending on the accelerometer's
                                                       * range.
                                                       *
                                                       * @return
                                                       */
                                                      int accelerometerCountsPerG(void) const;
                                                  
                                                      /**
                                                       * @brief gyroscopeCountsPerDeg_s   Returns the constant corresponding to
                                                       * the number of "counts" there is in a deg/s depending on the gyroscope's
                                                       * range.
                                                       *
                                                       * @return
                                                       */
                                                      float gyroscopeCountsPerDeg_s(void) const;
                                                  
                                                  
                                                      /**
                                                       * @brief read is a common function to read multiple bytes from an I2C device.
                                                       * @param start
                                                       * @param buffer
                                                       * @param size
                                                       * @return
                                                       *
                                                       * It uses the boolean parameter for Wire.endTransMission() to be able to
                                                       * hold or release the I2C-bus.
                                                       * This is implemented in Arduino 1.0.1.
                                                       * Only this function is used to read.
                                                       * There is no function for a single byte.
                                                       */
                                                      int read(int start, uint8_t *buffer, int size);
                                                  
                                                  
                                                      // --------------------------------------------------------
                                                      // MPU6050_write
                                                      //
                                                      // This is a common function to write multiple bytes to an I2C device.
                                                      //
                                                      // If only a single register is written,
                                                      // use the function MPU_6050_write_reg().
                                                      //
                                                      // Parameters:
                                                      //   start : Start address, use a define for the register
                                                      //   pData : A pointer to the data to write.
                                                      //   size  : The number of bytes to write.
                                                      //
                                                      // If only a single register is written, a pointer
                                                      // to the data has to be used, and the size is
                                                      // a single byte:
                                                      //   int data = 0;        // the data to write
                                                      //   MPU6050_write (MPU6050_PWR_MGMT_1, &c, 1);
                                                      //
                                                      int write(int start, const uint8_t *pData, int size);
                                                  
                                                  
                                                      // --------------------------------------------------------
                                                      // MPU6050_write_reg
                                                      //
                                                      // An extra function to write a single register.
                                                      // It is just a wrapper around the MPU_6050_write()
                                                      // function, and it is only a convenient function
                                                      // to make it easier to write a single register.
                                                      //
                                                      int write_reg(int reg, uint8_t data);
                                                  
                                                  };
                                                  
                                                  #endif // MPU6050_H
                                                  

                                                  Le fichier Mpu6050.cpp

                                                  #include "Mpu6050.h"
                                                  
                                                  #include <Wire.h>
                                                  
                                                  #if 1
                                                  #   define  LOG(msg)    Serial.print( "Mpu6050.cpp::"msg )
                                                  #   define  LOGLN(msg)  Serial.println("Mpu6050.cpp::"msg )
                                                  #else
                                                  #   define LOG(msg)
                                                  #   define LOGLN(msg)
                                                  #endif
                                                  
                                                  // Register names according to the datasheet.
                                                  // According to the InvenSense document
                                                  // "MPU-6000 and MPU-6050 Register Map
                                                  // and Descriptions Revision 3.2", there are no registers
                                                  // at 0x02 ... 0x18, but according other information
                                                  // the registers in that unknown area are for gain
                                                  // and offsets.
                                                  //
                                                  #define MPU6050_AUX_VDDIO          0x01   // R/W
                                                  #define MPU6050_SMPLRT_DIV         0x19   // R/W
                                                  #define MPU6050_CONFIG             0x1A   // R/W
                                                  #define MPU6050_GYRO_CONFIG        0x1B   // R/W
                                                  #define MPU6050_ACCEL_CONFIG       0x1C   // R/W
                                                  #define MPU6050_FF_THR             0x1D   // R/W
                                                  #define MPU6050_FF_DUR             0x1E   // R/W
                                                  #define MPU6050_MOT_THR            0x1F   // R/W
                                                  #define MPU6050_MOT_DUR            0x20   // R/W
                                                  #define MPU6050_ZRMOT_THR          0x21   // R/W
                                                  #define MPU6050_ZRMOT_DUR          0x22   // R/W
                                                  #define MPU6050_FIFO_EN            0x23   // R/W
                                                  #define MPU6050_I2C_MST_CTRL       0x24   // R/W
                                                  #define MPU6050_I2C_SLV0_ADDR      0x25   // R/W
                                                  #define MPU6050_I2C_SLV0_REG       0x26   // R/W
                                                  #define MPU6050_I2C_SLV0_CTRL      0x27   // R/W
                                                  #define MPU6050_I2C_SLV1_ADDR      0x28   // R/W
                                                  #define MPU6050_I2C_SLV1_REG       0x29   // R/W
                                                  #define MPU6050_I2C_SLV1_CTRL      0x2A   // R/W
                                                  #define MPU6050_I2C_SLV2_ADDR      0x2B   // R/W
                                                  #define MPU6050_I2C_SLV2_REG       0x2C   // R/W
                                                  #define MPU6050_I2C_SLV2_CTRL      0x2D   // R/W
                                                  #define MPU6050_I2C_SLV3_ADDR      0x2E   // R/W
                                                  #define MPU6050_I2C_SLV3_REG       0x2F   // R/W
                                                  #define MPU6050_I2C_SLV3_CTRL      0x30   // R/W
                                                  #define MPU6050_I2C_SLV4_ADDR      0x31   // R/W
                                                  #define MPU6050_I2C_SLV4_REG       0x32   // R/W
                                                  #define MPU6050_I2C_SLV4_DO        0x33   // R/W
                                                  #define MPU6050_I2C_SLV4_CTRL      0x34   // R/W
                                                  #define MPU6050_I2C_SLV4_DI        0x35   // R
                                                  #define MPU6050_I2C_MST_STATUS     0x36   // R
                                                  #define MPU6050_INT_PIN_CFG        0x37   // R/W
                                                  #define MPU6050_INT_ENABLE         0x38   // R/W
                                                  #define MPU6050_INT_STATUS         0x3A   // R
                                                  #define MPU6050_ACCEL_XOUT_H       0x3B   // R
                                                  #define MPU6050_ACCEL_XOUT_L       0x3C   // R
                                                  #define MPU6050_ACCEL_YOUT_H       0x3D   // R
                                                  #define MPU6050_ACCEL_YOUT_L       0x3E   // R
                                                  #define MPU6050_ACCEL_ZOUT_H       0x3F   // R
                                                  #define MPU6050_ACCEL_ZOUT_L       0x40   // R
                                                  #define MPU6050_TEMP_OUT_H         0x41   // R
                                                  #define MPU6050_TEMP_OUT_L         0x42   // R
                                                  #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_EXT_SENS_DATA_00   0x49   // R
                                                  #define MPU6050_EXT_SENS_DATA_01   0x4A   // R
                                                  #define MPU6050_EXT_SENS_DATA_02   0x4B   // R
                                                  #define MPU6050_EXT_SENS_DATA_03   0x4C   // R
                                                  #define MPU6050_EXT_SENS_DATA_04   0x4D   // R
                                                  #define MPU6050_EXT_SENS_DATA_05   0x4E   // R
                                                  #define MPU6050_EXT_SENS_DATA_06   0x4F   // R
                                                  #define MPU6050_EXT_SENS_DATA_07   0x50   // R
                                                  #define MPU6050_EXT_SENS_DATA_08   0x51   // R
                                                  #define MPU6050_EXT_SENS_DATA_09   0x52   // R
                                                  #define MPU6050_EXT_SENS_DATA_10   0x53   // R
                                                  #define MPU6050_EXT_SENS_DATA_11   0x54   // R
                                                  #define MPU6050_EXT_SENS_DATA_12   0x55   // R
                                                  #define MPU6050_EXT_SENS_DATA_13   0x56   // R
                                                  #define MPU6050_EXT_SENS_DATA_14   0x57   // R
                                                  #define MPU6050_EXT_SENS_DATA_15   0x58   // R
                                                  #define MPU6050_EXT_SENS_DATA_16   0x59   // R
                                                  #define MPU6050_EXT_SENS_DATA_17   0x5A   // R
                                                  #define MPU6050_EXT_SENS_DATA_18   0x5B   // R
                                                  #define MPU6050_EXT_SENS_DATA_19   0x5C   // R
                                                  #define MPU6050_EXT_SENS_DATA_20   0x5D   // R
                                                  #define MPU6050_EXT_SENS_DATA_21   0x5E   // R
                                                  #define MPU6050_EXT_SENS_DATA_22   0x5F   // R
                                                  #define MPU6050_EXT_SENS_DATA_23   0x60   // R
                                                  #define MPU6050_MOT_DETECT_STATUS  0x61   // R
                                                  #define MPU6050_I2C_SLV0_DO        0x63   // R/W
                                                  #define MPU6050_I2C_SLV1_DO        0x64   // R/W
                                                  #define MPU6050_I2C_SLV2_DO        0x65   // R/W
                                                  #define MPU6050_I2C_SLV3_DO        0x66   // R/W
                                                  #define MPU6050_I2C_MST_DELAY_CTRL 0x67   // R/W
                                                  #define MPU6050_SIGNAL_PATH_RESET  0x68   // R/W
                                                  #define MPU6050_MOT_DETECT_CTRL    0x69   // R/W
                                                  #define MPU6050_USER_CTRL          0x6A   // R/W
                                                  #define MPU6050_PWR_MGMT_1         0x6B   // R/W
                                                  #define MPU6050_PWR_MGMT_2         0x6C   // R/W
                                                  #define MPU6050_FIFO_COUNTH        0x72   // R/W
                                                  #define MPU6050_FIFO_COUNTL        0x73   // R/W
                                                  #define MPU6050_FIFO_R_W           0x74   // R/W
                                                  #define MPU6050_WHO_AM_I           0x75   // R
                                                  
                                                  
                                                  // Defines for the bits, to be able to change
                                                  // between bit number and binary definition.
                                                  // By using the bit number, programming the sensor
                                                  // is like programming the AVR microcontroller.
                                                  // But instead of using "(1<<X)", or "_BV(X)",
                                                  // the Arduino "bit(X)" is used.
                                                  #define MPU6050_D0 0
                                                  #define MPU6050_D1 1
                                                  #define MPU6050_D2 2
                                                  #define MPU6050_D3 3
                                                  #define MPU6050_D4 4
                                                  #define MPU6050_D5 5
                                                  #define MPU6050_D6 6
                                                  #define MPU6050_D7 7
                                                  
                                                  // AUX_VDDIO Register
                                                  #define MPU6050_AUX_VDDIO MPU6050_D7  // I2C high: 1=VDD, 0=VLOGIC
                                                  
                                                  // CONFIG Register
                                                  // DLPF is Digital Low Pass Filter for both gyro and accelerometers.
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_DLPF_CFG0     MPU6050_D0
                                                  #define MPU6050_DLPF_CFG1     MPU6050_D1
                                                  #define MPU6050_DLPF_CFG2     MPU6050_D2
                                                  #define MPU6050_EXT_SYNC_SET0 MPU6050_D3
                                                  #define MPU6050_EXT_SYNC_SET1 MPU6050_D4
                                                  #define MPU6050_EXT_SYNC_SET2 MPU6050_D5
                                                  
                                                  // Combined definitions for the EXT_SYNC_SET values
                                                  #define MPU6050_EXT_SYNC_SET_0 (0)
                                                  #define MPU6050_EXT_SYNC_SET_1 (bit(MPU6050_EXT_SYNC_SET0))
                                                  #define MPU6050_EXT_SYNC_SET_2 (bit(MPU6050_EXT_SYNC_SET1))
                                                  #define MPU6050_EXT_SYNC_SET_3 (bit(MPU6050_EXT_SYNC_SET1)|bit(MPU6050_EXT_SYNC_SET0))
                                                  #define MPU6050_EXT_SYNC_SET_4 (bit(MPU6050_EXT_SYNC_SET2))
                                                  #define MPU6050_EXT_SYNC_SET_5 (bit(MPU6050_EXT_SYNC_SET2)|bit(MPU6050_EXT_SYNC_SET0))
                                                  #define MPU6050_EXT_SYNC_SET_6 (bit(MPU6050_EXT_SYNC_SET2)|bit(MPU6050_EXT_SYNC_SET1))
                                                  #define MPU6050_EXT_SYNC_SET_7 (bit(MPU6050_EXT_SYNC_SET2)|bit(MPU6050_EXT_SYNC_SET1)|bit(MPU6050_EXT_SYNC_SET0))
                                                  
                                                  // Alternative names for the combined definitions.
                                                  #define MPU6050_EXT_SYNC_DISABLED     MPU6050_EXT_SYNC_SET_0
                                                  #define MPU6050_EXT_SYNC_TEMP_OUT_L   MPU6050_EXT_SYNC_SET_1
                                                  #define MPU6050_EXT_SYNC_GYRO_XOUT_L  MPU6050_EXT_SYNC_SET_2
                                                  #define MPU6050_EXT_SYNC_GYRO_YOUT_L  MPU6050_EXT_SYNC_SET_3
                                                  #define MPU6050_EXT_SYNC_GYRO_ZOUT_L  MPU6050_EXT_SYNC_SET_4
                                                  #define MPU6050_EXT_SYNC_ACCEL_XOUT_L MPU6050_EXT_SYNC_SET_5
                                                  #define MPU6050_EXT_SYNC_ACCEL_YOUT_L MPU6050_EXT_SYNC_SET_6
                                                  #define MPU6050_EXT_SYNC_ACCEL_ZOUT_L MPU6050_EXT_SYNC_SET_7
                                                  
                                                  // Combined definitions for the DLPF_CFG values
                                                  #define MPU6050_DLPF_CFG_0 (0)
                                                  #define MPU6050_DLPF_CFG_1 (bit(MPU6050_DLPF_CFG0))
                                                  #define MPU6050_DLPF_CFG_2 (bit(MPU6050_DLPF_CFG1))
                                                  #define MPU6050_DLPF_CFG_3 (bit(MPU6050_DLPF_CFG1)|bit(MPU6050_DLPF_CFG0))
                                                  #define MPU6050_DLPF_CFG_4 (bit(MPU6050_DLPF_CFG2))
                                                  #define MPU6050_DLPF_CFG_5 (bit(MPU6050_DLPF_CFG2)|bit(MPU6050_DLPF_CFG0))
                                                  #define MPU6050_DLPF_CFG_6 (bit(MPU6050_DLPF_CFG2)|bit(MPU6050_DLPF_CFG1))
                                                  #define MPU6050_DLPF_CFG_7 (bit(MPU6050_DLPF_CFG2)|bit(MPU6050_DLPF_CFG1)|bit(MPU6050_DLPF_CFG0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  // This name uses the bandwidth (Hz) for the accelometer,
                                                  // for the gyro the bandwidth is almost the same.
                                                  #define MPU6050_DLPF_260HZ    MPU6050_DLPF_CFG_0
                                                  #define MPU6050_DLPF_184HZ    MPU6050_DLPF_CFG_1
                                                  #define MPU6050_DLPF_94HZ     MPU6050_DLPF_CFG_2
                                                  #define MPU6050_DLPF_44HZ     MPU6050_DLPF_CFG_3
                                                  #define MPU6050_DLPF_21HZ     MPU6050_DLPF_CFG_4
                                                  #define MPU6050_DLPF_10HZ     MPU6050_DLPF_CFG_5
                                                  #define MPU6050_DLPF_5HZ      MPU6050_DLPF_CFG_6
                                                  #define MPU6050_DLPF_RESERVED MPU6050_DLPF_CFG_7
                                                  
                                                  // GYRO_CONFIG Register
                                                  // The XG_ST, YG_ST, ZG_ST are bits for selftest.
                                                  // The FS_SEL sets the range for the gyro.
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_FS_SEL0 MPU6050_D3
                                                  #define MPU6050_FS_SEL1 MPU6050_D4
                                                  #define MPU6050_ZG_ST   MPU6050_D5
                                                  #define MPU6050_YG_ST   MPU6050_D6
                                                  #define MPU6050_XG_ST   MPU6050_D7
                                                  
                                                  // Combined definitions for the FS_SEL values
                                                  #define MPU6050_FS_SEL_0 (0)
                                                  #define MPU6050_FS_SEL_1 (bit(MPU6050_FS_SEL0))
                                                  #define MPU6050_FS_SEL_2 (bit(MPU6050_FS_SEL1))
                                                  #define MPU6050_FS_SEL_3 (bit(MPU6050_FS_SEL1)|bit(MPU6050_FS_SEL0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  // The name uses the range in degrees per second.
                                                  #define MPU6050_FS_SEL_250  MPU6050_FS_SEL_0
                                                  #define MPU6050_FS_SEL_500  MPU6050_FS_SEL_1
                                                  #define MPU6050_FS_SEL_1000 MPU6050_FS_SEL_2
                                                  #define MPU6050_FS_SEL_2000 MPU6050_FS_SEL_3
                                                  
                                                  // ACCEL_CONFIG Register
                                                  // The XA_ST, YA_ST, ZA_ST are bits for selftest.
                                                  // The AFS_SEL sets the range for the accelerometer.
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_ACCEL_HPF0 MPU6050_D0
                                                  #define MPU6050_ACCEL_HPF1 MPU6050_D1
                                                  #define MPU6050_ACCEL_HPF2 MPU6050_D2
                                                  #define MPU6050_AFS_SEL0   MPU6050_D3
                                                  #define MPU6050_AFS_SEL1   MPU6050_D4
                                                  #define MPU6050_ZA_ST      MPU6050_D5
                                                  #define MPU6050_YA_ST      MPU6050_D6
                                                  #define MPU6050_XA_ST      MPU6050_D7
                                                  
                                                  // Combined definitions for the ACCEL_HPF values
                                                  #define MPU6050_ACCEL_HPF_0 (0)
                                                  #define MPU6050_ACCEL_HPF_1 (bit(MPU6050_ACCEL_HPF0))
                                                  #define MPU6050_ACCEL_HPF_2 (bit(MPU6050_ACCEL_HPF1))
                                                  #define MPU6050_ACCEL_HPF_3 (bit(MPU6050_ACCEL_HPF1)|bit(MPU6050_ACCEL_HPF0))
                                                  #define MPU6050_ACCEL_HPF_4 (bit(MPU6050_ACCEL_HPF2))
                                                  #define MPU6050_ACCEL_HPF_7 (bit(MPU6050_ACCEL_HPF2)|bit(MPU6050_ACCEL_HPF1)|bit(MPU6050_ACCEL_HPF0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  // The name uses the Cut-off frequency.
                                                  #define MPU6050_ACCEL_HPF_RESET  MPU6050_ACCEL_HPF_0
                                                  #define MPU6050_ACCEL_HPF_5HZ    MPU6050_ACCEL_HPF_1
                                                  #define MPU6050_ACCEL_HPF_2_5HZ  MPU6050_ACCEL_HPF_2
                                                  #define MPU6050_ACCEL_HPF_1_25HZ MPU6050_ACCEL_HPF_3
                                                  #define MPU6050_ACCEL_HPF_0_63HZ MPU6050_ACCEL_HPF_4
                                                  #define MPU6050_ACCEL_HPF_HOLD   MPU6050_ACCEL_HPF_7
                                                  
                                                  // Combined definitions for the AFS_SEL values
                                                  #define MPU6050_AFS_SEL_0 (0)
                                                  #define MPU6050_AFS_SEL_1 (bit(MPU6050_AFS_SEL0))
                                                  #define MPU6050_AFS_SEL_2 (bit(MPU6050_AFS_SEL1))
                                                  #define MPU6050_AFS_SEL_3 (bit(MPU6050_AFS_SEL1)|bit(MPU6050_AFS_SEL0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  // The name uses the full scale range for the accelerometer.
                                                  #define MPU6050_AFS_SEL_2G  MPU6050_AFS_SEL_0
                                                  #define MPU6050_AFS_SEL_4G  MPU6050_AFS_SEL_1
                                                  #define MPU6050_AFS_SEL_8G  MPU6050_AFS_SEL_2
                                                  #define MPU6050_AFS_SEL_16G MPU6050_AFS_SEL_3
                                                  
                                                  // FIFO_EN Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_SLV0_FIFO_EN  MPU6050_D0
                                                  #define MPU6050_SLV1_FIFO_EN  MPU6050_D1
                                                  #define MPU6050_SLV2_FIFO_EN  MPU6050_D2
                                                  #define MPU6050_ACCEL_FIFO_EN MPU6050_D3
                                                  #define MPU6050_ZG_FIFO_EN    MPU6050_D4
                                                  #define MPU6050_YG_FIFO_EN    MPU6050_D5
                                                  #define MPU6050_XG_FIFO_EN    MPU6050_D6
                                                  #define MPU6050_TEMP_FIFO_EN  MPU6050_D7
                                                  
                                                  // I2C_MST_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_MST_CLK0  MPU6050_D0
                                                  #define MPU6050_I2C_MST_CLK1  MPU6050_D1
                                                  #define MPU6050_I2C_MST_CLK2  MPU6050_D2
                                                  #define MPU6050_I2C_MST_CLK3  MPU6050_D3
                                                  #define MPU6050_I2C_MST_P_NSR MPU6050_D4
                                                  #define MPU6050_SLV_3_FIFO_EN MPU6050_D5
                                                  #define MPU6050_WAIT_FOR_ES   MPU6050_D6
                                                  #define MPU6050_MULT_MST_EN   MPU6050_D7
                                                  
                                                  // Combined definitions for the I2C_MST_CLK
                                                  #define MPU6050_I2C_MST_CLK_0 (0)
                                                  #define MPU6050_I2C_MST_CLK_1  (bit(MPU6050_I2C_MST_CLK0))
                                                  #define MPU6050_I2C_MST_CLK_2  (bit(MPU6050_I2C_MST_CLK1))
                                                  #define MPU6050_I2C_MST_CLK_3  (bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
                                                  #define MPU6050_I2C_MST_CLK_4  (bit(MPU6050_I2C_MST_CLK2))
                                                  #define MPU6050_I2C_MST_CLK_5  (bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK0))
                                                  #define MPU6050_I2C_MST_CLK_6  (bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1))
                                                  #define MPU6050_I2C_MST_CLK_7  (bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
                                                  #define MPU6050_I2C_MST_CLK_8  (bit(MPU6050_I2C_MST_CLK3))
                                                  #define MPU6050_I2C_MST_CLK_9  (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK0))
                                                  #define MPU6050_I2C_MST_CLK_10 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK1))
                                                  #define MPU6050_I2C_MST_CLK_11 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
                                                  #define MPU6050_I2C_MST_CLK_12 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2))
                                                  #define MPU6050_I2C_MST_CLK_13 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK0))
                                                  #define MPU6050_I2C_MST_CLK_14 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1))
                                                  #define MPU6050_I2C_MST_CLK_15 (bit(MPU6050_I2C_MST_CLK3)|bit(MPU6050_I2C_MST_CLK2)|bit(MPU6050_I2C_MST_CLK1)|bit(MPU6050_I2C_MST_CLK0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  // The names uses I2C Master Clock Speed in kHz.
                                                  #define MPU6050_I2C_MST_CLK_348KHZ MPU6050_I2C_MST_CLK_0
                                                  #define MPU6050_I2C_MST_CLK_333KHZ MPU6050_I2C_MST_CLK_1
                                                  #define MPU6050_I2C_MST_CLK_320KHZ MPU6050_I2C_MST_CLK_2
                                                  #define MPU6050_I2C_MST_CLK_308KHZ MPU6050_I2C_MST_CLK_3
                                                  #define MPU6050_I2C_MST_CLK_296KHZ MPU6050_I2C_MST_CLK_4
                                                  #define MPU6050_I2C_MST_CLK_286KHZ MPU6050_I2C_MST_CLK_5
                                                  #define MPU6050_I2C_MST_CLK_276KHZ MPU6050_I2C_MST_CLK_6
                                                  #define MPU6050_I2C_MST_CLK_267KHZ MPU6050_I2C_MST_CLK_7
                                                  #define MPU6050_I2C_MST_CLK_258KHZ MPU6050_I2C_MST_CLK_8
                                                  #define MPU6050_I2C_MST_CLK_500KHZ MPU6050_I2C_MST_CLK_9
                                                  #define MPU6050_I2C_MST_CLK_471KHZ MPU6050_I2C_MST_CLK_10
                                                  #define MPU6050_I2C_MST_CLK_444KHZ MPU6050_I2C_MST_CLK_11
                                                  #define MPU6050_I2C_MST_CLK_421KHZ MPU6050_I2C_MST_CLK_12
                                                  #define MPU6050_I2C_MST_CLK_400KHZ MPU6050_I2C_MST_CLK_13
                                                  #define MPU6050_I2C_MST_CLK_381KHZ MPU6050_I2C_MST_CLK_14
                                                  #define MPU6050_I2C_MST_CLK_364KHZ MPU6050_I2C_MST_CLK_15
                                                  
                                                  // I2C_SLV0_ADDR Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV0_RW MPU6050_D7
                                                  
                                                  // I2C_SLV0_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV0_LEN0    MPU6050_D0
                                                  #define MPU6050_I2C_SLV0_LEN1    MPU6050_D1
                                                  #define MPU6050_I2C_SLV0_LEN2    MPU6050_D2
                                                  #define MPU6050_I2C_SLV0_LEN3    MPU6050_D3
                                                  #define MPU6050_I2C_SLV0_GRP     MPU6050_D4
                                                  #define MPU6050_I2C_SLV0_REG_DIS MPU6050_D5
                                                  #define MPU6050_I2C_SLV0_BYTE_SW MPU6050_D6
                                                  #define MPU6050_I2C_SLV0_EN      MPU6050_D7
                                                  
                                                  // A mask for the length
                                                  #define MPU6050_I2C_SLV0_LEN_MASK 0x0F
                                                  
                                                  // I2C_SLV1_ADDR Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV1_RW MPU6050_D7
                                                  
                                                  // I2C_SLV1_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV1_LEN0    MPU6050_D0
                                                  #define MPU6050_I2C_SLV1_LEN1    MPU6050_D1
                                                  #define MPU6050_I2C_SLV1_LEN2    MPU6050_D2
                                                  #define MPU6050_I2C_SLV1_LEN3    MPU6050_D3
                                                  #define MPU6050_I2C_SLV1_GRP     MPU6050_D4
                                                  #define MPU6050_I2C_SLV1_REG_DIS MPU6050_D5
                                                  #define MPU6050_I2C_SLV1_BYTE_SW MPU6050_D6
                                                  #define MPU6050_I2C_SLV1_EN      MPU6050_D7
                                                  
                                                  // A mask for the length
                                                  #define MPU6050_I2C_SLV1_LEN_MASK 0x0F
                                                  
                                                  // I2C_SLV2_ADDR Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV2_RW MPU6050_D7
                                                  
                                                  // I2C_SLV2_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV2_LEN0    MPU6050_D0
                                                  #define MPU6050_I2C_SLV2_LEN1    MPU6050_D1
                                                  #define MPU6050_I2C_SLV2_LEN2    MPU6050_D2
                                                  #define MPU6050_I2C_SLV2_LEN3    MPU6050_D3
                                                  #define MPU6050_I2C_SLV2_GRP     MPU6050_D4
                                                  #define MPU6050_I2C_SLV2_REG_DIS MPU6050_D5
                                                  #define MPU6050_I2C_SLV2_BYTE_SW MPU6050_D6
                                                  #define MPU6050_I2C_SLV2_EN      MPU6050_D7
                                                  
                                                  // A mask for the length
                                                  #define MPU6050_I2C_SLV2_LEN_MASK 0x0F
                                                  
                                                  // I2C_SLV3_ADDR Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV3_RW MPU6050_D7
                                                  
                                                  // I2C_SLV3_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV3_LEN0    MPU6050_D0
                                                  #define MPU6050_I2C_SLV3_LEN1    MPU6050_D1
                                                  #define MPU6050_I2C_SLV3_LEN2    MPU6050_D2
                                                  #define MPU6050_I2C_SLV3_LEN3    MPU6050_D3
                                                  #define MPU6050_I2C_SLV3_GRP     MPU6050_D4
                                                  #define MPU6050_I2C_SLV3_REG_DIS MPU6050_D5
                                                  #define MPU6050_I2C_SLV3_BYTE_SW MPU6050_D6
                                                  #define MPU6050_I2C_SLV3_EN      MPU6050_D7
                                                  
                                                  // A mask for the length
                                                  #define MPU6050_I2C_SLV3_LEN_MASK 0x0F
                                                  
                                                  // I2C_SLV4_ADDR Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV4_RW MPU6050_D7
                                                  
                                                  // I2C_SLV4_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_MST_DLY0     MPU6050_D0
                                                  #define MPU6050_I2C_MST_DLY1     MPU6050_D1
                                                  #define MPU6050_I2C_MST_DLY2     MPU6050_D2
                                                  #define MPU6050_I2C_MST_DLY3     MPU6050_D3
                                                  #define MPU6050_I2C_MST_DLY4     MPU6050_D4
                                                  #define MPU6050_I2C_SLV4_REG_DIS MPU6050_D5
                                                  #define MPU6050_I2C_SLV4_INT_EN  MPU6050_D6
                                                  #define MPU6050_I2C_SLV4_EN      MPU6050_D7
                                                  
                                                  // A mask for the delay
                                                  #define MPU6050_I2C_MST_DLY_MASK 0x1F
                                                  
                                                  // I2C_MST_STATUS Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV0_NACK MPU6050_D0
                                                  #define MPU6050_I2C_SLV1_NACK MPU6050_D1
                                                  #define MPU6050_I2C_SLV2_NACK MPU6050_D2
                                                  #define MPU6050_I2C_SLV3_NACK MPU6050_D3
                                                  #define MPU6050_I2C_SLV4_NACK MPU6050_D4
                                                  #define MPU6050_I2C_LOST_ARB  MPU6050_D5
                                                  #define MPU6050_I2C_SLV4_DONE MPU6050_D6
                                                  #define MPU6050_PASS_THROUGH  MPU6050_D7
                                                  
                                                  // I2C_PIN_CFG Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_CLKOUT_EN       MPU6050_D0
                                                  #define MPU6050_I2C_BYPASS_EN   MPU6050_D1
                                                  #define MPU6050_FSYNC_INT_EN    MPU6050_D2
                                                  #define MPU6050_FSYNC_INT_LEVEL MPU6050_D3
                                                  #define MPU6050_INT_RD_CLEAR    MPU6050_D4
                                                  #define MPU6050_LATCH_INT_EN    MPU6050_D5
                                                  #define MPU6050_INT_OPEN        MPU6050_D6
                                                  #define MPU6050_INT_LEVEL       MPU6050_D7
                                                  
                                                  // INT_ENABLE Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_DATA_RDY_EN    MPU6050_D0
                                                  #define MPU6050_I2C_MST_INT_EN MPU6050_D3
                                                  #define MPU6050_FIFO_OFLOW_EN  MPU6050_D4
                                                  #define MPU6050_ZMOT_EN        MPU6050_D5
                                                  #define MPU6050_MOT_EN         MPU6050_D6
                                                  #define MPU6050_FF_EN          MPU6050_D7
                                                  
                                                  // INT_STATUS Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_DATA_RDY_INT   MPU6050_D0
                                                  #define MPU6050_I2C_MST_INT    MPU6050_D3
                                                  #define MPU6050_FIFO_OFLOW_INT MPU6050_D4
                                                  #define MPU6050_ZMOT_INT       MPU6050_D5
                                                  #define MPU6050_MOT_INT        MPU6050_D6
                                                  #define MPU6050_FF_INT         MPU6050_D7
                                                  
                                                  // MOT_DETECT_STATUS Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_MOT_ZRMOT MPU6050_D0
                                                  #define MPU6050_MOT_ZPOS  MPU6050_D2
                                                  #define MPU6050_MOT_ZNEG  MPU6050_D3
                                                  #define MPU6050_MOT_YPOS  MPU6050_D4
                                                  #define MPU6050_MOT_YNEG  MPU6050_D5
                                                  #define MPU6050_MOT_XPOS  MPU6050_D6
                                                  #define MPU6050_MOT_XNEG  MPU6050_D7
                                                  
                                                  // IC2_MST_DELAY_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_I2C_SLV0_DLY_EN MPU6050_D0
                                                  #define MPU6050_I2C_SLV1_DLY_EN MPU6050_D1
                                                  #define MPU6050_I2C_SLV2_DLY_EN MPU6050_D2
                                                  #define MPU6050_I2C_SLV3_DLY_EN MPU6050_D3
                                                  #define MPU6050_I2C_SLV4_DLY_EN MPU6050_D4
                                                  #define MPU6050_DELAY_ES_SHADOW MPU6050_D7
                                                  
                                                  // SIGNAL_PATH_RESET Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_TEMP_RESET  MPU6050_D0
                                                  #define MPU6050_ACCEL_RESET MPU6050_D1
                                                  #define MPU6050_GYRO_RESET  MPU6050_D2
                                                  
                                                  // MOT_DETECT_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_MOT_COUNT0      MPU6050_D0
                                                  #define MPU6050_MOT_COUNT1      MPU6050_D1
                                                  #define MPU6050_FF_COUNT0       MPU6050_D2
                                                  #define MPU6050_FF_COUNT1       MPU6050_D3
                                                  #define MPU6050_ACCEL_ON_DELAY0 MPU6050_D4
                                                  #define MPU6050_ACCEL_ON_DELAY1 MPU6050_D5
                                                  
                                                  // Combined definitions for the MOT_COUNT
                                                  #define MPU6050_MOT_COUNT_0 (0)
                                                  #define MPU6050_MOT_COUNT_1 (bit(MPU6050_MOT_COUNT0))
                                                  #define MPU6050_MOT_COUNT_2 (bit(MPU6050_MOT_COUNT1))
                                                  #define MPU6050_MOT_COUNT_3 (bit(MPU6050_MOT_COUNT1)|bit(MPU6050_MOT_COUNT0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  #define MPU6050_MOT_COUNT_RESET MPU6050_MOT_COUNT_0
                                                  
                                                  // Combined definitions for the FF_COUNT
                                                  #define MPU6050_FF_COUNT_0 (0)
                                                  #define MPU6050_FF_COUNT_1 (bit(MPU6050_FF_COUNT0))
                                                  #define MPU6050_FF_COUNT_2 (bit(MPU6050_FF_COUNT1))
                                                  #define MPU6050_FF_COUNT_3 (bit(MPU6050_FF_COUNT1)|bit(MPU6050_FF_COUNT0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  #define MPU6050_FF_COUNT_RESET MPU6050_FF_COUNT_0
                                                  
                                                  // Combined definitions for the ACCEL_ON_DELAY
                                                  #define MPU6050_ACCEL_ON_DELAY_0 (0)
                                                  #define MPU6050_ACCEL_ON_DELAY_1 (bit(MPU6050_ACCEL_ON_DELAY0))
                                                  #define MPU6050_ACCEL_ON_DELAY_2 (bit(MPU6050_ACCEL_ON_DELAY1))
                                                  #define MPU6050_ACCEL_ON_DELAY_3 (bit(MPU6050_ACCEL_ON_DELAY1)|bit(MPU6050_ACCEL_ON_DELAY0))
                                                  
                                                  // Alternative names for the ACCEL_ON_DELAY
                                                  #define MPU6050_ACCEL_ON_DELAY_0MS MPU6050_ACCEL_ON_DELAY_0
                                                  #define MPU6050_ACCEL_ON_DELAY_1MS MPU6050_ACCEL_ON_DELAY_1
                                                  #define MPU6050_ACCEL_ON_DELAY_2MS MPU6050_ACCEL_ON_DELAY_2
                                                  #define MPU6050_ACCEL_ON_DELAY_3MS MPU6050_ACCEL_ON_DELAY_3
                                                  
                                                  // USER_CTRL Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_SIG_COND_RESET MPU6050_D0
                                                  #define MPU6050_I2C_MST_RESET  MPU6050_D1
                                                  #define MPU6050_FIFO_RESET     MPU6050_D2
                                                  #define MPU6050_I2C_IF_DIS     MPU6050_D4   // must be 0 for MPU-6050
                                                  #define MPU6050_I2C_MST_EN     MPU6050_D5
                                                  #define MPU6050_FIFO_EN        MPU6050_D6
                                                  
                                                  // PWR_MGMT_1 Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_CLKSEL0      MPU6050_D0
                                                  #define MPU6050_CLKSEL1      MPU6050_D1
                                                  #define MPU6050_CLKSEL2      MPU6050_D2
                                                  #define MPU6050_TEMP_DIS     MPU6050_D3    // 1: disable temperature sensor
                                                  #define MPU6050_CYCLE        MPU6050_D5    // 1: sample and sleep
                                                  #define MPU6050_SLEEP        MPU6050_D6    // 1: sleep mode
                                                  #define MPU6050_DEVICE_RESET MPU6050_D7    // 1: reset to default values
                                                  
                                                  // Combined definitions for the CLKSEL
                                                  #define MPU6050_CLKSEL_0 (0)
                                                  #define MPU6050_CLKSEL_1 (bit(MPU6050_CLKSEL0))
                                                  #define MPU6050_CLKSEL_2 (bit(MPU6050_CLKSEL1))
                                                  #define MPU6050_CLKSEL_3 (bit(MPU6050_CLKSEL1)|bit(MPU6050_CLKSEL0))
                                                  #define MPU6050_CLKSEL_4 (bit(MPU6050_CLKSEL2))
                                                  #define MPU6050_CLKSEL_5 (bit(MPU6050_CLKSEL2)|bit(MPU6050_CLKSEL0))
                                                  #define MPU6050_CLKSEL_6 (bit(MPU6050_CLKSEL2)|bit(MPU6050_CLKSEL1))
                                                  #define MPU6050_CLKSEL_7 (bit(MPU6050_CLKSEL2)|bit(MPU6050_CLKSEL1)|bit(MPU6050_CLKSEL0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  #define MPU6050_CLKSEL_INTERNAL    MPU6050_CLKSEL_0
                                                  #define MPU6050_CLKSEL_X           MPU6050_CLKSEL_1
                                                  #define MPU6050_CLKSEL_Y           MPU6050_CLKSEL_2
                                                  #define MPU6050_CLKSEL_Z           MPU6050_CLKSEL_3
                                                  #define MPU6050_CLKSEL_EXT_32KHZ   MPU6050_CLKSEL_4
                                                  #define MPU6050_CLKSEL_EXT_19_2MHZ MPU6050_CLKSEL_5
                                                  #define MPU6050_CLKSEL_RESERVED    MPU6050_CLKSEL_6
                                                  #define MPU6050_CLKSEL_STOP        MPU6050_CLKSEL_7
                                                  
                                                  // PWR_MGMT_2 Register
                                                  // These are the names for the bits.
                                                  // Use these only with the bit() macro.
                                                  #define MPU6050_STBY_ZG       MPU6050_D0
                                                  #define MPU6050_STBY_YG       MPU6050_D1
                                                  #define MPU6050_STBY_XG       MPU6050_D2
                                                  #define MPU6050_STBY_ZA       MPU6050_D3
                                                  #define MPU6050_STBY_YA       MPU6050_D4
                                                  #define MPU6050_STBY_XA       MPU6050_D5
                                                  #define MPU6050_LP_WAKE_CTRL0 MPU6050_D6
                                                  #define MPU6050_LP_WAKE_CTRL1 MPU6050_D7
                                                  
                                                  // Combined definitions for the LP_WAKE_CTRL
                                                  #define MPU6050_LP_WAKE_CTRL_0 (0)
                                                  #define MPU6050_LP_WAKE_CTRL_1 (bit(MPU6050_LP_WAKE_CTRL0))
                                                  #define MPU6050_LP_WAKE_CTRL_2 (bit(MPU6050_LP_WAKE_CTRL1))
                                                  #define MPU6050_LP_WAKE_CTRL_3 (bit(MPU6050_LP_WAKE_CTRL1)|bit(MPU6050_LP_WAKE_CTRL0))
                                                  
                                                  // Alternative names for the combined definitions
                                                  // The names uses the Wake-up Frequency.
                                                  #define MPU6050_LP_WAKE_1_25HZ MPU6050_LP_WAKE_CTRL_0
                                                  #define MPU6050_LP_WAKE_2_5HZ  MPU6050_LP_WAKE_CTRL_1
                                                  #define MPU6050_LP_WAKE_5HZ    MPU6050_LP_WAKE_CTRL_2
                                                  #define MPU6050_LP_WAKE_10HZ   MPU6050_LP_WAKE_CTRL_3
                                                  
                                                  
                                                  // Default I2C address for the MPU-6050 is 0x68.
                                                  // But only if the AD0 pin is low.
                                                  // Some sensor boards have AD0 high, and the
                                                  // I2C address thus becomes 0x69.
                                                  #define MPU6050_I2C_ADDRESS 0x68
                                                  
                                                  
                                                  
                                                  static const double C_DEG_TO_RAD    =  0.017453293;
                                                  static const double C_RAD_TO_DEG    = 57.295779506;
                                                  
                                                  
                                                  Mpu6050::Mpu6050()
                                                      :   m_accelerometerRange( AccelerometerRange_2g )
                                                      ,   m_forceVector( 1 )
                                                      ,   m_gyroRange( GyroRange250deg_s )
                                                      ,   m_whoAmI( 0x00 )
                                                  {
                                                  
                                                  }
                                                  
                                                  
                                                  int Mpu6050::accelerometerCountsPerG() const
                                                  {
                                                      int ret = 1;
                                                  
                                                      switch( this->m_accelerometerRange )
                                                      {
                                                          case AccelerometerRange_2g:
                                                              ret = 16384;
                                                              break;
                                                  
                                                          case AccelerometerRange_4g:
                                                              ret = 8192;
                                                              break;
                                                  
                                                          case AccelerometerRange_8g:
                                                              ret = 4096;
                                                              break;
                                                  
                                                          case AccelerometerRange_16g:
                                                              ret = 2048;
                                                              break;
                                                  
                                                          default:
                                                              ret = 1;
                                                              break;
                                                      }
                                                  
                                                      return ret;
                                                  }
                                                  
                                                  double  Mpu6050::accelX_g() const
                                                  {
                                                      return this->rawAccelX() / ((double)this->accelerometerCountsPerG() );
                                                  }
                                                  
                                                  double  Mpu6050::accelY_g() const
                                                  {
                                                      return this->rawAccelY() / ((double)this->accelerometerCountsPerG() );
                                                  }
                                                  
                                                  double  Mpu6050::accelZ_g() const
                                                  {
                                                      return this->rawAccelZ() / ((double)this->accelerometerCountsPerG() );
                                                  }
                                                  
                                                  double  Mpu6050::angleX_deg() const
                                                  {
                                                      return acos( this->accelX_g() / this->m_forceVector ) * C_RAD_TO_DEG;
                                                  }
                                                  
                                                  double  Mpu6050::angleY_deg() const
                                                  {
                                                      return acos( this->accelY_g() / this->m_forceVector ) * C_RAD_TO_DEG;
                                                  }
                                                  
                                                  double  Mpu6050::angleZ_deg() const
                                                  {
                                                      return acos( this->accelZ_g() / this->m_forceVector ) * C_RAD_TO_DEG;
                                                  }
                                                  
                                                  void    Mpu6050::clearData()
                                                  {
                                                      this->m_data.value.x_accel  = 0;
                                                      this->m_data.value.y_accel  = 0;
                                                      this->m_data.value.z_accel  = 0;
                                                  
                                                      this->m_data.value.x_gyro  = 0;
                                                      this->m_data.value.y_gyro  = 0;
                                                      this->m_data.value.z_gyro  = 0;
                                                  
                                                      this->m_data.value.temperature  = 0;
                                                  }
                                                  
                                                  float Mpu6050::gyroscopeCountsPerDeg_s() const
                                                  {
                                                      float ret = 1;
                                                  
                                                      switch( this->m_gyroRange )
                                                      {
                                                          case GyroRange250deg_s:
                                                              ret = 131;
                                                              break;
                                                  
                                                          case GyroRange500deg_s:
                                                              ret = 65.5;
                                                              break;
                                                  
                                                          case GyroRange1000deg_s:
                                                              ret = 32.8;
                                                              break;
                                                  
                                                          case GyroRange2000deg_s:
                                                              ret = 16.4;
                                                              break;
                                                  
                                                          default:
                                                              ret = 1;
                                                              break;
                                                      }
                                                  
                                                      return ret;
                                                  }
                                                  
                                                  double  Mpu6050::gyroX_deg_s() const
                                                  {
                                                      return this->rawGyroX() / ((double)this->gyroscopeCountsPerDeg_s() );
                                                  }
                                                  
                                                  double  Mpu6050::gyroY_deg_s() const
                                                  {
                                                      return this->rawGyroY() / ((double)this->gyroscopeCountsPerDeg_s() );
                                                  }
                                                  
                                                  double  Mpu6050::gyroZ_deg_s() const
                                                  {
                                                      return this->rawGyroZ() / ((double)this->gyroscopeCountsPerDeg_s() );
                                                  }
                                                  
                                                  bool    Mpu6050::init(String *argErrorString)
                                                  {
                                                      uint8_t c;
                                                      int     error = 0;
                                                  
                                                  
                                                      /* Initialize the 'Wire' class for the I2C-bus. */
                                                      LOGLN( "Init Wire..............................." );
                                                      Wire.begin();
                                                      LOGLN( "Init Wire.......................[  OK  ]" );
                                                  
                                                  
                                                      // default at power-up:
                                                      //    Gyro at 250 degrees second
                                                      //    Acceleration at 2g
                                                      //    Clock source at internal 8MHz
                                                      //    The device is in sleep mode.
                                                      //
                                                  
                                                      LOGLN( "Reading WhoAmI.........................." );
                                                      error = this->read( MPU6050_WHO_AM_I, &this->m_whoAmI, 1 );
                                                      if( error != 0 ) {
                                                          LOGLN( "Reading WhoAmI..................[ERREUR]" );
                                                          if( argErrorString != 0 ) {
                                                              *argErrorString = String( "Can't fetch who i am" );
                                                          }
                                                          return false;
                                                      }
                                                      LOGLN( "Reading WhoAmI..................[  OK  ]" );
                                                  
                                                      // According to the datasheet, the 'sleep' bit
                                                      // should read a '1'. But I read a '0'.
                                                      // That bit has to be cleared, since the sensor
                                                      // is in sleep mode at power-up. Even if the
                                                      // bit reads '0'.
                                                      LOGLN( "Reading PowerManagement................." );
                                                      error = this->read( MPU6050_PWR_MGMT_2, &c, 1 );
                                                      if( error != 0 ) {
                                                          if( argErrorString != 0 ) {
                                                              *argErrorString = String( "Can't fetch sleep bit" );
                                                          }
                                                          LOGLN( "Reading PowerManagement.........[ERREUR]" );
                                                          return false;
                                                      }
                                                      LOGLN( "Reading PowerManagement.........[  OK  ]" );
                                                  
                                                  
                                                      /* Clear the 'sleep' bit to start the sensor. */
                                                      LOGLN( "Clear 'sleep' bit......................." );
                                                      this->write_reg( MPU6050_PWR_MGMT_1, 0 );
                                                      LOGLN( "Clear 'sleep' bit...............[  OK  ]" );
                                                  
                                                  
                                                      /* Get the accelerometer's config */
                                                      LOGLN( "Get the accelerometer config............" );
                                                      uint8_t reg_content;
                                                      this->read( MPU6050_ACCEL_CONFIG, &reg_content, 1 );
                                                  
                                                  
                                                      if( ( reg_content & MPU6050_AFS_SEL_16G ) == MPU6050_AFS_SEL_16G ) {
                                                          this->m_accelerometerRange  = AccelerometerRange_16g;
                                                      } else if( ( reg_content & MPU6050_AFS_SEL_8G ) == MPU6050_AFS_SEL_8G ) {
                                                          this->m_accelerometerRange  = AccelerometerRange_8g;
                                                      } else if( ( reg_content & MPU6050_AFS_SEL_4G ) == MPU6050_AFS_SEL_4G ) {
                                                          this->m_accelerometerRange  = AccelerometerRange_4g;
                                                      } else if( (reg_content & MPU6050_AFS_SEL_2G) == MPU6050_AFS_SEL_2G ) {
                                                          this->m_accelerometerRange  = AccelerometerRange_2g;
                                                      }
                                                      LOGLN( "Get the accelerometer config....[  OK  ]" );
                                                  
                                                  
                                                      /* Get the gyro config */
                                                      LOGLN( "Get the gyro config....................." );
                                                      this->read( MPU6050_GYRO_CONFIG, &reg_content, 1 );
                                                      if( (reg_content & MPU6050_FS_SEL_2000) == MPU6050_FS_SEL_2000 ) {
                                                          this->m_gyroRange   = GyroRange2000deg_s;
                                                      } else if( (reg_content & MPU6050_FS_SEL_1000) == MPU6050_FS_SEL_1000 ) {
                                                          this->m_gyroRange   = GyroRange1000deg_s;
                                                      } else if( (reg_content & MPU6050_FS_SEL_500) == MPU6050_FS_SEL_500 ) {
                                                          this->m_gyroRange   = GyroRange500deg_s;
                                                      } else if( (reg_content & MPU6050_FS_SEL_250) == MPU6050_FS_SEL_250 ) {
                                                          this->m_gyroRange   = GyroRange250deg_s;
                                                      }
                                                      LOGLN( "Get the gyro config.............[  OK  ]" );
                                                  
                                                  
                                                  
                                                  //    Serial.print( "MPU6050_ACCEL_CONFIG register == 0b" );
                                                  //    Serial.print( reg_content, BIN );
                                                  //    Serial.println( "" );
                                                  
                                                      return true;
                                                  }
                                                  
                                                  int16_t Mpu6050::rawAccelX() const
                                                  {
                                                      return this->m_data.value.x_accel;
                                                  }
                                                  
                                                  int16_t Mpu6050::rawAccelY() const
                                                  {
                                                      return this->m_data.value.y_accel;
                                                  }
                                                  
                                                  int16_t Mpu6050::rawAccelZ() const
                                                  {
                                                      return this->m_data.value.z_accel;
                                                  }
                                                  
                                                  int16_t Mpu6050::rawGyroX() const
                                                  {
                                                      return this->m_data.value.x_gyro;
                                                  }
                                                  
                                                  int16_t Mpu6050::rawGyroY() const
                                                  {
                                                      return this->m_data.value.y_gyro;
                                                  }
                                                  
                                                  int16_t Mpu6050::rawGyroZ() const
                                                  {
                                                      return this->m_data.value.z_gyro;
                                                  }
                                                  
                                                  int16_t Mpu6050::rawTemperature() const
                                                  {
                                                      return this->m_data.value.temperature;
                                                  }
                                                  
                                                  int Mpu6050::read(int start, uint8_t *buffer, int size)
                                                  {
                                                      int i, n;
                                                  
                                                      Wire.beginTransmission( MPU6050_I2C_ADDRESS );
                                                      n = Wire.write(start);
                                                      if (n != 1)
                                                          return (-10);
                                                  
                                                      n = Wire.endTransmission(false);    // hold the I2C-bus
                                                      if (n != 0)
                                                          return (n);
                                                  
                                                      // Third parameter is true: relase I2C-bus after data is read.
                                                      Wire.requestFrom(MPU6050_I2C_ADDRESS, size, true);
                                                      i = 0;
                                                      while(Wire.available() && i<size)
                                                      {
                                                          buffer[i++]=Wire.read();
                                                      }
                                                      if ( i != size) {
                                                          Serial.print( "i==" ); Serial.print( i, DEC );
                                                          Serial.print( " != size==" ); Serial.println( size, DEC );
                                                          Serial.print( "start==" ); Serial.println( start, DEC );
                                                          return (-11);
                                                      }
                                                  
                                                      return (0);  // return : no error
                                                  }
                                                  
                                                  double  Mpu6050::temperature_celsius() const
                                                  {
                                                      // The temperature sensor is -40 to +85 degrees Celsius.
                                                      // It is a signed integer.
                                                      // According to the datasheet:
                                                      //   340 per degrees Celsius, -512 at 35 degrees.
                                                      // At 0 degrees: -512 - (340 * 35) = -12412
                                                  
                                                      return ( (double) this->m_data.value.temperature + 12412.0) / 340.0;
                                                  }
                                                  
                                                  bool    Mpu6050::updateData()
                                                  {
                                                      int error = 0;
                                                  
                                                      // Read the raw values.
                                                      // Read 14 bytes at once,
                                                      // containing acceleration, temperature and gyro.
                                                      // With the default settings of the MPU-6050,
                                                      // there is no filter enabled, and the values
                                                      // are not very stable.
                                                      error = this->read( MPU6050_ACCEL_XOUT_H,
                                                                          (uint8_t *) &this->m_data,
                                                                          sizeof( this->m_data ) );
                                                      if( error != 0 ) {
                                                      Serial.print(F(" Mpu6050::updateData() ==>reading  accel, temp and gyro, error = "));
                                                      Serial.println(error,DEC);
                                                  
                                                          this->clearData();
                                                          return false;
                                                      }
                                                  
                                                  
                                                      // Swap all high and low bytes.
                                                      // After this, the registers values are swapped,
                                                      // so the structure name like x_accel_l does no
                                                      // longer contain the lower byte.
                                                      uint8_t swap;
                                                  #define SWAP(x,y) swap = x; x = y; y = swap
                                                  
                                                      SWAP (this->m_data.reg.x_accel_h, this->m_data.reg.x_accel_l);
                                                      SWAP (this->m_data.reg.y_accel_h, this->m_data.reg.y_accel_l);
                                                      SWAP (this->m_data.reg.z_accel_h, this->m_data.reg.z_accel_l);
                                                      SWAP (this->m_data.reg.t_h, this->m_data.reg.t_l);
                                                      SWAP (this->m_data.reg.x_gyro_h, this->m_data.reg.x_gyro_l);
                                                      SWAP (this->m_data.reg.y_gyro_h, this->m_data.reg.y_gyro_l);
                                                      SWAP (this->m_data.reg.z_gyro_h, this->m_data.reg.z_gyro_l);
                                                  
                                                  
                                                  
                                                      /* calculating force vector's length (for angular calculus) */
                                                      this->m_forceVector = sqrt(   pow( this->accelX_g(), 2 )
                                                                                  + pow( this->accelY_g(), 2 )
                                                                                  + pow( this->accelZ_g(), 2 ) );
                                                  
                                                      return true;
                                                  }
                                                  
                                                  uint8_t Mpu6050::whoAmI() const
                                                  {
                                                      return this->m_whoAmI;
                                                  }
                                                  
                                                  int Mpu6050::write(int start, const uint8_t *pData, int size)
                                                  {
                                                      int n, error;
                                                  
                                                      Wire.beginTransmission(MPU6050_I2C_ADDRESS);
                                                      n = Wire.write(start);        // write the start address
                                                      if (n != 1)
                                                          return (-20);
                                                  
                                                      n = Wire.write(pData, size);  // write data bytes
                                                      if (n != size)
                                                          return (-21);
                                                  
                                                      error = Wire.endTransmission(true); // release the I2C-bus
                                                      if (error != 0)
                                                          return (error);
                                                  
                                                      return (0);         // return : no error
                                                  }
                                                  
                                                  
                                                  int Mpu6050::write_reg(int reg, uint8_t data)
                                                  {
                                                      int error;
                                                  
                                                      error = this->write( reg, &data, 1 );
                                                  
                                                      return (error);
                                                  }

                                                  Le fichier "main":

                                                  // Do not remove the include below
                                                  #include "test_Mpu6050_main.h"
                                                  
                                                  #include <Arduino.h>
                                                  #include <Servo.h>
                                                  
                                                  
                                                  /* ######################################################################### */
                                                  /* ######################################################################### */
                                                  
                                                  #define VERBOSE                     /*!< A commenter pour desactiver log */
                                                  #define PRINT_ACCEL_RAW             /*!< Commenter pour desactiver affichage des valeurs "brutes" de l'accelerometre */
                                                  #define PRINT_ACCEL_G               /*!< Commenter pour desactiver affichage des valeurs en G de l'accelerometre */
                                                  #define PRINT_CALCULATED_ANGLES     /*!< Commenter pour desactiver affichage des valeurs de l'inclinaison calculée à partir de l'acceleration */
                                                  #define PRINT_GYRO_RAW              /*!< Commenter pour desactiver affichage des valeurs "brutes" du gyroscope */
                                                  #define PRINT_GYRO_DEG_PER_S        /*!< Commenter pour desactiver affichage des valeurs en degres par seconde du gyroscope */
                                                  #define PRINT_TEMPERATURE           /*!< Commenter pour desactiver affichage de la temperature */
                                                  
                                                  
                                                  
                                                  #ifdef VERBOSE
                                                  #   define  LOG(msg)    Serial.print( msg )
                                                  #   define  LOGLN(msg)  Serial.println( msg )
                                                  #else
                                                  #   define LOG(msg)
                                                  #   define LOGLN(msg)
                                                  #endif
                                                  
                                                  
                                                  /* ######################################################################### */
                                                  /* ######################################################################### */
                                                  
                                                  static const double C_DEG_TO_RAD    =  0.017453293;
                                                  static const double C_RAD_TO_DEG    = 57.295779506;
                                                  
                                                  Mpu6050         sensor;
                                                  
                                                  /* ######################################################################### */
                                                  /* ######################################################################### */
                                                  
                                                  void setup()
                                                  {
                                                      String errorString;
                                                  
                                                      /* Initialisation de la liaison série */
                                                      Serial.begin( 115200 );
                                                      LOGLN( "Hello World !" );
                                                  
                                                  
                                                      /* Initialisation du capteur */
                                                      LOG( "MPU6050 init...................." );
                                                      if( ! sensor.init( &errorString ) ) {
                                                          /* Si une erreur est survenue lors de l'initialisation */
                                                          Serial.println( "[Erreur]");
                                                          Serial.print( "Erreur a l'init du mpu6050 :: " );
                                                          Serial.println( errorString );
                                                          for(;;);
                                                      }
                                                      LOGLN( "[  OK  ]" );
                                                  
                                                  #ifdef VERBOSE
                                                      Serial.print( "+-- MPU6050 is \"0x" );
                                                      Serial.print( sensor.whoAmI(), HEX );
                                                      Serial.println( "\"\n" );
                                                  #endif
                                                  
                                                      delay( 1000 ); /*< Pour avoir le temps de lire les infos à l'ecran */
                                                  }
                                                  
                                                  /* ######################################################################### */
                                                  /* ######################################################################### */
                                                  
                                                  void loop()
                                                  {
                                                      Serial.println( "========================================" );
                                                  
                                                  
                                                      /* Update the data */
                                                      LOG( "updating sensor's data..........." );
                                                      if( ! sensor.updateData() ) {
                                                          Serial.println( "[ERREUR]" );
                                                          return; /*!< ce return permet de sortir de la fonction loop; cette fonction etant integree dans une boucle infinie, elle sera immediatement rappelee. */
                                                      } else {
                                                          LOGLN( "[OK]" );
                                                      }
                                                  
                                                  
                                                  
                                                      /* Print data */
                                                  
                                                  #ifdef PRINT_ACCEL_RAW
                                                      Serial.print( "raw Ax = " ); Serial.println( sensor.rawAccelX() );
                                                      Serial.print( "raw Ay = " ); Serial.println( sensor.rawAccelY() );
                                                      Serial.print( "raw Az = " ); Serial.println( sensor.rawAccelZ() );
                                                  #endif
                                                  
                                                  #ifdef PRINT_ACCEL_G
                                                      Serial.print( "Ax = " ); Serial.print( sensor.accelX_g() );Serial.println( "g" );
                                                      Serial.print( "Ay = " ); Serial.print( sensor.accelY_g() );Serial.println( "g" );
                                                      Serial.print( "Az = " ); Serial.print( sensor.accelZ_g() );Serial.println( "g" );
                                                  #endif
                                                  
                                                  
                                                  #ifdef PRINT_CALCULATED_ANGLES
                                                      Serial.print( "angle X==" ); Serial.print( sensor.angleX_deg(), 6 ); Serial.println( "" );
                                                      Serial.print( "angle Y==" ); Serial.print( sensor.angleY_deg(), 6 ); Serial.println( "" );
                                                      Serial.print( "angle Z==" ); Serial.print( sensor.angleZ_deg(), 6 ); Serial.println( "" );
                                                  #endif
                                                  
                                                  #ifdef PRINT_GYRO_RAW
                                                      Serial.print( "raw Rx = " ); Serial.println( sensor.gyroX_deg_s() );
                                                      Serial.print( "raw Ry = " ); Serial.println( sensor.gyroY_deg_s() );
                                                      Serial.print( "raw Rz = " ); Serial.println( sensor.gyroZ_deg_s() );
                                                  #endif
                                                  
                                                  #ifdef PRINT_GYRO_DEG_PER_S
                                                      Serial.print( "Rx = " ); Serial.print( sensor.gyroX_deg_s() );Serial.println( "°/s" );
                                                      Serial.print( "Ry = " ); Serial.print( sensor.gyroY_deg_s() );Serial.println( "°/s" );
                                                      Serial.print( "Rz = " ); Serial.print( sensor.gyroZ_deg_s() );Serial.println( "°/s" );
                                                  #endif
                                                  
                                                  #ifdef PRINT_TEMPERATURE
                                                      Serial.print(F("Temperature: "));
                                                      Serial.print( sensor.temperature_celsius(), 3 );
                                                      Serial.print(F(" degres Celsius"));
                                                      Serial.println(F(""));
                                                  #endif
                                                  
                                                  
                                                      delay( 500 );
                                                  }
                                                  
                                                  /* ######################################################################### */
                                                  /* ######################################################################### */
                                                  



                                                  Voilà, j'essaierai de me relire et d'ajouter des détails dès que j'ai un peu de temps :pirate:

                                                  ++

                                                  -
                                                  Edité par Naik 15 janvier 2014 à 14:43:07

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                  (\ _ /) (='.'=) Voici Lapinou. Aidez le à conquérir le monde (")-(") en le reproduisant.
                                                    4 mars 2014 à 9:23:58

                                                    Bonjour,

                                                    J'aimerai moi aussi utiliser un MPU6050 pour construire un drone.

                                                    Je me demandait si il n'était pas possible de juste utiliser la libraire Wire sans s’embêter avec des librairies MPUtralala totalement incompréhensibles.

                                                    Par exemple comme-ça :

                                                    #include <Wire.h>
                                                    
                                                    long val;
                                                    
                                                    void setup()
                                                    {
                                                      Wire.begin();
                                                      Serial.begin(9600);
                                                    
                                                    
                                                    }
                                                    
                                                    void loop()
                                                    {
                                                      Wire.beginTransmission(?); //Quelle adresse utiliser ?
                                                      Wire.requestFrom(adresse?, 16);
                                                      val = Wire.receive()
                                                      Wire.endTransmission();
                                                    
                                                      Serial.println(val);
                                                    }



                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      4 mars 2014 à 10:28:56

                                                      Salut :)

                                                      Plus tu cherches, plus tu trouves que c'est compliqué je crois !
                                                      Ce n'est pas avec deux demi-lignes classiques que tu vas tout récupérer il me semble ! :p

                                                      Et l'utilisation de la bibliothèque i²cdevlib est extrêmement simple ! 

                                                      Je crois que tu la télécharges entièrement là : http://www.i2cdevlib.com/usage 
                                                      Puis tu dois avoir des codes d'exemples (utiles pour les initialisations...)

                                                      Et ensuite, comme tu peux le voir sur la documentation, les fonctions pour tout récupérer sont très simples.
                                                      Je te conseille vraiment de faire comme cela, ce n'est pas compliqué de récupérer les informations du capteur, et c'est aussi très court !
                                                      (bon, les traiter, c'est autre chose... :p)

                                                      -
                                                      Edité par Soaocohoa 7 mars 2014 à 13:43:15

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        10 mars 2014 à 10:56:29

                                                        Hello !

                                                        DarkSn0w4 a écrit:

                                                        Je me demandait si il n'était pas possible de juste utiliser la libraire Wire sans s’embêter avec des librairies MPUtralala totalement incompréhensibles.

                                                        Par exemple comme-ça :

                                                        #include <Wire.h>
                                                        
                                                        long val;
                                                        
                                                        void setup()
                                                        {
                                                          Wire.begin();
                                                          Serial.begin(9600);
                                                        
                                                        
                                                        }
                                                        
                                                        void loop()
                                                        {
                                                          Wire.beginTransmission(?); //Quelle adresse utiliser ?
                                                          Wire.requestFrom(adresse?, 16);
                                                          val = Wire.receive()
                                                          Wire.endTransmission();
                                                        
                                                          Serial.println(val);
                                                        }

                                                        En un sens, oui. Mais ne serait-ce que pour récupérer les trois axes de l'accéléro + les trois du gyro, tu devras lire au minimum 6 registres, si c'est pas le double. Au minimum, parce que tu dois aussi configurer le capteur, éventuellement lire des informations sur son état, etc. et ça va faire beaucoup de lignes de code dans ton programme "pour rien". Il est donc plus simple (à mon sens) d'encapsuler les méthodes d'accès au capteur dans une classe, tout ton code propre au capteur sera regroupé dans deux fichiers seulement (très pratique pour tester, débeuguer,...), c'est réutilisable donc plus fiable, etc.

                                                        Du coup au lieu de ressembler à

                                                        void loop()
                                                        {
                                                          Wire.beginTransmission(adresseCapteur);
                                                          Wire.requestFrom(adresseX, 16);
                                                          valX = Wire.receive()
                                                          Wire.endTransmission();
                                                        
                                                          Wire.beginTransmission(adresseCapteur);
                                                          Wire.requestFrom(adresseY, 16);
                                                          valY = Wire.receive()
                                                          Wire.endTransmission();
                                                        
                                                          Wire.beginTransmission(adresseCapteur);
                                                          Wire.requestFrom(adresseZ, 16);
                                                          valZ = Wire.receive()
                                                          Wire.endTransmission();
                                                        
                                                          Serial.println(valX);
                                                          Serial.println(valY);
                                                          Serial.println(valZ);
                                                        }

                                                        ton code ressemblera à

                                                        Mpu6050 monCapteur;
                                                        
                                                        void loop()
                                                        {
                                                            Serial.println( monCapteur.X );
                                                            Serial.println( monCapteur.Y );
                                                            Serial.println( monCapteur.Z );
                                                        }

                                                        C'est à mon sens plus court et simple. (note: j'ai pas testé le code, là c'est juste pour l'exemple ;) )

                                                        Après il faut savoir que tu ne peux (normalement) pas exploiter directement les valeurs que te donne le MPU6050, comme (presque) tous les capteurs, tu dois effectuer un filtrage sur les données que tu récupère pour pouvoir les lisser et les "fusionner" (accéléro+gyro) (si ton capteur est immobile, tu arriveras à obtenir son inclinaison en calculant son vecteur accélération - qui, lorsque le capteur est immobile, est égal à celui de l'attraction terrestre-, mais si il est en mouvement l'angle de ton vecteur accélération n'est plus assimilable à celui de l'attraction terrestre, du coup ta mesure est faussée) mais ça c'est une autre histoire.

                                                        Bref, le plus simple c'est le mieux, même si encapsuler les accès au capteur dans une classe C++ ça te parait compliqué, c'est en fait plus simple, ça aide à la lisibilité du code; si c'est openSource et connu comme i2cdevlib, ce sera d'autant plus fiable.

                                                        Après si tu veux juste récupérer une donnée du capteur, sans faire de traitement particulier dessus, que c'est dans un seul registre, que tu vas l'utiliser qu'une seule fois, etc etc. bon il n'y a pas forcément utilité de coder une classe pour ça. Mais avec un drone tu n'es pas dans ce cas là.

                                                        Je te conseille vivement d'utiliser une classe comme par exemple celle de i2cdevlib. Sinon un copier/coller de ce que j'ai posté plus haut (message du 15 janvier) devrait être ok, mais c'est codé à l'arrache donc c'est pas forcément le plus propre et compréhensible. Mais ça fonctionne. ^^

                                                        Bon courage pour tes dev'

                                                        -
                                                        Edité par Naik 10 mars 2014 à 11:08:14

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        (\ _ /) (='.'=) Voici Lapinou. Aidez le à conquérir le monde (")-(") en le reproduisant.

                                                        [Arduino] Connaître l'inclinaison avec un MPU-6050

                                                        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                        × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                        • Editeur
                                                        • Markdown