Cardan de contrôle de mouvement : 12 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Bonjour à tous, Je m'appelle Harji Nagi. Je suis actuellement étudiant en deuxième année d'études en électronique et ingénierie de la communication à l'Institut de technologie Pranveer Singh, Kanpur (UP). J'ai un vif intérêt pour la robotique, l'arduino, l'intelligence artificielle et l'électronique analogique.

Le mot « cardan » est défini comme un support pivotant qui permet la rotation de n'importe quel objet dans un seul axe. Ainsi, un cardan à trois axes permet à tout objet monté sur le cardan d'être indépendant du mouvement de celui qui tient le cardan. Le cardan dicte le mouvement de l'objet, pas celui qui le porte.

Il se compose de 3 servomoteurs MG996R pour le contrôle 3 axes, et d'une base sur laquelle seront placés le capteur MPU6050, l'Arduino et la batterie. Il est utilisé pour maintenir la caméra stabilisée sans vibration. Un cardan à 3 axes garantit que le mouvement de la caméra est stabilisé même si celui qui la tient monte et descend, gauche et droite, avant et arrière. C'est ce que nous appelons stabilisation en lacet, en tangage et en roulis.

Étape 1: Liste des composants

La liste des composants sont:

1)Arduino Uno

2) Batterie 8 V, 1,5 A pour alimenter Arduino Uno

3) 7805 Régulateur de tension Ic ou vous pouvez utiliser un convertisseur buck

4)MPU 6050

5) 3 * (moteurs SERVO MG995)

6) fils de cavalier

Autres équipements:

1) fer à souder

2) pistolet à colle

3) perceuse

4) La nourriture peut

Au lieu d'utiliser breadborad, j'ai utilisé une petite carte de perf personnalisée pour une connexion de bus positive et négative

Étape 2: Assemblage

Le noyau en mousse, le panneau de mousse ou le panneau de mousse recouvert de papier est un matériau léger et facile à couper utilisé pour le montage de servomoteurs et pour la fabrication de modèles réduits.

Tout d'abord, j'ai fabriqué des supports en forme de L de bricolage pour monter un servomoteur à l'aide d'un panneau de mousse.

Étape 3:

L'assemblage du cardan était assez facile. J'ai commencé par installer le servo Yaw, le capteur MPU 6050 et l'interrupteur ON-OFF. À l'aide de boulons et d'écrous, je l'ai fixé à la base

Étape 4: Ensuite, en utilisant la même méthode, j'ai sécurisé le servo de rouleau. les pièces sont spécialement conçues pour s'adapter facilement aux servos MG995

Étape 5: Ensuite, en utilisant la même méthode, j'ai sécurisé le servo de rouleau. les pièces sont spécialement conçues pour s'adapter facilement aux servos MG995

Étape 6: Connexions

Dans le schéma de circuit, vous pouvez utiliser soit un convertisseur abaisseur, soit un régulateur de tension 7805 IC pour convertir 8 V en 5 V. Le microcontrôleur qui est donné sur le schéma de circuit est Arduino Nano, vous pouvez également utiliser Arduino Uno, Arduino Mega.

Les broches SCL et SDA du MPU 6050 sont connectées aux broches analogiques Arduino A5 et A4. (Les broches SCL et SDA peuvent varier, alors consultez la fiche technique des broches SCl et SDA pour d'autres microcontrôleurs)

Étape 7: connexion avec le régulateur de tension 7805 IC

Ce schéma de circuit est pour la connexion du régulateur de tension 7805, connectez la batterie 8v à Vin et vous obtiendrez une tension de sortie de 5v.

Étape 8: Codage

Vous devez inclure les bibliothèques suivantes:

1)#includeCliquez icipour télécharger le fichier zip

2)#includeCliquez ici pour télécharger le fichier zip

Après avoir téléchargé le fichier zip, ajoutez la bibliothèque zip dans le croquis arduino

Pour le code

/*

DIY Gimbal - MPU6050 Arduino Tutorial Code basé sur l'exemple MPU6050_DMP6 de la bibliothèque i2cdevlib de Jeff Rowberg: https://github.com/jrowberg/i2cdevlib */ // I2Cdev et MPU6050 doivent être installés en tant que bibliothèques, sinon le.cpp/ Les fichiers.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" // pas nécessaire si vous utilisez le fichier d'inclusion MotionApps / / 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 #include // l'adresse I2C par défaut de la classe est 0x68 // des adresses I2C spécifiques peuvent être passé en paramètre ici // AD0 low = 0x68 (par défaut pour SparkFun breakout et la carte d'évaluation InvenSense) // AD0 high = 0x69 MPU6050 mpu; //MPU6050 mpu(0x69); // <-- utiliser pour AD0 high // Définir les 3 servomoteurs Servo servo0; Servo servo1; Servo servo2; flotteur correct; entier j = 0; #define OUTPUT_READABLE_YAWPITCHROLL #define INTERRUPT_PIN 2 // utilise la broche 2 sur Arduino Uno et la plupart des cartes bool blinkState = false; // Contrôle/état MPU vars bool dmpReady = false; // défini sur true si l'initialisation DMP a réussi uint8_t mpuIntStatus; // contient l'octet d'état d'interruption réel du MPU uint8_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 FIFO uint8_t fifoBuffer[64]; // Tampon de stockage FIFO // orientation/mouvement vars Quaternion q; // [w, x, y, z] conteneur de quaternions VectorInt16 aa; // [x, y, z] accélère les mesures du capteur VectorInt16 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 mondial Gravité VectorFloat; // [x, y, z] vecteur de gravité float euler[3]; // [psi, theta, phi] Conteneur d'angle d'Euler float ypr[3]; // [lacet, tangage, roulis] conteneur lacet/tangage/rouleau et vecteur de gravité // structure de paquet pour la démonstration de théière InvenSense uint8_t teapotPacket[14] = { '$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\r', '\n' }; // ================================================ ================ // === ROUTINE DE DÉTECTION D'INTERRUPTION === // ====================== =========================================== volatile bool mpuInterrupt = false; // indique si la broche d'interruption MPU est devenue haute void dmpDataReady() { mpuInterrupt = true; } // =============================================== ================= // === CONFIGURATION INITIALE === // ===================== =========================================== configuration vide() { // rejoindre le bus I2C (la bibliothèque I2Cdev ne le fait pas automatiquement) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin(); Wire.setClock(400000); // Horloge I2C 400 kHz. Commentez cette ligne si vous rencontrez des difficultés de compilation #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif // initialise la communication série // (115200 choisi car requis pour la sortie Teapot Demo, mais c'est // vraiment à vous de décider selon votre projet) Serial.begin(38400); tandis que (!Série); // attendre l'énumération Leonardo, les autres continuent immédiatement // initialiser le périphérique //Serial.println(F("Initializing I2C devices…")); mpu.initialize(); pinMode(INTERRUPT_PIN, INPUT); devStatus = mpu.dmpInitialize(); // fournissez vos propres décalages de gyroscope ici, mis à l'échelle pour une sensibilité minimale mpu.setXGyroOffset(17); mpu.setYGyroOffset(-69); mpu.setZGyroOffset(27); mpu.setZAccelOffset(1551); // 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); attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), 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…")); dmpReady = 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 // (si cela va se casser, le code sera généralement 1) // Serial.print(F("DMP Initialization failed (code ")); //Serial.print(devStatus); //Serial.println(F(")")); } // Définit les broches auxquelles sont connectés les 3 servomoteurs servo0.attach(10); servo1.attach(9); servo2.attache(8); } // =============================================== ================= // === BOUCLE DE PROGRAMME PRINCIPAL === // ==================== ============================================ boucle vide() { / / si la programmation a échoué, n'essayez pas de faire quoi que ce soit si (!dmpReady) retourne; // attend une interruption MPU ou des paquets supplémentaires disponibles while (!mpuInterrupt && fifoCount < packetSize) { if (mpuInterrupt && fifoCount

= 1024) {

// réinitialiser afin que nous puissions continuer proprement mpu.resetFIFO(); fifoCount = mpu.getFIFOCount(); Serial.println(F("débordement FIFO !")); // sinon, vérifiez l'interruption des données DMP prêtes (cela devrait arriver fréquemment) } else if (mpuIntStatus & _BV(MPU6050_INTERRUPT_DMP_INT_BIT)) { // attendez la longueur des données disponibles correcte, devrait être une attente TRÈS courte pendant (fifoCount 1 paquet disponible / / (cela nous permet de lire immédiatement la suite sans attendre une interruption) fifoCount -= packetSize; // Récupère les valeurs de Yaw, Pitch et Roll #ifdef OUTPUT_READABLE_YAWPITCHROLL mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); // Valeurs de lacet, de tangage, de roulis - Radians en degrés ypr[0] = ypr[0] * 180 / M_PI; ypr[1] = ypr[1] * 180 / M_PI; ypr[2] = ypr[2] * 180 / M_PI; // Ignorer 300 lectures (processus d'auto-étalonnage) if (j <= 300) { correct = ypr[0]; // Le lacet commence à une valeur aléatoire, donc nous capturer la dernière valeur après 300 lectures j++; } // Après 300 lectures else { ypr[0] = ypr[0] - correct; // Réglez le lacet à 0 deg - soustrayez la dernière valeur aléatoire de lacet de la valeur actuelle pour faire le Yaw 0 degré es // Mapper les valeurs du capteur MPU6050 de -90 à 90 aux valeurs appropriées pour la servocommande de 0 à 180 int servo0Value = map(ypr[0], -90, 90, 0, 180); int valeur servo1 = map(ypr[1], -90, 90, 0, 180); int servo2Value = map(ypr[2], -90, 90, 180, 0); // Contrôle les servos selon l'orientation MPU6050 servo0.write(servo0Value); servo1.write(servo1Value); servo2.write(servo2Value); } #fin si } }

Enfin en utilisant la fonction d'écriture, nous envoyons ces valeurs aux servos comme signaux de commande. Bien sûr, vous pouvez désactiver le servo Yaw si vous voulez juste une stabilisation pour les axes X et Y, et utiliser cette plate-forme comme cardan de caméra

Étape 9: lorsque tous les composants sont connectés, son apparence est similaire à cette image

Étape 10: Insérez maintenant tous les éléments de base à l'intérieur de la boîte de conserve

Étape 11: Lorsque tous les fils et composants sont placés à l'intérieur d'une boîte de conserve, appliquez un pistolet à colle à la base du panneau de mousse

Étape 12: Conclusion

Veuillez noter que ce cardan est loin d'être un bon appareil photo. Les mouvements ne sont pas fluides car ces servos ne sont pas destinés à un tel usage. Les vrais cardans de caméra utilisent un type spécial de moteur BLDC pour obtenir des mouvements fluides. Alors, considérez ce projet uniquement à des fins éducatives.

Ce serait tout pour ce tutoriel, j'espère que vous l'avez apprécié et que vous avez appris quelque chose de nouveau. N'hésitez pas à poser n'importe quelle question dans la section commentaires ci-dessous et n'oubliez pas de consulter mes collections de projets