Bras de robot 6 axes avec ATMega328 et servomoteurs

Cet article nous a été envoyé par notre auteur invité Miguel Torres Gordo. Nous vous souhaitons beaucoup de plaisir à le lire et à le reproduire :

J'ai toujours été fasciné par les mouvements des bras des robots lorsqu'ils effectuent toutes sortes de tâches. Leurs mouvements sont précis et continus, comme si j'assistais à un cours de danse. Ces robots industriels disposent de moteurs puissants et de circuits électroniques spéciaux pour contrôler les mouvements selon des coordonnées programmées. Serait-il possible de construire un petit bras robotisé avec des modules et des composants électroniques simples ?

Le principal problème est le poids de la structure du bras robotique et des actionneurs qui doivent le déplacer. Idéalement, la structure devrait être en métal et les actionneurs devraient être des moteurs pas à pas, mais cet ensemble est lourd et coûteux. La question est la suivante : serait-il possible de le faire avec des servomoteurs ?

Il faut chercher un matériau qui ne soit pas très lourd et peu coûteux. Pour les incrustations (travaux de marqueterie), on utilise du balsa, qui n'est pas lourd mais résistant. Ainsi, il est possible que les servomoteurs déplacent l'ensemble, l'électronique pour la commande y étant déjà intégrée. Nous allons développer un bras robotisé qui prend les pièces avec une pince et les dépose à un autre endroit.

Les matériaux nécessaires pour ce projet sont

• 1x Carte microcontrôleur avec câble USB
• 1x PCA9685 16 canaux 12 bits de PWM
• 3x MG995 Micro Servo Moteur
• 2x MG90S Micro Servomotor
• 1x SG90 Micro Servo Motor 9G
• Câble Jumper Wire
• Alimentation externe (min. 5V)
• Contreplaqué en Bois 3mm
• Colle à bois
• Chevilles en bois

Le logiciel requis est :

• Arduino Ide
• Sketchs de Robotarm et Sketch d'ajustement
• Bibliothèque Wire (intégrée)
  
• Adafruit_PWMServoDriver library (via le gestionnaire de bibliothèque ou le ZIP de Github)
  

La première étape consiste à concevoir la structure de notre bras robotique en balsa de 3mm d'épaisseur. Pour que les différentes pièces de notre robot puissent supporter le poids de la pièce suivante, nous devons augmenter l'épaisseur de ces pièces en collant plusieurs morceaux identiques (le poids n'augmente pas beaucoup, comme vous le remarquerez). Pour soutenir les mouvements des servomoteurs, on doit équilibrer un peu le poids des bras, en tenant compte du poids du bras à l'autre extrémité.

Plan à télécharger

Pour le fonctionnement de notre bras robotisé, il est très important de connaître les données de largeur d'impulsion des servomoteurs afin de pouvoir positionner l'angle minimal et maximal avec les sketches de réglage et d'amener le bras robotisé dans la position souhaitée. Selon la fiche technique, le servomoteur MG995 tourne à 120 degrés, tandis que les servomoteurs MG90S et SG90 tournent à 180 degrés. Pour déterminer les données de largeur d'impulsion nécessaires, nous utilisons les sketches Servo_check_120_degrees_slow_motion.ino et Servo_check_180_degrees.ino et un rapporteur, comme indiqué sur le dessin.

Les deux sketchs sont très similaires, c'est pourquoi nous allons expliquer les lignes les plus importantes d'un des deux sketchs. Les lignes suivantes font partie du croquis des servomoteurs MG995. Les deux premières lignes que nous analysons sont les valeurs minimales et maximales de la largeur d'impulsion pour chaque servomoteur, qui correspondent aux positions 0 degré et 180 degrés.

 #define SERVOMIN 100         // This is the 'minimum' pulse length count (out of 4096)
 #define SERVOMAX 500         // This is the 'maximum' pulse length count (out of 4096)

Dans les lignes suivantes, on crée deux boucles dans lesquelles on doit modifier les données marquées en rouge pour positionner le servomoteur entre 30 degrés et 150 degrés. Dans ce cas, on obtient les 120 degrés avec lesquels le MG995 travaille.
Le mouvement se fait lentement avec 10 "pas" toutes les 50 millisecondes de 30 degrés à 150 degrés. On doit effectuer ces procédures avec tous les servomoteurs que nous allons utiliser et noter les valeurs correspondantes pour chacun d'entre eux, car ce sont les valeurs entre lesquelles il travaille pour se positionner.

for (int pos=165; pos<430; pos +=10) {       // Loop with movement slow from 30
  degrees to 150 degrees
  pwm.setPWM(0, 0, pos );
  Serial.println("165 pulse length count --> 30 degrees");
  delay(50);
}
delay (5000);
​
for (int pos_m=430; pos_m>165; pos_m -=10) {   // Loop with movement slow from 150
  degrees to 30 degrees
  pwm.setPWM(0, 0, pos_m );
  Serial.println("430 pulse length count --> 150 degrees");
  delay(50);
}
delay (5000);

Montage

Une fois que nous avons les valeurs d'impulsion minimale et maximale pour l'angle de travail minimal et maximal de chaque servomoteur, il est temps de tout assembler. Pour réaliser correctement l'assemblage, vous pouvez procéder comme suit :

1. on commence le montage sur le préhenseur, celui-ci étant fermé et le servomoteur tourné de 90 degrés.

2. le servomoteur suivant est le numéro 1, avec la position à 0 degré et la pince dans la position que l'on voit sur la photo, car la rotation de 180 degrés se fait dans le sens des aiguilles d'une montre.

3. le troisième servomoteur est le numéro 2, qui, comme le précédent, se trouve en position 0 degré et déplace le préhenseur verticalement vers le haut, car il tourne également dans le sens des aiguilles d'une montre pour se déplacer vers 180 degrés.

4. c'est maintenant le tour du servomoteur numéro 3, on laisse dans ce cas la position du servomoteur à 90 degrés et on monte le bras en ligne avec le suivant, car on a ainsi 60 degrés de mouvement dans chaque direction.

5. pour le servomoteur numéro 4, on laisse la position à 90 degrés et on monte le bras horizontalement (parallèlement au sol), ce qui nous donne, comme pour le servomoteur précédent, un grand rayon d'action de 60 degrés dans chaque direction.

6. on laisse le dernier servomoteur, numéro 5, à 90 degrés, comme le précédent, et on monte la plateforme tournante de façon à ce que le reste du bras soit au milieu du bord latéral de la base.

Circuit et description du fonctionnement

Comme tu peux le voir sur le schéma électrique, le circuit est très simple. Nous avons le microcontrôleur, le module PCA9685 et les 6 servomoteurs.

Les connexions électriques des servomoteurs au module PCA9685 sont reliées au numéro du port de sortie PWM correspondant sur le module, en fonction de la numérotation du servomoteur, c'est-à-dire que le servomoteur numéro 0 est relié au port de sortie 0.

L'alimentation en courant continu de 5V est connectée au connecteur à vis vert de la carte pilote, en faisant attention à la polarité, car les servomoteurs sont alimentés par cette connexion.

Les connexions entre le microcontrôleur Atmega328P et le module PCA9685 sont la communication I2C via son port et les 5V pour l'alimentation de l'électronique du module.

Les six servomoteurs sont contrôlés par le microcontrôleur Atmega328P via le module PCA9685, qui a deux fonctions importantes. La première consiste à alimenter les servomoteurs en 5V à partir d'une alimentation externe suffisamment puissante pour déplacer les 6 servomoteurs simultanément. La seconde consiste à envoyer à chaque servomoteur le signal PWM transmis par le microcontrôleur via le signal I2C. Comme on peut le voir sur le schéma ci-dessus, nous n'avons besoin que de 2 broches pour la communication entre le microcontrôleur et le module PCA9685, les autres broches étant laissées pour d'autres utilisations.

La partie vraiment pénible de ce projet est le réglage des valeurs pour chaque position du bras et des vitesses des mouvements. Ce dernier doit être plus lent si le bras doit ramasser un objet.

Pour le réglage et le mouvement du bras du robot à chaque étape, un sketch a été créé pour chaque étape. Cela permet d'effectuer les réglages individuellement. Une fois que nous aurons effectué tous les réglages correctement, nous les regrouperons tous dans un seul sketch. Pour ce faire, nous utiliserons des méthodes/fonctions, de sorte que le code soit plus propre et plus facile à suivre. Analysez le code pour un niveau et vous verrez qu'il est très simple. Pour les autres niveaux, la méthode d'adaptation est similaire.

Le code que nous allons analyser est le paramétrage du bras robotique pour prendre la première pièce. Le sketch s'appelle pick_up_first_object.ino.

Les deux premières lignes de code sont les bibliothèques dont nous avons besoin pour que le sketch fonctionne correctement. Wire.h est responsable de la communication I2C et Adafruit_PWMServoDriver est responsable de l'utilisation du module PCA9685.

#include <Wire.h>

#include <Adafruit_PWMServoDriver.h>

Les 4 lignes suivantes sont, dans l'ordre, l'implémentation d'un objet Adafruit_PWMServoDriver pour contrôler les positions des servomoteurs, SERVOMIN et SERVOMAX sont les valeurs du front montant et du front descendant pour la position 0 degré et 180 degrés des servomoteurs respectivement. La variable de vitesse est utilisée pour le temps d'attente avant le mouvement du servomoteur suivant.

Adafruit_PWMServoDriver pca9685 = Adafruit_PWMServoDriver();

#define SERVOMIN  100             

#define SERVOMAX  500            

int velocidad = 450;

Les 4 lignes suivantes sont, dans l'ordre, l'implémentation d'un objet Adafruit_PWMServoDriver pour contrôler les positions des servomoteurs, SERVOMIN et SERVOMAX sont les valeurs du front montant et du front descendant pour la position 0 degré et 180 degrés des servomoteurs respectivement. La variable de vitesse est utilisée pour le temps d'attente avant le mouvement du prochain servomoteur. Dans la méthode setup(), nous initialisons le moniteur série et émettons un message. Dans les deux lignes suivantes, nous initialisons le module PCA9685 à l'aide de son objet précédemment implémenté et indiquons la fréquence à laquelle les servomoteurs fonctionnent, à savoir 50 Hz.

Dans la méthode setup()-, nous initialisons le moniteur série et affichons un message. Dans les deux lignes suivantes, nous initialisons le module PCA9685 à l'aide de son objet précédemment implémenté et indiquons la fréquence à laquelle les servomoteurs fonctionnent, à savoir 50 Hz.

void setup() {

   Serial.println("Ajusting to Pick up first object");

   pca9685.begin();

   pca9685.setPWMFreq(50);

}

Nous mettons maintenant en œuvre la (loop)-méthode. Nous commençons ici par les réglages de chacun des servomoteurs qui doivent agir pour exécuter le mouvement. Nous commençons par le premier servomoteur que nous voulons déplacer. Le servomoteur 5 est celui qui fait tourner le bras du robot. Avec la fonction pca9685.setPWM(5, 0, 350), on indique au module PCA9685 qu'il doit déplacer le moteur 5 dans la position résultant de la soustraction de la valeur du front montant (0) du front descendant (350) et, avec la fonction delay(velocidad ), nous attendons 450 millisecondes pour exécuter la prochaine fonction du servomoteur suivant.

void loop() {

       // Servomotor 5

       pca9685.setPWM(5, 0, 350);

       delay(velocidad);

Les deux appels de fonction suivants exécutent les mouvements des servomoteurs 4 et 2. L'exécution est similaire à celle de la fonction précédente, d'abord déplacer le servomoteur 4, attendre 450 millisecondes et après ce temps, déplacer le servomoteur 2 à la position de la différence entre le front montant et le front descendant.

       // Servomotor 4

       pca9685.setPWM(4, 0, 210);

       delay(velocidad);

       // Servomotor 2

       ca9685.setPWM(2, 0, 405);

       delay(velocidad);

Les deux fonctions suivantes exécutent les mouvements des servomoteurs 3 et 2. Expliquons pourquoi nous avons implémenté des boucles pour cela. Le mouvement des servomoteurs précédents se fait à la vitesse normale, qui est très abrupte. Pour donner la sensation d'une vitesse lente, nous avons implémenté une boucle dans laquelle le servomoteur se déplace d'un "pas" toutes les 10 millisecondes depuis la position de départ (150) de la variable pos jusqu'à sa position finale (180) du servomoteur 3. Le mouvement réel est un mouvement intermittent, mais comme le temps d'attente entre chaque mouvement n'est que de 10 millisecondes, le mouvement donne une sensation de continuité à faible vitesse. Comme le mouvement est ainsi lisse, il nous aide à obtenir une bonne précision.

  // Servomotor 3

       for (int pos=150; pos<180; pos +=1) {

           pca9685.setPWM(3, 0, pos);

           delay(10);

       }

       // Servomotor 2

       for (int pos=405; pos>350; pos -=1) {

             pca9685.setPWM(2, 0, pos);

             delay(10);

       }

L'évolution des deux dernières fonctions, qui déplacent les servomoteurs 1 et 0 (préhenseur), est similaire à celle décrite ci-dessus. Le servomoteur 1 se déplace à vitesse normale et le servomoteur 0, qui représente le préhenseur, le ferme à vitesse lente, car il est en boucle.

      // Servomotor 1

       pca9685.setPWM(1, 0, 300);

       delay(velocidad);

       // Servomotor 0

       for (int pos=200; pos>166; pos -=1) {

           pca9685.setPWM(0, 0, pos);

           delay(10);

       }

Le dernier temps d'attente dans certains des différents sketches est de 60 secondes, car il s'agit de mouvements à l'intérieur de boucles qui sont exécutés en continu. De cette manière, nous pouvons vérifier quelles coordonnées sont correctes dans quelles positions et nous pouvons adapter les valeurs des variables pos de chaque servomoteur de manière à ce que le bras du robot soit positionné aux coordonnées souhaitées.

       delay(60000);

}

Pour effectuer le réglage à chaque étape, nous devons exécuter le sketch correspondant et faire varier les valeurs des variables pos de chaque servomoteur jusqu'à ce que le bras du robot atteigne la position souhaitée.

Le sketch robot_arm.ino préparé exécute une trajectoire qui part d'une position de sécurité, déplace deux pièces et revient à la position de sécurité. J'ai essayé de simplifier autant que possible la programmation de ce sketch. C'est pourquoi j'ai déposé le code de chaque étape sous forme de sketchs séparée et les ai programmées comme fonctions dans la méthode loop() du sketch robot_arm.ino avec les mêmes noms. Ainsi, nous savons à tout moment dans quelle position se trouve notre bras robotisé.

Lorsque les servomoteurs sont connectés au module PCA9685 et que celui-ci est alimenté, les servomoteurs conservent la position dans laquelle ils se trouvent. J'en ai profité pour réduire le nombre de fonctions à certains niveaux. Si nous avons un servomoteur dans une position à l'étape précédente et que la suivante est la même, nous n'avons pas besoin de changer, nous éliminons donc cette dernière puisqu'elle conserve la position qu'elle avait auparavant.

Je vous souhaite beaucoup de plaisir avec ce projet.

Miguel Torres Gordo