Bras robotique programmable local et à distance

Applications et services en ligne

	Arduino IDE
	MIT App Inventor 2

À propos de ce projet

Le but de ce tutoriel est de développer pas à pas un projet de contrôle et de programmation d'un Bras Robotique, simulant les fonctions de base d'un robot industriel.

Étape 1 :Spécifications

Le robot a deux fonctions de base :

• Programme :Enregistrez les positions des bras en trois dimensions (chaque enregistrement est un "pas")

• Courir :Effectuez en séquence les positions enregistrées dans le "Programme". Le robot exécutera le programme jusqu'à ce que la commande "ABORT" soit utilisée.

Caractéristiques principales :

• Le projet peut être utilisé pour contrôler des robots avec 3 ou 4 DOF ("Degrés de Liberté").

• Le robot peut être contrôlé en modes "LOCAL" et "REMOTE" (le dernier via un appareil Android)

• Pendant la phase de programme, l'utilisateur peut changer le mode de contrôle de « LOCAL » à « DISTANT » et vice et versa.

• Les informations à l'utilisateur seront fournies par des LED colorées, un affichage LED à 2 lignes et un son (un buzzer).

• L'alarme sonore peut également être déclenchée à distance.

Étape 2 :​Le projet

Le schéma fonctionnel de l'étape précédente montre la "Bill of Material" qui sera utilisée dans ce projet.

J'ai opté pour l'Arduino MEGA afin de ne pas me soucier du nombre de ports Arduino (E/S) disponibles. L'UNO, par exemple, fonctionnerait sans problème mais une méthode d'extension de port devrait être utilisée. Il existe plusieurs options que l'on trouve facilement sur internet, comme un décodeur 74138 par exemple.

Ici, le premier prototype étant programmé en "mode local".

Pour le réseau Bluetooth, le HC-06 sera utilisé.

L'application Android utilisée pour le "mode à distance ", a été développé à l'aide de l'outil MIT Appinventor2, qui est une plate-forme unique puissante pour ce type d'application basée sur des appareils Android. L'application est disponible en téléchargement gratuit sur la boutique Google :MJRoBot Arduino Robot Arm Control.

La vidéo ci-dessous peut vous donner une idée de ce que devrait être le projet final avec programmation à distance :

Étape 3 :Développement du projet

Les bras robotiques peuvent être classés en fonction du nombre de « joints » ou de « degrés de liberté » (DOF) qu'ils possèdent.

• Le "Base ", ou "Taille ", peut généralement faire tourner le bras à 180o ou 360o, selon le type de servo utilisé (ici dans ce projet, un servo à 180o a été utilisé).

• L'"Épaule ", est le responsable de " lever ou baisser " le bras verticalement.

• Le "Coude " fera " avancer ou reculer le bras ".

• La "Griffe " ou "Gripper " fonctionne en ouvrant ou en fermant pour "saisir des choses".

Étape 4 :​Le Circuit

Des servomoteurs seront utilisés pour entraîner les articulations, connectés directement à l'Arduino. Notez qu'il n'est pas rare de voir "Moteurs pas à pas" utilisés à la base pour plus de couple et de précision. Le bon choix des servos est très important (il existe des servos chinois bon marché qui sont très mal construits comme le MG995, qui sont malheureusement ceux fournis avec mon SanSmart 3DOF AARM). Mais pour la proposition de ce projet a bien fonctionné.

L'alimentation CC des servos doit être séparée de l'Arduino et des autres composants. Une alimentation externe de 5 ou 6V devrait fonctionner sans problème (consultez la fiche technique de vos servos pour vérifier la plage de tension appropriée). Une pratique courante consiste également à utiliser des condensateurs de 470 uF entre VCC et GND pour minimiser le bruit généré par les moteurs à courant continu à l'intérieur des servomoteurs. Assurez-vous de connecter tous les "Grounds" (source d'alimentation externe avec la broche Arduino GND).

Si les servos ont des problèmes et vibrent beaucoup, faites des ajustements aux "retards" de votre code. Il est important que les servos aient le temps d'arriver à un certain point avant de recevoir une nouvelle commande. Cela vaut également la peine de vérifier si les servos sont numériques ou analogiques, comme s'ils étaient mécaniquement similaires, le numérique fonctionne avec une fréquence de 300 Hz tandis que l'analogique, 50 Hz. La bibliothèque Arduino standard "Servo.h " a été développé pour les servos analogiques et peut être modifié si nécessaire, pour un meilleur fonctionnement avec les servos numériques.

Le dessin ci-dessus montre le circuit complet.

Étape 5 :​Le code

Le projet n'est pas compliqué, mais il comporte de nombreuses variables. Le plus prudent est de les définir clairement et de laisser les remarques sur un fichier unique :

ArmDefine.h

Ce fichier doit également définir les angles minimum, maximum et initial du servo. Le code inclus dans ce didacticiel comporte deux ensembles de paramètres pour les bras robotiques que j'ai testés dans mon projet (bien sûr, seul un groupe de constantes doit être utilisé) :

// MeArm 4-DOF#define minGrip 15 #define minBase 0 #define minShou 60 #define minElbw 60 #define maxGrip 45 #define maxBase 170#define maxShou 180 #define maxElbw 150 #define midGrip 30#define midBase 87#define midShou 138#define midElbw 100/* SS 3-DOF#define minGrip 75 #define minBase 5 #define minShou 5 #define minElbw 0 #define maxGrip 125 #define maxBase 150#define maxShou 155 #define maxElbw 0 #define midGrip 100#define midBase 90#define midShou 90#define midElbw 0 */ 

Chaque type de bras a un ensemble de paramètres différent et il est important que vous trouviez celui qui vous convient. Ce que je suggère, c'est qu'initialement les potentiomètres (pots) restent à son point médian et que le mappage des sorties PWM soit défini sur les valeurs par défaut :Max =255 , Min =0 et Moyen =126 ( "#defines " ci-dessus). Ensuite, commencez à faire varier les pots (un par un) et suivez dans le Serial Monitor (ou LCD) quelles devraient être les valeurs minimales et maximales où le bras fonctionne correctement. Ce seront les valeurs finales à utiliser pour le paramètres (modifier mes valeurs d'origine sur ArmDefine.h) .

Pour « enregistrer » les ensembles de coordonnées (ou étapes) que le robot doit jouer, j'utiliserai des tableaux de données :

int gripPosition[100];int basePosition[100];int shouPosition[100];int elbwPosition[100];int positionIndex =0; // Index à utiliser au tableau de position utilisé pour les tâches enregistrées 

A noter que je ne garde pas la position "stockée" et à la fin du programme "robot", l'index est revenu à zéro et le robot attendra l'enregistrement d'une nouvelle séquence (le programme est perdu). Alternativement, vous pouvez conserver ces tableaux de données dans l'EEPROM Arduino, par exemple. En faisant cela, le programme serait exécuté à nouveau ou même vous pourriez avoir plus d'un programme stocké.

Étape 6 :​La logique du programme

Le bloc principal ("Loop") est vraiment assez simple :

Vérifiez si une commande pour exécuter le "programme" (séquence d'étapes) a été utilisée.

• Si c'est le cas, lancez-le.

• Sinon, le "programme" n'est pas terminé et doit encore écrire de nouvelles étapes.

• Si une « nouvelle position » est définie, ajoutez-la au programme.

• Tout d'abord, vérifie les messages arrivant dans la mémoire tampon série, à partir de l'appareil Android.

• Ensuite, vérifie si le mode de contrôle est "Local" ou "Remote" (la valeur par défaut est Local).

• Revenez au début et effectuez à nouveau l'étape 1.

boucle vide (){ checkBTcmd (); defineLocalRemote (); execTaskCmd =digitalRead (execTaskPin); if (execTaskCmd ==|| commande HIGH =="runon") { RunProgram (); } else recArmPosition (); commande ="";} 

La fonction checkBTcmd() assemble une chaîne en utilisant les caractères individuels qui arrivent du module BT. Cette chaîne est passée à la variable "commande ".

La fonction defineLocalRemote() considère la variable "commande " vérifier si une commande pour changer le mode à distance est reçue ou vice versa. La commande d'alarme est également analysée ici. Pour la logique du programme, si l'"Alarme" est déclenchée dans l'appareil Android, le bras doit nécessairement aller à la télécommande mode.

La fonction RunProgram() effectue les préparatifs, allume / éteint les LED, etc et surtout invoque la fonction :ExecuteTask() . Cette dernière est la fonction qui contient la logique d'exécution de la séquence d'étapes. La fonction augmente le "positionIndex " envoyer les données de position à armer une par une à l'aide de l'outil :armPosition(grip, base, épaule, coude) .

Enfin, la fonction qui commande vraiment les servos et écrit les "pas" est la recArmPosition() . En fonction de la réception de la commande Android, cette fonction définira le positionnement des servos qui peuvent être soit via les pots, soit via les "curseurs" de l'application Android. A chaque changement de position, cette fonction envoie les coordonnées aux servos en utilisant le armPosition fonction (prise, base, épaule, coude). La lecture de la position réelle des pots ou des curseurs et l'activation correspondante des servos se produisent au moment où la commande "SAVE" ou "PROGRAM" est déclenchée. A ce moment, l'index de position des tableaux est incrémenté et le pas stocké.

Pour simplifier la compréhension, tout le code était basé sur ses fonctions spécifiques. Le "Configuration ", "Boucle " et les fonctions décrites ci-dessus sont pratiquement toutes dans le fichier :MJRoBot_Arm_Robot_Task_Prgm.ino

Les fonctions plus générales telles que la commande read BT :void checkBTcmd() ; générateur de sons :void bip (int pin, int freq, long ms) et anti-rebond :debounce booléen (pin int) ; sont dans le fichier :General_Functions.ino

Un fait important :comme l'Arduino exécute des instructions basées sur une horloge de 16Mhz, on s'attend à ce que les boutons de contrôle soient lus des centaines voire des milliers de fois par seconde, il est donc important de faire un bouton "anti-rebond" qui définit le pas d'enregistrement .

Le quatrième et dernier fichier est :Arm_Ctrl_and_Display.ino

Dans ce fichier se trouvent les fonctions de lecture du potentiomètre :bool readPotenciometers() ; lecture des curseurs Android :bool readSliders() ; placement des servos :void armPosition (int gripp, int basee, int épaule, coude int) . Les autres fonctions incluses dans le fichier concernent l'affichage des données sur l'écran LCD, le moniteur série, les alarmes, etc.

La vidéo montre le bras robotique 4DOF "meArm" programmé à distance via l'application Android .

Le code source complet du projet se trouve sur GITHUB :

https://github.com/Mjrovai/MJRoBot-Programmed-Arm

ou ici :

Étape 7 : Conclusion

Comme toujours, j'espère que ce projet pourra aider d'autres personnes à trouver leur chemin dans le monde passionnant de l'électronique, de la robotique et de l'IoT ! Pour plus de projets, veuillez visiter mon blog :MJRoBot.org

Salutations du sud du monde ! Rendez-vous à mon prochain tutoriel !

Merci

Marcelo

Code

• Extrait de code n° 1
• Extrait de code 2
• Extrait de code 3

Extrait de code #1Arduino

// MeArm 4-DOF#define minGrip 15 #define minBase 0 #define minShou 60 #define minElbw 60 #define maxGrip 45 #define maxBase 170#define maxShou 180 #define maxElbw 150 #define midGrip 30#define midBase 87# define midShou 138#define midElbw 100/* SS 3-DOF#define minGrip 75 #define minBase 5 #define minShou 5 #define minElbw 0 #define maxGrip 125 #define maxBase 150#define maxShou 155 #define maxElbw 0 #define midGrip 100# define midBase 90#define midShou 90#define midElbw 0 */

Extrait de code #2Arduino

int gripPosition[100];int basePosition[100];int shouPosition[100];int elbwPosition[100];int positionIndex =0; // Index à utiliser au tableau de position utilisé pour les tâches enregistrées

Extrait de code n°3Arduino

boucle vide (){ checkBTcmd (); defineLocalRemote (); execTaskCmd =digitalRead (execTaskPin); if (execTaskCmd ==|| commande HIGH =="runon") { RunProgram (); } else recArmPosition (); commande ="";}

Github

Schémas

Bras Robot