Trois robots de grande taille à construire et à programmer : Troisième robot "Spider" (Première partie)

Nous commençons cette fois la description du troisième et dernier de nos robots : Spider, l’araignée à 6 pattes ! Dans cette partie, nous décrirons pas à pas la mécanique et le montage du robot et nous vous renvoyons à la suivante pour la présentation complète du logiciel.


Dans cet article en deux parties, nous analysons le troisième robot : Spider. Dans cette première partie, nous nous pencherons sur la mécanique et son assemblage mais, comme nous l’avons déjà fait très en détail pour CarBot et Filippo et qu’en substance la méthode de montage mécanique de Spider est analogue, nous pourrons passer plus vite sur cette phase (les nombreuses photos de la figure 1 vont vous rendre les choses faciles). Dans la prochaine partie, nous étudierons les logiciels permettant à Spider de se déplacer et d’interagir avec son environnement.

Spider
Spider ressemble à une araignée… sauf qu’il a six pattes, ce qui ne se trouve jamais chez un membre de la famille des arachnides (rappelons qu’elle est un arthropode et non un insecte) : bref ce serait plutôt un scarabée ! En tout cas, grâce à ses pattes, il peut se déplacer en avant, en arrière et tourner sur lui-même. Le mouvement en avant est obtenu en abaissant la patte centrale gauche, de façon à lever les deux autres pattes du même côté. Ainsi, le robot s’appuie seulement sur trois pattes (la centrale gauche et les deux droites) : les deux pattes gauches soulevées sont alors portées en avant. Ensuite, la patte centrale gauche est relevée et celle de droite est abaissée.
Ainsi, les pattes relevées sont les deux de droite : ensuite, elles se portent en avant. Si les phases décrites sont exécutées continuellement et cycliquement, il est possible de produire la marche en avant. Si, en revanche, on veut obtenir la marche en arrière, une fois relevées les pattes latérales, il suffit de les porter en arrière au lieu d’en avant.

Le fonctionnement
Tout comme pour les deux autres robots, on utilise pour Spider des servomoteurs : par contre, à la différence de Car-Bot et de Filippo, Spider en a besoin de trois : un pour lever/baisser les pattes centrales et deux pour les mouvements des pattes latérales, respectivement pour celles de droite et de gauche. Le modèle utilisé est toujours le Futuba S3003.
Vous vous souvenez que pour CarBot ces moteurs avaient dû être légèrement modifiés (mécaniquement et électroniquement), de façon à permettre aux axes et aux roues de tourner sur 360°. Eh bien pour Spider, comme pour Filippo, aucune modification de ce type n’est nécessaire : en effet, les moteurs n’ont pas à faire une rotation complète. Les trois moteurs sont alimentés par une tension entre 4,8 et 6 V et le positionnement des axes est commandé par des trains d’impulsions dont la durée implique le sens du mouvement.
Pendant la marche avant, la reconnaissance des obstacles se fait par les “antennes” (gauche et droite) reliées à des micro-interrupteurs, lesquels, bien sûr, sont connectés au microcontrôleur de la carte-mère, ce qui permet au logiciel de gestion de détecter les obstacles situés sur la trajectoire du robot.

L’assemblage
Comme pour les autres robots, la structure mécanique de Spider a été réalisée en plaque de fibre de verre recouverte sur les deux faces d’un film de cuivre, le tout protégé par de la peinture cuite au four. Cette structure est constituée de divers éléments devant être assemblés : ici aussi, après emboîtement, on a le choix entre la fixation par collage (colle au cyanoacrylate) ou par soudure au tinol et, là encore, nous vous conseillons la seconde méthode, plus rapide et plus simple. Utilisez un fer de 40 W au moins à panne large, un tournevis cruciforme N1, une pince universelle, une petite pince droite à bec fin et une recourbée, du tinol 60/40 de bonne qualité et des élastiques de maintien.
Occupons-nous maintenant des jointures du robot, devant permettre une certaine mobilité. Comme pour Filippo, pour relier la structure de base aux parties mobiles, on utilise une vis, deux rondelles (une de chaque côté) et un écrou autobloquant (que les mécaniciens appellent “nylstop”). On trouve de telles jointures entre la structure et les pattes. Pour permettre le mouvement, il est important de serrer ces boulons de jointure à la juste pression, mais pas trop. En effet, les jointures doivent pouvoir bouger librement sans forcer, mais sans qu’il y ait toutefois un jeu excessif. Nous vous conseillons de visser chaque écrou à fond, puis de le dévisser d’environ 1/4 de tour. En outre, toujours à propos des pièces en mouvement, afin de diminuer les frottements, nous vous conseillons de mettre une goutte d’huile fine (dite de machine et en effet on l’utilise pour graisser les machines à coudre) à chaque jointure. Vous pouvez utiliser une petite seringue et, quand la goutte est mise, éliminer l’excédant avec un chiffon ou un papier absorbant.
Dernier point concernant l’assemblage des divers éléments composant la structure de base. Pour cet assemblage, aucune ferrure n’est prévue : il se fait par encastrement des divers tenons dans des fentes puis par soudure dans les angles au tinol en suivant l’ordre des 60 photos de la figure 1. Si l’encastrement vous oppose une certaine résistance, n’hésitez pas à vous aider d’un marteau et d’une cale en bois ou d’un maillet (sans déformer les plaques toutefois par excès de violence !). Nous vous conseillons en outre de ne pas frapper sur un point particulier, mais de répartir l’effort (d’où la cale de bois…) afin que les tenons entrent dans leurs fentes tous ensemble et progressivement. Avant de commencer les soudures, immobilisez bien la structure avec les élastiques, vous ferez ainsi un travail bien plus facile et plus précis.

Figure 1 : Le montage mécanique complet de Spider tout en images.
Le procédé est identique à celui de CarBot et Filippo : encastrements et soudures au tinol.
- De 1 à 20 : De la structure porteuse et des entretoises au porte-batterie et aux moteurs dans la base.
- De 21 à 40 : Du support pour les pattes centrales et du montage des pattes latérales à l’assemblage des tirants des pattes latérales.
- De 40 à 60 : De l’assemblage des pattes centrales et des micro-interrupteurs dans la base aux ultimes finitions et à l’installation de la carte-mère.
































La partie électronique
Quand le robot est assemblé, passons à l’électronique.
Nous vous rappelons qu’elle est commune aux trois robots et qu’elle se compose principalement d’une carte-mère où prend place un microcontrôleur PIC16F876 aux broches de I/O duquel sont reliés les différents dispositifs : les deux servomoteurs, le buzzer, le circuit intégré MAX232 et les deux micro-interrupteurs des “antennes”. Nous vous rappelons en outre que la carte-mère est conçue dotée de deux connecteurs d’extension : le premier, constitué de 20 broches conduisant vers l’extérieur 19 ports de I/O du microcontrôleur plus la masse, le second, en revanche, met à disposition 8 broches (3 masses GND, 3 +5 V et 2 alimentations directes batterie). Ces deux connecteurs ont été positionnés de façon à pouvoir superposer à la carte-mère une platine supplémentaire sur laquelle on peut installer d’autres composants ou circuits (par exemple, des détecteurs supplémentaires, une mini caméra vidéo, des afficheurs LCD, etc.). Pour plus de détails concernant l’extension éventuelle de la carte-mère, nous vous renvoyons au premier article de cette rubrique ROBOTIQUE, dans lequel nous présentions la carte-mère et les schémas électriques.

Le logiciel
Puisque nous en avons terminé avec la présentation mécanique de Spider, considérons un aspect du logiciel de gestion du robot. Comme pour CarBot et Filippo, c’est dans la seconde partie de l’article que nous donnerons la présentation complète du logiciel de Spider. Ici, nous voudrions vous montrer un “listing” écrit en Basic et que vous pouvez utiliser comme base à partir de laquelle écrire vos programmes.
Ce “listing” a simplement trait aux déclarations de certaines définitions de caractère général, du sens des ports de I/O, des liaisons des dispositifs externes aux ports du microcontrôleur, des variables et des constantes. En particulier, il est défini que le “bootloader” est mémorisé dans le microcontrôleur, qu’on utilise une horloge à 20 MHz, que les broches de I/O du port A sont paramétrées comme numériques et que les “pull up” du port B sont paramétrés comme ON. Ensuite, sont définis les différents sens des broches composant les ports A, B et C.
Nous vous rappelons qu’un 0 indique une broche paramétrée comme “OUTPUT”, un 1 comme “INPUT”. Dans la partie commentaire, le poids de chaque bit est en outre montré : le plus significatif indique la broche numéro 7 des ports (par exemple, la broche RB7 et RC7), alors que le moins significatif indique la broche 0 des ports (par exemple, la broche RA0, RB0 et RC0).
Dans l’exemple sont spécifiés comme “INPUT” les ports RA4, RA5 et RC2, alors que tous les autres ports sont paramétrés comme “OUTPUT”. Ensuite, sont exécutées les “liaisons” entre les ports de I/O utilisés et les variables qui les gèrent : par exemple, le port RB2 est relié à la variable Servo1 (indiquant la position du servomoteur 1), le port RB1 à la variable Servo2, le port RA4 à l’antenne_1, le port RA1 au “speaker”, etc. Si vous étendez la carte-mère avec de nouveaux dispositifs externes, vous devez définir au cours de cette phase les liaisons réalisées.
Ensuite, se trouve un espace où déclarer certaines variables ou constantes que vous utiliserez à l’intérieur du programme.
En outre, la syntaxe de la déclaration est montrée, que ce soit pour les variables particulières ou pour les “arrays”. Puis sont mises à zéro toutes les broches des trois ports et on entre alors dans la partie principale du programme.
La déclaration d’éventuelles subroutines est en revanche à faire à la fin du “listing”. Nous vous rappelons que chaque subroutine doit commencer par une étiquette (Sub1 : ou Sub2 : dans nos exemples) et terminer par l’instruction Return, produisant le retour au point d’appel de la subroutine.
Quand la déclaration de toutes les procédures est terminée, l’instruction End est présente et elle indique au compilateur la fin du programme.

Figure 2 : Listing.

‘*********************************************************************************
‘* Nom : Listing des paramétrages de base. *
‘* Process. : PIC16F876 *
‘*********************************************************************************

‘-----[ Définitions ]------------------------------------------------------------
DEFINE LOADER_USED 1 ‘Utilisé pour boot-loader
DEFINE OSC 20 ‘Paramétrer Clock à 20MHz
ADCON1 = 000111 ‘Port A = Digitale
OPTION_REG.7=0 ‘Paramétrer à ON les pullups du Port B

‘----[ Vers Port ]----------------------------------------------------------------
‘Syntaxe > 0=Output; 1=Input
‘Poids du bit > 76543210
TRISA = 110000 ‘Paramétrer broche Port A en Input et/ou Output
TRISB = 000000 ‘Paramétrer broche Port B en Input et/ou Output
TRISC = 000100 ‘Paramétrer broche Port C en Input et/ou Output

‘-----[ Définitions I/O ]--------------------------------------------------------
Servo1 VAR PORTB.2 > ‘Port Servo 1
Servo2 VAR PORTB.1 > ‘Port Servo 2
Servo3 VAR PORTB.0 > ‘Port Servo 3
Antenne_1 VAR PORTA.4 > ‘Port Antenne 1
Antenne_2 VAR PORTA.5 > ‘Port Antenne 2
Speaker VAR PORTA.1 > ‘Port Speaker
LED_1 VAR PORTC.3 > ‘Port LED 1
LED_2 VAR PORTC.4 > ‘Port LED 2

IR_1 VAR PORTC.1 > ‘Port LED Emetteur Infrarouge 1

IR_2 VAR PORTC.0 > ‘Port LED Emetteur Infrarouge 2

IFR_1 VAR PORTC.5 > ‘Port Récepteur Infrarouge

‘-----[ Définitions Variables ]--------------------------------------------------
‘Syntaxe > Variables Label VAR Size{.Modifiers}
‘Syntaxe > Arrays Label VAR Size[Number of elements]

‘-----[ Définitions Constantes ]-------------------------------------------------
‘Syntaxe > Label CON Constant expression

‘-----[ Initialisation ]----------------------------------------------------------
PORTA =0 ‘Mise à zéro des trois
ports de I/O
PORTB =0
PORTC =0

‘-----[ Début programme ]---------------------------------------------------------
Début :
‘Instructions faisant partie de la main program.

‘-----[ Subroutine ]--------------------------------------------------------------
Sub1:
‘Instructions faisant partie de la subroutine Sub1
Return ‘Fin de la subroutine Sub1
Sub2:
‘Instructions faisant partie de la subroutine Sub2
Return ‘Fin de la subroutine Sub2

End ‘Fin du programme

A suivre...

Trois robots de grande taille à construire et à programmer
Premier robot "CarBot" (Première partie)
Premier robot "CarBot" (Deuxième partie)
Deuxième robot "Filippo" (Première partie)
Deuxième robot "Filippo" (Deuxième partie)
Troisième robot "Spider" (Deuxième partie)

0 commentaires:

Enregistrer un commentaire

Related Posts Plugin for WordPress, Blogger...