Contrôleur de bras robotique MK2 Plus

Outils et machines nécessaires

Imprimante 3D (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Le bras EEZYBOT MK2

Si vous avez cherché sur thingverse.com des bras robotiques sympas, il y a de fortes chances que vous soyez tombé dessus. Le bras EEZYBOT MK2 (conçu par le brillant daghizmo ) partage la cinématique de l'ABB IRB460 réduite avec un rapport de 1:7. Cependant, ce bras est conçu pour fonctionner avec des servos, ce qui le rend un peu fragile et moins gracieux. Il existe cependant une meilleure solution. Le bras MK2 Plus trouvé ici, https://www.thingverse.com/thing:2520572 est une version remixée du bras MK2 d'origine qui utilise 3 moteurs pas à pas pour déplacer ses liaisons.

L'impression prend un certain temps, alors ajoutez cet article à vos favoris, faites tout imprimer et revenez une fois que vous avez terminé ! (Cela prendra quelques jours)

Si vous rencontrez des difficultés pour assembler le bras, il existe de nombreux tutoriels en ligne.

Sélection d'une position d'origine

Contrairement aux servos, les moteurs pas à pas n'ont aucune conscience de la position. Nous devrons remédier à cela en mettant d'abord en place une routine de ralliement lorsque le bras est sous tension. Nous utiliserons 3 interrupteurs de fin de course pour régler notre position d'origine. Les liaisons fonctionnent de manière quelque peu complexe, mais vous comprendrez facilement où positionner les interrupteurs une fois que vous aurez assemblé le bras et vu comment tout bouge.

(c'est-à-dire qu'il n'y a pas de système XY comme un système cartésien, mais nous les appellerons de toute façon pour rendre les choses plus faciles)

Vous pouvez régler l'interrupteur de fin de course Z n'importe où sur la base principale du bras. Ajoutez un peu de colle chaude pour que vos fils ne se détachent pas lorsque le bras bouge.

Câblage

Le câblage est assez simple, car toutes les bornes sont marquées sur le blindage CNC. Ne branchez pas vos pilotes A4988 dans le mauvais sens ! Le moteur pas à pas sur le côté avec l'interrupteur de fin de course Y doit être branché à la borne pour le moteur pas à pas Y dans votre bouclier CNC. Il en va de même pour le moteur à côté du fin de course X. (Nous les appelons X et Y car il est plus facile de traiter le blindage CNC de cette façon) Connectez le dernier pas à pas qui fait tourner la base du bras à la borne Z et câblez les butées en fonction de leurs noms. La polarité n'a pas d'importance.

Trouvez une bonne alimentation 12 V qui peut fournir le courant nécessaire aux moteurs pour qu'ils fonctionnent sans caler.

Code

Nous allons passer aux choses sérieuses. Nous utiliserons la bibliothèque AccelStepper pour Arduino pour piloter les steppers en douceur. Cette bibliothèque vous permet d'accélérer, de décélérer et d'exécuter facilement plusieurs moteurs pas à pas simultanément. Vous pouvez obtenir cette bibliothèque directement via l'IDE Arduino en utilisant le gestionnaire de bibliothèque (Esquisse > Inclure la bibliothèque > Gestionnaire de bibliothèque)

Vous pouvez également l'obtenir sur la page des créateurs originaux sur airspayce. https://www.airspayce.com/mikem/arduino/AccelStepper/

Maintenant que nous avons tout ce dont nous avons besoin, passons en revue le code étape par étape.

Nous allons d'abord définir quelques noms pour les broches que nous allons utiliser. Vous pouvez trouver un schéma des broches du bouclier CNC avec une recherche rapide d'images sur Google. Nous allons également créer les objets AccelStepper pour nos 3 moteurs pas à pas.

#define XSTEP 2 //Broche pas à pas du moteur pas à pas
#define YSTEP 3
#define ZSTEP 4
#define XDIR 5 // Broche de contrôle de la direction du moteur pas à pas
#define YDIR 6
#define ZDIR 7
#define ENABLE 8 // Broche d'activation du blindage CNC
#define XLIMIT 9 // Broches de fin de course
#define YLIMIT 10
#define ZLIMIT 11
#define XMOTORACC 250 // Valeurs d'accélération et de vitesse max
#define XMOTORMAXSPEED 1000
#define YMOTORACC 250
#define YMOTORMAXSPEED 1000
# inclure 
AccelStepper XMOTOR(1,XSTEP,XDIR);
AccelStepper YMOTOR(1,YSTEP,YDIR);
AccelStepper ZMOTOR(1,ZSTEP,ZDIR); 

Créons une petite fonction d'aide pour configurer nos broches.

void pinsetup(){
 pinMode(ENABLE,OUTPUT);
 digitalWrite(ENABLE,LOW);
 pinMode(XLIMIT,INPUT_PULLUP);
 pinMode( YLIMIT,INPUT_PULLUP);
 pinMode(ZLIMIT,INPUT_PULLUP);
} 

Maintenant que c'est fait, passons en revue la logique de notre routine de ralliement.

void autohome(){ //Nous l'utilisons pour appeler notre routine de homing 
 xyhome();
 zhome();
}
void xyhome () {
 int initial_xhome =-1;
 int initial_yhome =-1;
 // Définir la vitesse maximale et l'accélération de chaque pas au démarrage pour le homing
 XMOTOR.setMaxSpeed ​​(500.0 ); // Définir la vitesse maximale du pas à pas (plus lent pour obtenir une meilleure précision)
 XMOTOR.setAcceleration (50.0); // Définir l'accélération du pas à pas
 YMOTOR.setMaxSpeed(500.0); // Définir la vitesse maximale du pas à pas (plus lent pour obtenir une meilleure précision)
 YMOTOR.setAcceleration (50.0); // Définir l'accélération du moteur pas à pas
 // Démarrer la procédure de prise d'origine du moteur pas à pas au démarrage
 while (digitalRead(YLIMIT)) { // Faire bouger le moteur pas à pas dans le sens antihoraire jusqu'à ce que le commutateur soit activé
 XMOTOR. moveTo(initial_xhome); // Définit la position vers laquelle se déplacer
 YMOTOR.moveTo(initial_yhome); // Définit la position de déplacement vers
 initial_xhome--; // Diminuer de 1 pour le prochain mouvement si nécessaire
 initial_yhome--;
 XMOTOR.run(); // Commencer à déplacer le stepper
 YMOTOR.run();
 delay(5);
 }
 XMOTOR.setCurrentPosition(0); // Définir la position actuelle à zéro pour le moment
 YMOTOR.setCurrentPosition(0);
 initial_xhome =-1;
 initial_yhome =1;
 while(digitalRead(XLIMIT)){ 
 XMOTOR.moveTo(initial_xhome); // Définit la position vers laquelle se déplacer
 YMOTOR.moveTo(initial_yhome); // Définit la position de déplacement vers
 initial_xhome--; // Diminuer de 1 pour le prochain mouvement si nécessaire
 initial_yhome++;
 XMOTOR.run(); // Commencer à déplacer le stepper
 YMOTOR.run();
 delay(5);
 }
 YMOTOR.setCurrentPosition(0); // Définit la position actuelle à zéro pour l'instant
 YMOTOR.setMaxSpeed(250.0); // Définir la vitesse maximale du pas à pas (plus lent pour obtenir une meilleure précision)
 YMOTOR.setAcceleration(10.0); // Définir l'accélération du pas à pas
 initial_yhome =1;
 while (!digitalRead(YLIMIT)) { // Faire bouger le pas à pas dans le sens horaire jusqu'à ce que le commutateur soit désactivé
 YMOTOR.moveTo(initial_yhome); 
 YMOTOR.run();
 initial_yhome++;
 delay(5);
 }
 YMOTOR.setCurrentPosition(0);
 YMOTOR.setMaxSpeed(YMOTORMAXSPEED ); // Définir la vitesse maximale du pas à pas (plus rapide pour les mouvements réguliers)
 YMOTOR.setAcceleration(YMOTORACC); // Définir l'accélération du stepper
 XMOTOR.setCurrentPosition(0); // Définir la position actuelle sur zéro pour le moment
 XMOTOR.setMaxSpeed(250.0); // Définir la vitesse maximale du pas à pas (plus lent pour obtenir une meilleure précision)
 XMOTOR.setAcceleration(10.0); // Définir l'accélération du pas à pas
 initial_xhome =1;
 while (!digitalRead(XLIMIT)) { // Faire bouger le pas à pas dans le sens horaire jusqu'à ce que le commutateur soit désactivé
 XMOTOR.moveTo(initial_xhome); 
 XMOTOR.run();
 initial_xhome++;
 delay(5);
 }
 XMOTOR.setCurrentPosition(0);
 XMOTOR.setMaxSpeed(XMOTORMAXSPEED ); // Définir la vitesse maximale du stepper (plus rapide pour les mouvements réguliers)
 XMOTOR.setAcceleration(XMOTORACC); // Définir l'accélération du stepper
}
void zhome() {
 int initial_zhome =-1;
 // Définir la vitesse maximale et l'accélération de chaque stepper au démarrage pour le homing
 ZMOTOR.setMaxSpeed ​​(100.0); // Définir la vitesse maximale du pas à pas (plus lent pour obtenir une meilleure précision)
 ZMOTOR.setAcceleration (100.0); // Définir l'accélération du moteur pas à pas
 // Démarrer la procédure de prise d'origine du moteur pas à pas au démarrage
 while (digitalRead(ZLIMIT)) { // Faire bouger le moteur pas à pas dans le sens antihoraire jusqu'à ce que l'interrupteur soit activé
 ZMOTOR. moveTo(initial_zhome); // Définit la position vers laquelle se déplacer
 initial_zhome--; // Diminuer de 1 pour le prochain mouvement si nécessaire
 ZMOTOR.run(); // Commencer à déplacer le stepper
 delay(5);
 }
 ZMOTOR.setCurrentPosition(0); // Définir la position actuelle sur zéro pour l'instant
 ZMOTOR.setMaxSpeed ​​(50.0); // Définir la vitesse maximale du moteur pas à pas (plus lent pour obtenir une meilleure précision)
 ZMOTOR.setAcceleration (50.0); // Définir l'accélération du pas à pas
 initial_zhome =1;
 while (!digitalRead(ZLIMIT)) { // Faire bouger le pas à pas dans le sens horaire jusqu'à ce que le commutateur soit désactivé
 ZMOTOR.moveTo(initial_zhome); 
 ZMOTOR.run();
 initial_zhome++;
 delay(5);
 }
 ZMOTOR.setCurrentPosition(0);
 ZMOTOR.setMaxSpeed(1000.0 ); // Définir la vitesse maximale du pas à pas (plus rapide pour les mouvements réguliers)
 ZMOTOR.setAcceleration(1000.0); // Définir l'accélération du stepper
} 

Bon, ça fait beaucoup de code. Que se passe-t-il vraiment ici ? Le bras exécute d'abord une routine de ralliement sur les moteurs X et Y. En raison de la façon dont les liens fonctionnent, cela se fait en quelques étapes. (Vous pouvez voir la vidéo à la fin pour voir cela en action)

• Tout d'abord, les moteurs X et Y sont déplacés dans des directions opposées de sorte que l'interrupteur de fin de course Y est enfoncé en premier.
• Dès que le fin de course Y est enfoncé, les deux moteurs tournent dans le même sens de sorte que le fin de course X est enfoncé.
• Après avoir appuyé sur l'interrupteur X, les moteurs sont déplacés un peu pour que les interrupteurs soient enfoncés (enfoncés comme dans, pas le triste un peu enfoncé.)
• Enfin, le moteur Z est tourné de manière à ce que l'interrupteur de fin de course Z soit enfoncé.

Vous devrez être très prudent lorsque vous effectuez la procédure de homing pour la première fois. Si vos steppers se déplacent dans l'autre sens, COUPEZ L'ALIMENTATION, PUIS retournez le connecteur du moteur.

Maintenant que c'est fait, appelez autohome() depuis votre fonction setup() pour qu'elle ne s'exécute qu'une seule fois. Laissez votre boucle() vide. Et gardez une main sur votre alimentation pour l'éteindre en cas de problème.

void setup() {
 // mettez votre code de configuration ici, à exécuter une fois :
 Serial.begin(9600);
 pinsetup();
 autohome();
 Serial.println("HOMING OK");
} 

Si vous avez de la chance, vos moteurs tourneront dans le bon sens, les interrupteurs de fin de course cliqueront juste et la routine de ralliement fonctionnera sans aucun problème. Mais si vous êtes comme moi, vous devrez faire de petits changements avant que tout soit opérationnel. Débranchez donc toujours l'alimentation si le ralliement se passe mal afin de ne pas gâcher votre bras imprimé en 3D.

Enfin, vous pouvez écrire votre propre logique dans la boucle () afin que votre bras se déplace dans les positions souhaitées. En raison de la façon dont le bras est lié, les moteurs X et Y contrôlent l'effecteur final de manière presque cartésienne.

boucle vide() {
 XMOTOR.runToNewPosition(100);
 delay(1000);
 YMOTOR.runToNewPosition(50);
 delay(1000);
 YMOTOR.runToNewPosition(-50);
 delay(1000);
 YMOTOR.runToNewPosition(0);
 delay(1000);
 XMOTOR.runToNewPosition( 0);
 retard(1000);
} 

Conclusion

J'ai vu beaucoup de tutoriels sur la façon d'utiliser le micrologiciel GRBL populaire pour contrôler ce bras. Cependant, cela signifie que vous avez besoin d'un ordinateur pour envoyer des commandes série au bras afin de le faire bouger. Si vous n'avez besoin que du bras MK2 pour effectuer quelques mouvements, vous pouvez facilement les coder en dur dans l'Arduino et le laisser faire son propre travail.

Cela ne veut pas dire que vous ne pouvez pas contrôler cela avec des commandes série ! Vous pouvez simplement incorporer un code délimiteur série dans celui-ci et envoyer les pas de moteur XY et Z sous forme de chaîne (délimité par des caractères spéciaux - par exemple 5, 6, 7* qui déplacerait le moteur X de 5 pas, le Y de 6 et le Z par 7. Le * est utilisé pour indiquer la fin de la chaîne).

Vous pouvez également développer cela davantage pour envoyer les coordonnées spatiales 3D de l'effecteur final et demander à l'arduino de déterminer les étapes requises à l'aide de la cinématique inverse, ou même de la trigonométrie de base.

S'amuser! Et mes plus sincères remerciements à tous les brillants designers de Thingiverse !

Code

• robotArm

robotArmArduino

Aucun aperçu (téléchargement uniquement).

Contrôleur de bras robotique MK2 - Github

Pièces et boîtiers personnalisés

Robot Arm MK2 Plus sur Thingiverse