Curseur de caméra de suivi d'objet avec axe de rotation. Imprimé en 3D et construit sur le contrôleur de moteur à courant continu RoboClaw et Arduino : 5 étapes (avec photos)

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

Projets Fusion 360 »

Ce projet a été l'un de mes projets préférés depuis que j'ai pu combiner mon intérêt pour la réalisation de vidéos avec le bricolage. J'ai toujours regardé et voulu imiter ces plans cinématographiques dans les films où une caméra se déplace sur un écran tout en faisant un panoramique pour suivre l'objet. Cela ajoute un effet de profondeur très intéressant à une vidéo autrement 2D. Voulant reproduire cela sans dépenser des milliers de dollars en équipement hollywoodien, j'ai décidé de construire moi-même un tel curseur de caméra.

L'ensemble du projet est construit sur des pièces que vous pouvez imprimer en 3D, et le code s'exécute sur la populaire carte Arduino. Tous les fichiers du projet tels que les fichiers CAO et le code sont disponibles en téléchargement ci-dessous.

Fichiers d'impression CAO/ 3D disponibles ici

Fichier de code Arduino disponible ici

Le projet s'articule autour des 2 moteurs à courant continu à balais à engrenages et du contrôleur de moteur Basic Micro Roboclaw. Ce contrôleur de moteur peut transformer les moteurs à courant continu à balais en un type de servomoteur supérieur avec une précision de position incroyable, des tonnes de couple et une rotation complète à 360 degrés. Plus à ce sujet plus tard.

Avant de continuer, regardez d'abord le didacticiel vidéo lié ici. Ce tutoriel vous donnera un aperçu de la façon de construire ce projet et ce guide Instructables ira plus en profondeur dans la façon dont j'ai construit ce projet.

Matériaux-

• 2 tiges filetées m10 de 1 mètre de long utilisées pour relier toutes les pièces
• 8x écrous M10 pour monter les pièces sur les tiges filetées
• 2 tiges en acier lisse de 8 mm de long de 95 cm pour le coulissement
• 4x roulements lm8uu pour que le curseur glisse en douceur sur les tiges d'acier
• 4x écrous m3 de 10 mm de long pour le montage du moteur
• 2 x roulements de skate (diamètre extérieur 22 mm, diamètre intérieur 8 mm) pour l'axe de rotation
• 1x 15mm roulement pour le côté fou
• 1x boulon m4 de 4 cm de long avec contre-écrou m4 pour le montage du roulement de renvoi sur la pièce imprimée en 3D du renvoi.
• Engrenage à 20 dents avec un diamètre intérieur de 4 mm pour le moteur du curseur. La poulie exacte n'est pas très importante car votre moteur à courant continu doit être adapté pour un couple suffisant. Assurez-vous simplement que c'est le même pas que votre ceinture
• Courroie GT2 de 2 mètres de long. Encore une fois, vous pouvez utiliser n'importe quelle courroie tant qu'elle correspond au pas des dents de votre poulie.

Électronique

• 2 * Motoréducteurs à courant continu avec encodeurs (l'un contrôle le mouvement latéral, tandis que l'autre contrôle l'axe de rotation). Voici celui que j'ai utilisé. Plus d'informations à ce sujet dans la partie électronique du guide
• Contrôleur de moteur à courant continu RoboClaw. (J'ai utilisé le contrôleur double 15Amp car il me permettait de contrôler les deux moteurs avec un contrôleur)
• N'importe quel Arduino. J'ai utilisé l'Arduino UNO
• Batterie/Source d'alimentation. (J'ai utilisé une batterie LiPo 7.4V 2 cellules)
• Écran (Pour afficher le menu. Tout écran compatible U8G fonctionnera, j'ai utilisé cet écran OLED de 1,3 pouces)
• Encodeur rotatif (pour naviguer et configurer les options dans le menu)
• Bouton poussoir physique (Pour déclencher le mouvement du curseur)

Étape 1: conception de matériel + construction + impression 3D

Passons maintenant à l'électronique. L'électronique est l'endroit où ce projet a beaucoup de flexibilité.

Commençons par le cœur de ce projet: les 2 moteurs à courant continu à balais.

J'ai choisi les moteurs à courant continu à balais pour plusieurs raisons.

1. Les moteurs à balais sont beaucoup plus simples à câbler et à utiliser que les moteurs pas à pas
2. Les moteurs à courant continu à balais sont beaucoup plus légers que les moteurs à courant continu, ce qui est particulièrement important pour le moteur à axe de rotation, car ce moteur se déplace physiquement latéralement avec la caméra et il est important de le rendre aussi léger que possible pour éviter une contrainte excessive sur le moteur principal du curseur de la caméra.

J'ai choisi ce moteur à courant continu en particulier. Ce moteur m'a donné un couple extrêmement élevé qui était nécessaire pour déplacer une telle charge de caméra. De plus, l'engrenage élevé signifiait que le régime maximal était lent, ce qui signifiait que je pouvais filmer des mouvements plus lents, et l'engrenage élevé conduisait également à une précision de position plus élevée car une rotation de 360 degrés de l'arbre de sortie signifiait 341,2 comptes de l'encodeur du moteur.

Cela nous amène au contrôleur de mouvement RoboClaw. Le contrôleur de moteur à courant continu à double moteur Roboclaw prend des instructions simples de votre Arduino via des commandes de code simples et effectue tout le traitement lourd et la fourniture de puissance pour que votre moteur fonctionne comme prévu. L'Arduino peut envoyer des signaux au Roboclaw via PWM, tension analogique, série simple ou série par paquets. La série de paquets est la meilleure solution car elle vous permet de récupérer les informations du Roboclaw qui sont nécessaires au suivi de position. Je vais approfondir la partie logiciel/programmation du Roboclaw à l'étape suivante (programmation).

Essentiellement, le Roboclaw peut transformer un moteur à balais CC avec un encodeur pour qu'il ressemble davantage à un servo grâce à la capacité du RoboClaw à effectuer un contrôle de position. Cependant, contrairement à un servo traditionnel, votre moteur à courant continu à balais a maintenant beaucoup plus de couple, beaucoup plus de précision de position grâce à un engrenage moteur élevé, et plus important encore, votre moteur à courant continu peut tourner à 360 degrés en continu, ce qu'un servo traditionnel ne peut pas faire.

La prochaine partie électronique est l'écran. Pour mon écran, j'ai choisi cette dalle OLED en raison de sa taille et de son contraste élevé. Ce contraste élevé est incroyable et rend l'écran très facile à utiliser en plein soleil tout en ne donnant pas trop de lumière qui pourrait interférer avec une potentielle prise de vue sombre. Cet écran peut être facilement échangé contre un autre écran compatible U8G. La liste complète des écrans compatibles est disponible ici. En fait, ce projet a été intentionnellement codé autour de la bibliothèque U8G afin que les constructeurs de bricolage comme vous aient plus de flexibilité dans leurs pièces

Les pièces électroniques finales pour ce projet étaient l'encodeur rotatif et le bouton-poussoir pour démarrer le mouvement du curseur. L'encodeur vous permet de naviguer dans le menu de l'écran et de configurer tout le menu du curseur avec une seule molette. L'encodeur rotatif n'a pas de position « fine » comme un potentiomètre traditionnel, ce qui est particulièrement utile pour modifier les coordonnées x et y du suivi de l'objet à l'écran. Le bouton poussoir sert exclusivement à démarrer le mouvement du curseur sans avoir à manipuler l'encodeur rotatif.

Étape 3: Programmation du curseur de la caméra

Le codage était de loin le défi le plus difficile de ce projet. Vous voyez, dès le départ, je voulais que le curseur soit contrôlable depuis un écran. Pour rendre ce projet compatible avec le plus d'écrans possible, j'ai dû utiliser la bibliothèque U8Glib pour l'Arduino. Cette bibliothèque prend en charge plus de 32 écrans. Cependant, la bibliothèque U8Glib a utilisé une boucle d'image pour dessiner le menu à l'écran et cela était en conflit avec la capacité de l'Arduino à collecter simultanément des informations sur la position de la caméra qui étaient nécessaires pour la fonctionnalité de calcul de l'angle de la caméra (ceci est couvert dans les deux prochains paragraphes). L'U8Glib2 a une alternative à la boucle d'image en utilisant ce qu'on appelle une option de mémoire tampon pleine page, mais la bibliothèque consommait trop de mémoire et rendait difficile l'ajustement du reste du code étant donné les contraintes de mémoire de l'Arduino Uno. Cela signifiait que j'étais coincé avec U8G et que je devais contourner le problème en empêchant l'écran de se mettre à jour à chaque fois que le curseur était en mouvement et que l'Arduino devait collecter des données de position à partir du Roboclaw. J'ai également été obligé de déclencher le curseur pour commencer à sortir de la boucle de menu, car une fois entré dans les sous-menus, je serais à l'intérieur de la boucle d'image et le curseur ne fonctionnerait pas comme prévu. J'ai également contourné ce problème en faisant en sorte qu'un bouton physique séparé déclenche le mouvement du curseur.

Parlons maintenant de l'élément de suivi de rotation. Cette partie semble très complexe à intégrer, mais elle est en fait assez simple. L'implémentation pour cela se trouve sous la fonction 'motor()' dans mon code Arduino. La première étape consiste à créer une grille en 2 dimensions et à décider où l'objet que vous souhaitez suivre est placé. Sur cette base, vous pouvez dessiner un triangle vers votre position actuelle. Vous pouvez obtenir votre position actuelle à partir de la valeur du codeur du moteur. Si vous souhaitez configurer la position de l'objet suivi en cm/mm, vous devrez traduire la valeur de votre encodeur en une valeur cm/mm. Cela peut être fait simplement en déplaçant le curseur de la caméra de 1 cm et en mesurant l'augmentation de la valeur de l'encodeur. Vous pouvez saisir cette valeur en haut du code sous la variable encoder_mm.

Nous allons maintenant utiliser la fonction de tangente inverse pour obtenir l'angle auquel la caméra doit faire face pour pointer vers votre objet. La tangente inverse prend le côté opposé et adjacent du triangle. Le côté opposé du triangle ne change jamais car il s'agit de la distance y entre votre curseur et l'objet. Le côté adjacent du curseur de la caméra change cependant. Ce côté adjacent peut être calculé en prenant la position x de l'objet et en soustrayant votre position actuelle. Au fur et à mesure que le curseur se déplace dans son amplitude de mouvement, il continuera à mettre à jour l'Arduino sur la valeur de l'encodeur. L'Arduino convertira à plusieurs reprises cette valeur d'encodeur en une valeur de position cm/mm x, puis calculera la longueur du côté adjacent, et enfin calculera l'angle auquel la caméra doit faire face à tout moment pour pointer vers l'objet.

Maintenant que notre Arduino traite dynamiquement l'angle de la caméra, nous pouvons nous attaquer à la conversion de cet angle en une valeur de position pour que le moteur de rotation se déplace. Cela nous amène à la plus grande fonctionnalité de RoboClaw pour ce projet. En donnant au Roboclaw une valeur de position, il peut essentiellement faire en sorte qu'un moteur à balais CC se comporte comme un servo. Sauf contrairement à un servo, notre moteur a beaucoup plus de couple, une précision beaucoup plus élevée et peut également tourner à 360 degrés.

Le code Arduino pour déplacer le Roboclaw vers une certaine position est le suivant:

roboclaw. SpeedAccelDeccelPositionM1(adresse, 'vitesse', 'accélération', 'décélération', 'position à laquelle vous voulez aller', 1);

Pour régler la valeur de position du moteur afin qu'elle corresponde à l'angle de votre caméra, vous devrez déplacer manuellement la plaque de la caméra de 180 degrés. Ensuite, voyez à quel point la valeur de l'encodeur a changé depuis le déplacement de la plaque de la caméra de 0 degrés à 180 degrés. Cela vous donne votre plage d'encodeur. Vous pouvez entrer cette plage dans la fonction motrice qui mappe l'angle de la caméra de l'Arduino à une valeur de position. Ceci est également commenté dans le code, il devrait donc être facile à trouver *****

Le RoboClaw m'a également donné la possibilité de régler d'autres facteurs tels que l'accélération, la décélération et les valeurs PID. Cela m'a permis en outre de lisser le mouvement de l'axe de rotation, en particulier lorsque les changements d'angle étaient infimes et ajoutaient des secousses sans valeur PID « D » élevée. Vous pouvez également régler automatiquement vos valeurs PID via l'application de bureau de Roboclaw.

Étape 4: Utilisation du curseur de la caméra

Venons-en maintenant à la partie amusante, en actionnant le curseur. Le menu comporte 4 onglets principaux. L'onglet du haut est dédié au contrôle de la vitesse. La rangée du milieu du menu contient des onglets pour configurer la position X & Y de l'objet suivi en mm, et également configurer si nous voulons que le curseur tourne et suive notre objet ou simplement faire un simple mouvement de glissement sans rotation. Tourner l'encodeur rotatif nous permet de naviguer dans les différentes options des menus. Pour configurer l'une des options, accédez à l'option et appuyez sur l'encodeur rotatif. Une fois enfoncé, la rotation de l'encodeur rotatif changera la valeur du sous-menu en surbrillance plutôt que de parcourir le menu. Une fois que vous avez atteint la valeur souhaitée, vous pouvez cliquer à nouveau sur l'encodeur rotatif. Vous êtes maintenant de retour au menu principal et pouvez naviguer entre les différents onglets. Une fois que vous êtes prêt, appuyez simplement sur le bouton aller à côté de l'écran et le curseur fait son travail !

Assurez-vous qu'une fois que vous avez fini d'utiliser le curseur de la caméra, que la caméra est dans la position « home »: le côté du curseur sur lequel elle a commencé. La raison en est que l'encodeur du moteur n'est pas un encodeur absolu, ce qui signifie que le Roboclaw/Arduino ne peut pas dire où se trouve l'encodeur. Ils peuvent seulement dire à quel point l'encodeur a changé depuis sa dernière mise sous tension. Cela signifie que lorsque vous éteignez le curseur de votre caméra, le curseur « oubliera » la position du curseur et réinitialisera l'encodeur à 0. Par conséquent, si vous éteignez votre curseur de l'autre côté, lorsque vous l'allumez, le curseur essayez de vous déplacer plus loin que le bord et de vous écraser contre le mur coulissant. Ce comportement de l'encodeur est également la raison pour laquelle la caméra réinitialise son angle de rotation après chaque mouvement de glissement de la caméra. L'axe de rotation se protège également de l'écrasement dans la fin de son amplitude de mouvement.

Vous pouvez résoudre ce problème en ajoutant des butées et une procédure de référencement lors du démarrage. C'est ce qu'utilisent les imprimantes 3D.

Étape 5: Réflexions finales + Améliorations futures

Je recommande fortement à chaque constructeur de créer ses propres versions de ce curseur plutôt que de créer exactement le même curseur. Ajuster ma conception vous permettra de construire votre curseur selon vos spécifications exactes tout en comprenant mieux le fonctionnement de l'électronique et du code.

J'ai rendu le code aussi lisible et configurable que possible afin que vous puissiez modifier/calibrer les différentes variables de code pour les spécifications de votre curseur. Le code est également entièrement construit autour de fonctions, donc si vous souhaitez copier/ajuster/réécrire certains comportements du curseur, vous n'avez pas besoin de rétro-concevoir et de retravailler l'intégralité du code, mais uniquement les parties que vous souhaitez modifier.

Enfin, si je faisais une version 2.0, voici quelques améliorations que je ferais

1. Rapport de démultiplication plus élevé pour le moteur à axe de rotation. Un rapport de démultiplication plus élevé signifie que je peux faire de petits mouvements plus précis. Ceci est particulièrement critique lorsque la caméra est loin de votre objet et que l'angle de votre caméra change très lentement. Actuellement, mon moteur n'est pas réglé trop haut et il peut en résulter un mouvement légèrement saccadé lorsque le curseur de la caméra tourne trop lentement ou lorsqu'il y a très peu de changement d'angle de rotation. L'ajout d'une valeur PID « D » élevée m'a aidé à m'en débarrasser, mais s'est fait au prix d'une précision de suivi des objets légèrement inférieure.
2. Longueur modulaire. C'est un objectif farfelu, mais j'aimerais que le curseur de la caméra soit de longueur modulaire, ce qui signifie que vous pouvez facilement attacher de plus longues longueurs de rail pour que la caméra puisse glisser. C'est assez difficile car il faudra parfaitement aligner les deux pistes et comprendre comment faire fonctionner le système de courroie. Néanmoins, ce serait une mise à niveau cool!
3. Mouvement personnalisé Keyframes. J'aimerais introduire le concept de mouvements d'images clés dans ce curseur de caméra. Le keyframing est une technique très couramment utilisée dans la production vidéo et audio. Cela permettrait des mouvements de caméra non linéaires où la caméra se rend à une position, attend, puis se déplace vers une autre position à une vitesse différente, attend, puis passe à une troisième position, etc.
4. Contrôle Bluetooth/téléphone sans fil. Ce serait vraiment cool de pouvoir configurer les paramètres du curseur de la caméra sans fil et de pouvoir déployer le curseur de la caméra dans des endroits difficiles d'accès. L'application pour téléphone pourrait également ouvrir des opportunités d'intégration d'images clés, comme mentionné dans le dernier paragraphe.

C'est tout pour ce tuto. N'hésitez pas à déposer vos questions dans la section commentaires ci-dessous.

Pour plus de tutoriels sur le contenu et l'électronique, vous pouvez également consulter ma chaîne YouTube ici.