Premiers pas avec le capteur de mouvement IMU (6 DOF)

À propos de ce projet

Aujourd'hui, nous étudierons le meilleur capteur IMU (unité de mesure d'inertie) disponible et découvrirons comment il peut être interfacé avec un Arduino. Plus tard dans notre prochain tutoriel, nous essaierons de visualiser la détection de mouvement en 3D.

Le module de capteur IMU que nous utiliserons est centré autour d'un capteur MPU-6050.

Les appareils MPU-6050 combinent un gyroscope 3 axes et un accéléromètre 3 axes sur la même puce de silicium, avec un Digital Motion Processor™ (DMP™) intégré , qui traite des algorithmes MotionFusion complexes à 6 axes.

Ces appareils MotionTracking sont conçus pour les exigences de faible consommation, de faible coût et de haute performance des smartphones, des tablettes et des capteurs portables.

Données dont vous avez besoin :

MATÉRIEL :

1) Arduino UNO

2) Capteur MPU 6050

3) Câbles de connexion

LOGICIELS : IDE Arduino

Protocole de communication : Ce capteur IMU communique avec l'Arduino à l'aide du protocole de bus I2C.

Vous pouvez travailler séparément sur les accéléromètres et les gyroscopes, mais ils ne sont pas aussi précis que ce module combiné.

Passons maintenant au schéma de câblage et au profil de connexion.

Reportez-vous à l'une de ces 2 figures ci-dessous pour la connexion.

Si vous rencontrez des problèmes avec les chiffres ci-dessus, pas de panique.....

Parcourez le profil de broche de connexion ci-dessous :

Connectez 5 V [IMU MPU-6050] au VCC [ARDUINO] 

Connectez SDA [IMU MPU-6050] à Analog IN (A4) [ARDUINO] 

Connectez le SCL [IMU MPU-6050] à l'entrée analogique (A5) [ARDUINO] 

Connectez GND [IMU MPU-6050] à GND [ARDUINO]

Connectez INTPIN [IMU MPU-6050] à la broche 2 (broche PWM numérique) [ARDUINO]

Ici, si votre module MPU 6050 a une broche 5V, vous pouvez le connecter à la broche 5V de votre arduino. Sinon, vous devrez le connecter à la broche 3.3V afin d'éviter tout problème de surtension.

Alors maintenant que nous avons configuré le matériel, il est temps de programmer l'Arduino.

Tout d'abord, afin de tester le MPU 6050, cliquez sur ce lien et téléchargez la bibliothèque arduino pour MPU 6050. Il existe un dossier zip nommé "MPU6050.zip". Téléchargez le dossier et extrayez son contenu. Après cela, copiez le dossier de la bibliothèque "MPU6050" et collez-le dans le dossier de la bibliothèque d'Arduino. C'est-à-dire que vous devez vous rendre à l'emplacement où se trouve le dossier "bibliothèques" d'Arduino, puis coller simplement ce dossier "MPU6050" à l'intérieur.

Ensuite, vous devez télécharger une autre bibliothèque, nommée "I2Cdev.zip" (si elle n'a pas déjà été installée) et la coller dans la bibliothèque d'Arduino de la même manière que la précédente.

Alors maintenant, dans le dossier "libraries" d'Arduino, nous avons deux nouvelles entités. (Illustration : 8)

Maintenant, cliquez sur l'IDE arduino et voyez si ces nouvelles bibliothèques sont visibles (Fig (9). 

Avant d'inclure ces bibliothèques dans votre sketch, vous devez récupérer le code pour MPU6050. Reportez-vous à la figure (10)

(Fichier> Exemples> MPU6050> Exemples> MPU6050_DMP6). Cliquez sur ce fichier "MPU6050_DMP6".

Ensuite, incluez les bibliothèques "I2Cdev" et "MPU6050" dans ce croquis [Fig (11)].

Après avoir suivi toutes les étapes, COMPILEZ le croquis [Fig (12)].

Maintenant, la dernière étape reste...

Si vous remarquez qu'en dessous du coin droit de cette fenêtre, le message dit "Arduino/Genuino Uno sur COM1", assurez-vous qu'il est correct. Sinon, reportez-vous à la [Fig (14)]. Ne cliquez pas sur Serial Monitor maintenant. Seulement après avoir téléchargé le croquis [comme dans la figure (13)], passez aux étapes suivantes.

Vous devez vous assurer que le bon port est attribué à chaque fois que vous connectez votre Arduino.

Confus avec cette nouvelle fenêtre ?? Eh bien, c'est votre écran de sortie. Techniquement parlant, nous l'appelons Serial Monitor. C'est là que nous lisons nos valeurs à partir de différents capteurs.

ÉTAPE :       Outils > Moniteur série     ou    Touche de raccourci (Ctrl + Maj + M) 

Si vous rencontrez des problèmes avec le téléchargement de l'esquisse, même si vous avez sélectionné les bons ports. Cliquez sur ce lien (pour les utilisateurs de Windows). Pour les utilisateurs de Mac, reportez-vous au guide. Les utilisateurs de Linux se réfèrent à cette page Web pour obtenir des conseils.

Après avoir téléchargé le code, ouvrez le moniteur série et modifiez le "débit en bauds" à 115200. Si vous sélectionnez d'autres débits en bauds, vous verrez des commentaires inutiles car ceux-ci ne seront pas synchronisés. REMARQUE : Les processeurs hôtes de 8 MHz ou plus lents, comme le Teensy @ 3,3 v ou l'Ardunio Pro Mini fonctionnant à 3,3 v, ne peuvent pas gérer ce débit en bauds de manière fiable en raison du décalage en bauds avec les tics du processeur. Vous devez utiliser 38400 ou plus lent dans ces cas, ou utiliser une sorte de solution cristalline externe séparée pour la minuterie UART.

Si vous ne voyez pas cette déclaration "Initializing I2C devices…" sur votre écran, appuyez sur le bouton RESET. Cela devrait fonctionner maintenant. [Fig (15)]

CONNAISSANCES>> Vous verrez une ligne indiquant « Envoyer n'importe quel caractère pour commencer la programmation et la démo DMP : » Qu'est-ce que DMP ? ?

Réponse : DMP signifie Digital Motion Processing . Le MPU 6050 de l'Invense est doté d'un processeur de mouvement intégré. Il traite les valeurs de l'accéléromètre et du gyroscope pour nous donner des valeurs 3D précises; c'est-à-dire lacet, tangage et roulis. [Illustration (16)]

CONNAISSANCES>> Nous avons vu que la communication entre le capteur et l'arduino est basée sur le protocole I2C Bus. De même, nous avons également inclus une bibliothèque I2C dans ce projet. savez-vous ce que signifie I2C ?

Réponse : Le bus I2C se compose physiquement de 2 fils actifs et d'une connexion à la terre. Les fils actifs, appelés SDA et SCL , sont tous deux bidirectionnels. SDA est la ligne Serial DATA et SCL est la ligne Serial Clock. Chaque périphérique connecté au bus a sa propre adresse unique, qu'il s'agisse d'un MCU, d'un pilote LCD, d'une mémoire ou d'un ASIC. Chacune de ces puces peut servir de récepteur et/ou d'émetteur, selon la fonctionnalité. De toute évidence, un pilote LCD n'est qu'un récepteur, tandis qu'une mémoire ou une puce d'E/S peut être à la fois émetteur et récepteur. Le bus I2C est un bus multi-maître. Cela signifie que plusieurs circuits intégrés capables d'initier un transfert de données peuvent y être connectés. La spécification du protocole I2C stipule que le circuit intégré qui initie un transfert de données sur le bus est considéré comme le maître du bus. Par conséquent, à ce moment-là, tous les autres circuits intégrés sont considérés comme des esclaves de bus. Comme les maîtres de bus sont généralement des microcontrôleurs, ici par exemple, le maître de bus est ArduinoUno. De même, le capteur MPU est l'esclave du bus.

Visualisez le mouvement en 3D dans mon prochain tutoriel. Cliquez ici

Code

• Code Arduino pour capteur MPU

Code Arduino pour capteur MPUArduino

*/// I2Cdev et MPU6050 doivent être installés en tant que bibliothèques, ou bien les fichiers .cpp/.h// pour les deux classes doivent être dans le chemin d'inclusion de votre projet#include "I2Cdev.h"#include "MPU6050_6Axis_MotionApps20 .h"//#include "MPU6050.h" // non nécessaire si vous utilisez MotionApps include file // La bibliothèque Arduino Wire est requise si l'implémentation I2Cdev I2CDEV_ARDUINO_WIRE // est utilisée dans I2Cdev.h#if I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE #include " Wire .h"#endif// l'adresse I2C par défaut de la classe est 0x68// des adresses I2C spécifiques peuvent être transmises en tant que paramètre ici// AD0 low =0x68 (par défaut pour SparkFun breakout et la carte d'évaluation InvenSense)// AD0 high =0x69MPU6050 mpu;/ /MPU6050 mpu(0x69); // <-- utiliser pour AD0 haut/* =========================================================================REMARQUE :En plus de la connexion 3.3v, GND, SDA et SCL, cette esquisse dépend de la broche INT du MPU-6050 connectée à la broche d'interruption externe #0 de l'Arduino. Sur les Arduino Uno et Mega 2560, il s'agit de la broche d'E/S numérique 2. * ==========================================================================*//* =========================================================================REMARQUE :Arduino v1.0.1 avec la carte Leonardo génère une erreur de compilation lors de l'utilisation de Serial.write(buf, len). La sortie Théière utilise cette méthode. La solution nécessite une modification du fichier Arduino USBAPI.h, ce qui est heureusement simple, mais ennuyeux. Cela sera corrigé dans la prochaine version de l'IDE. Pour plus d'informations, consultez ces liens :http://arduino.cc/forum/index.php/topic,109987.0.html http://code.google.com/p/arduino/issues/detail?id=958 * =========================================================================*/// décommentez "OUTPUT_READABLE_QUATERNION" si vous voulez voir les composants réels// quaternion dans un [w, x, y, z] (pas le meilleur pour l'analyse// sur un hôte distant tel que Processing ou quelque chose cependant)//#define OUTPUT_READABLE_QUATERNION// décommentez "OUTPUT_READABLE_EULER" si vous voulez voir les angles d'Euler// (en degrés) calculés à partir des quaternions à venir du FIFO.// Notez que les angles d'Euler souffrent du blocage du cardan (pour plus d'informations, voir// http://en.wikipedia.org/wiki/Gimbal_lock)//#define OUTPUT_READABLE_EULER// décommentez "OUTPUT_READABLE_YAWPITCHROLL" si vous le souhaitez pour voir les angles de lacet/// tangage/roulis (en degrés) calculés à partir des quaternions provenant // du FIFO. Notez que cela nécessite également des calculs de vecteur de gravité.// Notez également que les angles de lacet/pitch/roll souffrent du blocage de la nacelle (pour// plus d'informations, voir :http://en.wikipedia.org/wiki/Gimbal_lock)#define OUTPUT_READABLE_YAWPITCHROLL/ / Décommentez "OUTPUT_READABLE_REALACCEL" si vous voulez voir l'accélération// les composants sans gravité. Ce référentiel d'accélération n'est// pas compensé pour l'orientation, donc +X est toujours +X selon le// capteur, juste sans les effets de la gravité. Si vous voulez une accélération// compensée pour l'orientation, utilisez OUTPUT_READABLE_WORLDACCEL à la place.//#define OUTPUT_READABLE_REALACCEL// décommentez "OUTPUT_READABLE_WORLDACCEL" si vous voulez voir l'accélération// les composants avec gravité supprimés et ajustés pour le cadre mondial de // référence (le lacet est par rapport à l'orientation initiale, puisqu'aucun magnétomètre// n'est présent dans ce cas). Pourrait être très pratique dans certains cas.//#define OUTPUT_READABLE_WORLDACCEL// décommentez "OUTPUT_TEAPOT" si vous voulez une sortie qui correspond au// format utilisé pour la démo de théière InvenSense//#define OUTPUT_TEAPOT#define LED_PIN 13 // (Arduino est 13 , Teensy est 11, Teensy++ est 6)bool blinkState =false;// MPU control/status varsbool dmpReady =false; // défini sur true si l'initialisation DMP a réussiuint8_t mpuIntStatus ; // contient l'octet d'état d'interruption réel de MPUuint8_t devStatus ; // renvoie l'état après chaque opération de périphérique (0 =succès, !0 =erreur)uint16_t packetSize; // taille de paquet DMP attendue (la valeur par défaut est de 42 octets)uint16_t fifoCount ; // compte de tous les octets actuellement dans FIFOuint8_t fifoBuffer[64] ; // Tampon de stockage FIFO// orientation/mouvement varsQuaternion q; // [w, x, y, z] quaternion containerVectorInt16 aa; // [x, y, z] mesures du capteur d'accélérationVectorInt16 aaReal; // [x, y, z] mesures du capteur d'accélération sans gravitéVectorInt16 aaWorld; // [x, y, z] mesures du capteur d'accélération du cadre mondialVectorFloat Gravity; // [x, y, z] gravité vectorfloat euler[3]; // [psi, theta, phi] Euler angle containerfloat ypr[3]; // [lacet, tangage, roulis] conteneur lacet/tangage/rouleau et vecteur de gravité// structure de paquet pour la théière InvenSense demouint8_t teapotPacket[14] ={ '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n' };// ================================================================// ===ROUTINE DE DETECTION D'INTERRUPTION ===// ================================================================volatile bool mpuInterrupt =false; // indique si la broche d'interruption MPU est devenue highvoid dmpDataReady() { mpuInterrupt =true;}// ================================================================// ===CONFIGURATION INITIALE ===// ================================================================void setup() { // rejoindre le bus I2C (la bibliothèque I2Cdev ne le fait pas automatiquement) #if I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE Wire.begin(); TWBR =24 ; // Horloge I2C 400kHz (200kHz si CPU est à 8MHz) #elif I2CDEV_IMPLEMENTATION ==I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif // initialise la communication série // (115200 choisi car il est requis pour la sortie Teapot Demo, mais c'est // vraiment à vous de décider selon votre projet) Serial.begin(115200); tandis que (!Série); // attendez l'énumération Leonardo, les autres continuent immédiatement // REMARQUE :les processeurs hôtes de 8 MHz ou plus lents, comme le Teensy @ 3.3v ou Ardunio // Pro Mini fonctionnant à 3.3v, ne peuvent pas gérer ce débit en bauds de manière fiable en raison // de la synchronisation en bauds étant trop désaligné avec les ticks du processeur. Vous devez utiliser // 38400 ou plus lent dans ces cas, ou utiliser une sorte de solution de cristal // externe séparée pour le minuteur UART. // initialise le périphérique Serial.println(F("Initialisation des périphériques I2C...")); mpu.initialize(); // vérifier la connexion Serial.println(F("Testing device connections...")); Serial.println(mpu.testConnection() ? F("Connexion MPU6050 réussie") :F("Connexion MPU6050 échouée")); // attendre le prêt Serial.println(F("\nEnvoyer n'importe quel caractère pour commencer la programmation DMP et la démo :")); while (Serial.available() &&Serial.read()); // tampon vide while (!Serial.available()); // attend les données while (Serial.available() &&Serial.read()); // vider à nouveau le tampon // charger et configurer le DMP Serial.println(F("Initializing DMP...")); devStatus =mpu.dmpInitialize(); // fournissez vos propres décalages de gyroscope ici, mis à l'échelle pour une sensibilité minimale mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1788) ; // 1688 par défaut d'usine pour ma puce de test // assurez-vous que cela a fonctionné (renvoie 0 si oui) if (devStatus ==0) { // activez le DMP, maintenant qu'il est prêt Serial.println(F("Enabling DMP. ..")); mpu.setDMPEnabled(true); // active la détection d'interruption Arduino Serial.println(F("Activation de la détection d'interruption (interruption externe Arduino 0)...")); attachInterrupt(0, dmpDataReady, RISING); mpuIntStatus =mpu.getIntStatus(); // définit notre indicateur DMP Ready pour que la fonction principale loop() sache qu'il est possible de l'utiliser Serial.println(F("DMP ready ! En attente de la première interruption...")); dmpPrêt =vrai ; // obtenir la taille de paquet DMP attendue pour une comparaison ultérieure packetSize =mpu.dmpGetFIFOPacketSize(); } else { // ERREUR ! // 1 =échec du chargement initial de la mémoire // 2 =échec des mises à jour de la configuration DMP // (en cas de panne, le code sera généralement 1) Serial.print(F("DMP Initialization failed (code ")); Serial. print(devStatus);Série.println(F(")")); } // configurer la LED pour la sortie pinMode (LED_PIN, OUTPUT);}// =================================================================// ===BOUCLE DE PROGRAMME PRINCIPAL ===// ================================================================void loop() { // si la programmation a échoué, n'essayez pas de faire quoi que ce soit si (!dmpReady) return ; // attend l'interruption du MPU ou des paquets supplémentaires disponibles pendant que (!mpuInterrupt &&fifoCount  1 paquet disponible // (cela nous permet d'en lire plus immédiatement sans attendre une interruption) fifoCount -=packetSize; #ifdef OUTPUT_READABLE_QUATERNION // affiche les valeurs des quaternions sous forme de matrice simple :w x y z mpu.dmpGetQuaternion(&q, fifoBuffer); Serial.print("quat\t"); Serial.print(q.w); Serial.print("\t"); Serial.print(q.x); Serial.print("\t"); Serial.print(q.y); Serial.print("\t"); Serial.println(q.z); #endif #ifdef OUTPUT_READABLE_EULER // affiche les angles d'Euler en degrés mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetEuler(euler, &q); Serial.print("euler\t"); Serial.print(euler[0] * 180/M_PI); Serial.print("\t"); Serial.print(euler[1] * 180/M_PI); Serial.print("\t"); Serial.println(euler[2] * 180/M_PI); #endif #ifdef OUTPUT_READABLE_YAWPITCHROLL // affiche les angles d'Euler en degrés mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); Serial.print("ypr\t"); Serial.print(ypr[0] * 180/M_PI); Serial.print("\t"); Serial.print(ypr[1] * 180/M_PI); Serial.print("\t"); Serial.println(ypr[2] * 180/M_PI); #endif #ifdef OUTPUT_READABLE_REALACCEL // affiche l'accélération réelle, ajustée pour supprimer la gravité mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetAccel(&aa, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity); Serial.print("areal\t"); Serial.print(aaReal.x); Serial.print("\t"); Serial.print(aaReal.y); Serial.print("\t"); Serial.println(aaReal.z); #endif #ifdef OUTPUT_READABLE_WORLDACCEL // affiche l'accélération initiale du cadre mondial, ajustée pour supprimer la gravité // et pivotée en fonction de l'orientation connue du quaternion mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetAccel(&aa, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity); mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q); Serial.print("aworld\t"); Serial.print(aaWorld.x); Serial.print("\t"); Serial.print(aaWorld.y); Serial.print("\t"); Serial.println(aaWorld.z); #endif #ifdef OUTPUT_TEAPOT // afficher les valeurs de quaternions au format de démonstration InvenSense Teapot :teapotPacket[2] =fifoBuffer[0] ; théièrePacket[3] =fifoBuffer[1]; teapotPacket[4] =fifoBuffer[4]; teapotPacket[5] =fifoBuffer[5]; teapotPacket[6] =fifoBuffer[8]; teapotPacket[7] =fifoBuffer[9]; teapotPacket[8] =fifoBuffer[12]; théièrePacket[9] =fifoBuffer[13]; Serial.write(teapotPacket, 14); théièrePaquet[11]++; // packetCount, boucle à 0xFF exprès #endif // LED clignotante pour indiquer l'activité blinkState =!blinkState; digitalWrite(LED_PIN, blinkState); }}

Schémas