Contrôle du bras robotisé à l'aide du microcontrôleur pic

De la chaîne de montage des industries de fabrication automobile aux robots de téléchirurgie dans l'espace, les bras robotiques se trouvent partout. Les mécanismes de ces robots sont similaires à ceux d'un humain qui peut être programmé pour une fonction similaire et des capacités accrues. Ils peuvent être utilisés pour effectuer des actions répétées plus rapidement et avec précision que les humains ou peuvent être utilisés dans des environnements difficiles sans risquer la vie humaine. Nous avons déjà construit un bras robotique d'enregistrement et de lecture utilisant Arduino qui pourrait être entraîné à effectuer une tâche particulière et répété pour toujours.

Dans ce tutoriel, nous utiliserons le microcontrôleur 8 bits PIC16F877A standard de l'industrie pour contrôler le même bras robotique avec des potentiomètres. Le défi avec ce projet est que PIC16F877A n'a que deux broches compatibles PWN, mais nous devons contrôler environ 5 servomoteurs pour notre robot qui nécessite 5 broches PWM individuelles. Nous devons donc utiliser les broches GPIO et générer des signaux PWM sur les broches PIC GPIO en utilisant les interruptions de la minuterie. Maintenant, bien sûr, nous pourrions passer à un meilleur microcontrôleur ou utiliser un IC de démultiplexeur pour rendre les choses beaucoup plus faciles ici. Mais encore, cela vaut la peine d'essayer ce projet pour l'expérience d'apprentissage.

La structure mécanique du bras robotique que j'utilise dans ce projet a été entièrement imprimée en 3D pour mon projet précédent; vous pouvez trouver les fichiers de conception complets et la procédure d'assemblage ici. Sinon, si vous n'avez pas d'imprimante 3D, vous pouvez également construire un bras robotique simple en utilisant des cartons comme indiqué dans le lien. En supposant que vous ayez en quelque sorte mis la main sur votre bras robotique, passons au projet.

Schéma

Le schéma de circuit complet de ce bras robotique basé sur un microcontrôleur PIC est illustré ci-dessous. Les schémas ont été dessinés à l'aide d'EasyEDA.

Le schéma de circuit est assez simple; le projet complet est alimenté par l'adaptateur 12V. Ce 12V est ensuite converti en + 5V à l'aide de deux régulateurs de tension 7805. L'un est étiqueté + 5V et l'autre est étiqueté + 5V (2). La raison d'avoir deux régulateurs est que lorsque le servo tourne, il tire beaucoup de courant, ce qui crée une chute de tension. Cette chute de tension force le PIC à redémarrer lui-même, nous ne pouvons donc pas faire fonctionner à la fois le PIC et les servomoteurs sur le même rail + 5V. Ainsi, celui étiqueté + 5V est utilisé pour alimenter le microcontrôleur PIC, l'écran LCD et les potentiomètres et une sortie de régulateur séparée étiquetée + 5V (2) est utilisée pour alimenter les servomoteurs.

Les cinq broches de sortie des potentiomètres qui fournissent une tension variable de 0V à 5V sont connectées aux broches analogiques An0 à AN4 du PIC. Comme nous prévoyons d'utiliser des minuteries pour générer des PWM, les servomoteurs peuvent être connectés à n'importe quelle broche GPIO. J'ai sélectionné des broches de RD2 à RD6 pour les servomoteurs, mais cela peut être n'importe quel GPIO de votre choix.

Puisque le programme implique beaucoup de débogage, un écran LCD 16x2 est également interfacé avec le portB du PIC. Cela affichera le cycle de service des servomoteurs qui sont contrôlés. En dehors de cela, j'ai également étendu les connexions pour toutes les broches GPIO et analogiques, juste au cas où des capteurs devraient être interfacés à l'avenir. Enfin, j'ai également connecté la broche du programmeur H1 pour programmer directement le PIC avec pickit3 en utilisant l'option de programmation ICSP.

Génération de signaux PWM sur la broche GPIO pour la commande de servomoteur

Une fois que le circuit est prêt, nous devons déterminer comment générer des signaux PWN sur la broche GPIO du PIC pour contrôler le servomoteur. Nous avons déjà fatigué quelque chose de similaire en utilisant la méthode d'interruption du minuteur et avons réussi. Ici, nous allons juste construire dessus, donc si vous êtes nouveau ici, je vous recommande fortement de lire ce tutoriel précédent avant de continuer.

Tous les servomoteurs de loisir fonctionnent avec une fréquence de 50 Hz. Ce qui signifie qu'un cycle d'impulsions complet pour un servomoteur sera de 1/50 (F = 1 / T), soit 20 ms. Sur ces 20 ms complets, le signal de commande n'est que de 0 à 2 ms tandis que le reste du signal est toujours désactivé. La figure ci-dessous montre comment le temps de marche ne varie que de 0 à 2 ms pour faire tourner le moteur de 0 degré à 180 degrés de la durée totale de 20 ms.

Dans cet esprit, nous devons écrire le programme de telle manière que le PIC lit de 0 à 1204 à partir du potentiomètre et le mappe à 0 à 100, ce qui sera le cycle de service du servomoteur. En utilisant ce cycle de service, nous pouvons calculer le temps de marche du servomoteur. Ensuite, nous pouvons initialiser l'interruption de la minuterie pour qu'elle déborde à un intervalle régulier de sorte qu'elle agisse de manière similaire à la fonction millis () dans Arduino. Avec cela, nous pouvons faire basculer le statut de la broche GPIO sur haut pendant une durée souhaitée et l'éteindre après 20 ms (un cycle complet), puis répéter le même processus. Maintenant que nous avons compris la logique, entrons dans le programme.

Programmation PIC16F8771A pour bras robotique

Comme toujours, le programme complet avec une vidéo se trouve à la fin de cette page, le code peut également être téléchargé à partir d'ici avec tous les fichiers nécessaires. Dans cette section, nous discuterons de la logique derrière le programme. Le programme utilise le module ADC, le module de minuterie et le module LCD pour contrôler le bras robotique. Si vous ne savez pas comment utiliser les fonctionnalités ADC ou Timer ou comment interfacer un LCD avec PIC, vous pouvez revenir aux liens respectifs pour les apprendre. L'explication ci-dessous est donnée en supposant que le lecteur est familier avec ces concepts.

Configuration du port du minuteur 0

La section la plus importante du code est de régler la minuterie 0 sur un débordement pour chaque retard spécifique. Les formules pour calculer ce retard peuvent être données comme

Délai = ((256-REG_val) * (Prescal * 4)) / Fosc

En utilisant les registres OPTION_REG et TMR0, nous avons réglé la minuterie 0 pour qu'elle fonctionne avec une valeur préscalaire de 32 et la valeur REG est réglée sur 248. La fréquence du cristal (Fosc) utilisée dans notre matériel est de 20 MHz. Avec ces valeurs, le retard peut être calculé comme

Délai = ((256-248) * (32 * 4)) / (20000000) = 0,0000512 seconde (ou) = 0,05 msec

Alors maintenant, nous avons réglé la minuterie pour déborder toutes les 0,05 ms. Le code pour faire de même est donné ci-dessous

/ ***** Configuration du port pour la minuterie ****** / OPTION_REG = 0b00000100; // Timer0 avec freq externe et 32 comme prescalaire // Active également PULL UP TMR0 = 248; // Charge la valeur de temps pour 0,0001s; delayValue peut être compris entre 0 et 256 uniquement TMR0IE = 1; // Activer le bit d'interruption du temporisateur dans le registre PIE1 GIE = 1; // Activer l'interruption globale PEIE = 1; // Activer l'interruption périphérique / *********** ______ *********** /

Sur la fenêtre de contrôle totale de 0 ms à 2 ms du servomoteur, nous pouvons le contrôler avec une résolution de 0,05 ms, ce qui nous permet d'avoir (2 / 0,05) 40 positions différentes pour le moteur entre 0 et 180 degrés. Vous pouvez diminuer cette valeur davantage si votre MCU pouvait la prendre en charge pour obtenir plus de positions et un contrôle précis.

Routine de service d'interruption (ISR)

Maintenant que la minuterie 0 est réglée sur un dépassement de débit toutes les 0,05 ms, nous aurons le drapeau d'interruption TMR0IF réglé sur 0,05 ms. Donc, dans la fonction ISR, nous pouvons réinitialiser le drapeau et incrémenter une variable appelée nombre par un. Alors maintenant, cette variable sera incrémentée de 1 toutes les 0,05 ms.

Calcul du cycle de service et de l'heure

Ensuite, nous devons calculer le cycle de service et l'heure pour les cinq servomoteurs. Nous avons cinq servomoteurs dont chacun est utilisé pour contrôler la section individuelle du bras. Nous devons donc lire la valeur ADC de tous les cinq et calculer le cycle de service et le temps pour chacun.

La valeur ADC sera comprise entre 0 et 1024, ce qui peut être converti en un cycle de service de 0% à 100% en multipliant simplement 0,0976 (100/1024 = 0,0976) par la valeur obtenue. Ce rapport cyclique de 0 à 100% doit ensuite être converti en temps ON. Nous savons qu'à 100% du cycle de service, le temps de marche doit être de 2 ms (pour 180 degrés), donc multiplier 0,02 (2/100 = 0,02) convertira le cycle de service de 0 à 100 en 0 à 2 ms. Mais alors, notre nombre de variables de minuterie est configuré pour augmenter une fois toutes les 0,05 ms. Cela signifie que la valeur de count sera de 20 (1 / 0,05 = 20) toutes les 1 ms. Nous devons donc multiplier 20 par 0,02 pour calculer le temps exact de notre programme qui nous donnera la valeur 0,4 (0,02 * 20 = 0,4). Le code pour le même est montré ci-dessous, vous pouvez le voir répété 5 fois pour les 5 pot en utilisant une boucle for. Les valeurs résultantes sont stockées dans le tableau T_ON.

pour (int pot_num = 0; pot_num <= 3; pot_num ++) { int Pev_val = T_ON; POT_val = (ADC_Read (pot_num)); // Lire la valeur de POT en utilisant ADC Duty_cycle = (POT_val * 0.0976); // Mappe 0 à 1024 à 0 à 100 T_ON = Duty_cycle * 0.4; // 20 * 0.02

Sélection du moteur à faire tourner

Nous ne pouvons pas contrôler les cinq moteurs ensemble car cela rendra le code ISR lourd ralentissant l'ensemble du microcontrôleur. Nous devons donc faire tourner un seul servomoteur à la fois. Pour sélectionner le servo à faire tourner, le microcontrôleur surveille le temps de marche des cinq servomoteurs et le compare avec son temps de marche précédent. S'il y a un changement dans le temps ON, nous pouvons conclure que le servo particulier doit être déplacé. Le code correspondant est indiqué ci-dessous.

if (T_ON! = Pev_val) { Lcd_Clear (); servo = pot_num; Lcd_Set_Cursor (2,11); Lcd_Print_String ("S:"); Lcd_Print_Char (servo + '0'); if (pot_num == 0) {Lcd_Set_Cursor (1,1); Lcd_Print_String ("A:");} else if (pot_num == 1) {Lcd_Set_Cursor (1,6); Lcd_Print_String ("B:");} else if (pot_num == 2) {Lcd_Set_Cursor (1,11); Lcd_Print_String ("C:");} else if (pot_num == 3) {Lcd_Set_Cursor (2,1); Lcd_Print_String ("D:");} else if (pot_num == 4) {Lcd_Set_Cursor (2,6); Lcd_Print_String ("E:");} char d2 = (Duty_cycle)% 10; char d1 = (cycle_travail / 10)% 10; Lcd_Print_Char (d1 + '0'); Lcd_Print_Char (d2 + '0');

Nous imprimons également le cycle de service du servo sur l'écran LCD afin que l'utilisateur puisse être conscient de sa position actuelle. En fonction du changement de temps de marche, le servo variable est mis à jour avec des nombres de 0 à 4 représentant chacun des moteurs individuels.

Contrôle du servomoteur à l'intérieur de l'ISR

À l'intérieur de l'ISR, le nombre de variables est incrémenté toutes les 0,05 ms, ce qui signifie que toutes les 1 ms, la variable sera incrémentée de 20. En utilisant cela, nous devons contrôler les broches pour produire un signal PWM. Si la valeur de compte est inférieure au temps de marche, le GPIO de ce moteur est activé en utilisant la ligne ci-dessous

PORTD = PORTD - servo_code;

Ici, le tableau servo_code a le détail des broches des cinq servomoteurs et en fonction de la valeur du servo variable, le code de ce servomoteur particulier sera utilisé. C'est alors logiquement OU (-) avec les bits PORTD existants pour ne pas perturber les valeurs des autres moteurs et mettre à jour uniquement ce moteur particulier. De même pour désactiver la broche

PORTD = PORTD & ~ (servo_code);

Nous avons inversé la valeur du bit à l'aide de l'opérateur logique inverse (~), puis avons effectué une opération ET (&) sur le PORTD pour désactiver uniquement la broche souhaitée tout en laissant les autres broches dans leur état précédent. L'extrait de code complet est présenté ci-dessous.

void interruption timer_isr () { if (TMR0IF == 1) // L'indicateur de minuterie a été déclenché en raison d'un dépassement de la minuterie -> réglé sur un débordement toutes les 0,05 ms { TMR0 = 248; // Charge le minuteur Valeur TMR0IF = 0; // Effacer le nombre d' indicateurs d'interruption du minuteur ++; // Compter les incréments de 1 pour chaque 0,05 ms -> le compte sera de 20 pour chaque 1 ms (0,05 / 1 = 20)) } int servo_code = {0b01000000, 0b00100000, 0b00010000, 0b00001000, 0b00000100}; if (count> = 20 * 20) count = 0; if (count <= (T_ON)) PORTD = PORTD - servo_code; else PORTD = PORTD & ~ (servo_code); }

Nous savons que le cycle total doit durer 20 ms avant que la broche GPIO ne soit à nouveau activée. Nous vérifions donc si le compte a dépassé 20 ms en comparant la valeur du compte à 400 (même calcul que celui décrit ci-dessus) et si oui, nous devons réinitialiser le compte pour qu'il soit à nouveau nul.

Simulation du code du bras robotique PIC

Il est toujours préférable de simuler le code avant de l'appliquer au matériel réel. J'ai donc utilisé Proteus pour simuler mon code et vérifier qu'il fonctionnait correctement. Le circuit utilisé pour la simulation est illustré ci-dessous, nous avons utilisé un oscilloscope pour vérifier si les signaux PWM sont générés comme requis. Nous pouvons également vérifier si l'écran LCD et les servomoteurs tournent comme prévu.

Comme vous pouvez le voir les écrans LCD le cycle de fonctionnement du moteur D à être 07 en fonction de la valeur du pot qui est le 3 ^ème moteur. Similaire si un autre pot est déplacé, le cycle de service de ce pot et son numéro de moteur seront affichés sur l'écran LCD. Le signal PWM affiché sur l'oscilloscope est illustré ci-dessous.

La période totale du cycle est mesurée à 22,2 ms à l'aide de l'option curseur sur l'oscilloscope, qui est très proche des 20 ms souhaitées. Enfin, nous sommes sûrs que le code fonctionne, donc pour continuer avec le circuit, nous pouvons soit le souder sur une carte de performance, soit utiliser un PCB. Cela ne fonctionnera pas facilement sur la maquette car le POT a toujours tendance à poser des problèmes en raison de mauvaises connexions.

Conception de circuits imprimés avec EasyEDA

Pour concevoir ce bras robotique PIC, nous avons choisi l'outil EDA en ligne appelé EasyEDA. Je l'utilise depuis longtemps maintenant et je le trouve très pratique en raison de sa grande disponibilité en encombrement et de sa nature facile à utiliser. Après avoir conçu le PCB, nous pouvons commander les échantillons de PCB par leurs services de fabrication de PCB à faible coût. Ils offrent également un service d'approvisionnement en composants où ils ont un grand stock de composants électroniques et les utilisateurs peuvent commander les composants nécessaires avec la commande de PCB.

Lors de la conception de vos circuits et PCB, vous pouvez également rendre publics vos conceptions de circuits et de PCB afin que d'autres utilisateurs puissent les copier ou les modifier et profiter de votre travail, nous avons également rendu public l'ensemble de nos schémas de circuits et de PCB pour ce circuit, vérifiez le lien ci-dessous:

easyeda.com/circuitdigest/pic-development-board-for-robotic-arm

En utilisant ce lien, vous pouvez commander directement le même PCB que nous utilisons dans ce projet et l'utiliser. Une fois la conception terminée, la carte peut être considérée comme un modèle 3D, ce qui sera très utile pour visualiser l'apparence de la carte après la fabrication. Le modèle 3D de la carte que nous utilisons est illustré ci-dessous. En dehors de cela, vous pouvez également afficher la couche supérieure et inférieure de la carte pour vérifier si l'écran lisse est comme prévu.

Calcul et commande d'échantillons en ligne

Après avoir terminé la conception de ce PCB Robot PIC, vous pouvez commander le PCB via JLCPCB.com. Pour commander le PCB auprès de JLCPCB, vous avez besoin du fichier Gerber. Pour télécharger les fichiers Gerber de votre PCB, cliquez simplement sur le bouton Générer un fichier de fabrication sur la page de l'éditeur EasyEDA, puis téléchargez le fichier Gerber à partir de là ou vous pouvez cliquer sur Commander à JLCPCB comme indiqué dans l'image ci-dessous. Cela vous redirigera vers JLCPCB.com, où vous pourrez sélectionner le nombre de PCB que vous souhaitez commander, le nombre de couches de cuivre dont vous avez besoin, l'épaisseur du PCB, le poids du cuivre et même la couleur du PCB, comme l'image ci-dessous:

Après avoir sélectionné toutes les options, cliquez sur «Enregistrer dans le panier» et vous serez redirigé vers la page où vous pouvez télécharger votre fichier Gerber que nous avons téléchargé depuis EasyEDA. Téléchargez votre fichier Gerber et cliquez sur «Enregistrer dans le panier». Et enfin, cliquez sur Commander en toute sécurité pour terminer votre commande, puis vous recevrez vos PCB quelques jours plus tard. Ils fabriquent le PCB à un taux très bas qui est de 2 $. Leur temps de construction est également très inférieur, soit 48 heures avec une livraison DHL de 3 à 5 jours.En gros, vous obtiendrez vos circuits imprimés dans la semaine suivant la commande.

Après avoir commandé le PCB, vous pouvez vérifier la progression de la production de votre PCB avec la date et l'heure. Vous le vérifiez en allant sur la page Compte et en cliquant sur "Progression de la production".

Après quelques jours de commande de PCB, j'ai reçu les échantillons de PCB dans un bel emballage comme le montrent les images ci-dessous.

Et après avoir obtenu ces pièces, j'ai soudé tous les composants requis sur le PCB. J'ai également soudé directement le POT au lieu d'utiliser des fils de connexion, car les fils femelle à femelle que j'ai initialement utilisés donnaient des tensions de sortie analogiques étranges probablement à cause de contacts desserrés. Une fois tous les composants assemblés, mon PCB ressemblait à quelque chose comme ça.

Vous avez peut-être remarqué qu'il n'y a qu'un seul 7805 sur cette carte. C'est parce qu'au départ, je pensais que je pourrais m'en tirer avec juste un régulateur pour alimenter à la fois le PIC et le servomoteur et plus tard, j'ai réalisé que j'avais besoin de deux. J'ai donc utilisé un circuit externe pour alimenter les servomoteurs à travers les fils verts que vous voyez ici.

Néanmoins, vous n'avez pas à vous en inquiéter car; J'ai apporté les modifications au PCB maintenant. Vous pouvez utiliser le PCB modifié et souder les deux régulateurs à bord lui-même.

Fonctionnement du bras robotique PIC

Après tout ce travail fatigant, il est temps de payer. Soudez tous les composants de la carte et téléchargez le programme sur le contrôleur PIC. Le code complet est donné ci-dessous ou peut être téléchargé à partir d'ici. Le connecteur de programmation fourni sur la carte devrait vous aider à télécharger le programme directement à l'aide de Pickit 3 sans trop de tracas. Une fois le programme téléchargé, vous devriez voir l'écran LCD afficher le servo qui est actuellement contrôlé. Pour en savoir plus sur la programmation du microcontrôleur PIC, suivez simplement le tutoriel précédent.

De là, vous pouvez simplement tourner le pot et vérifier comment les servomoteurs répondent à chaque potentiomètre. Une fois que vous avez compris le format, vous pouvez contrôler le bras robotique pour effectuer toute action dont vous avez besoin pour effectuer et vous amuser. Vous pouvez trouver le fonctionnement complet du projet dans la vidéo ci-dessous.

Voilà les gars espèrent que vous avez compris le projet et en avez appris quelque chose de nouveau. Si vous avez des questions, laissez-les dans la section des commentaires ou utilisez les forums pour d'autres discussions techniques.