Trois robots de grande taille à construire et à programmer : Premier robot "CarBot" (Deuxième partie)

Nous terminons la description du plus simple des trois robots : le CarBot.
Dans cette partie, nous nous occuperons de la programmation logicielle du PIC16F876 en Basic.


Dans la première partie de cette série d’articles de robotique consacrée aux trois robots, nous vous avons présenté la platine commune de contrôle (ou carte-mère) utilisée pour contrôler CarBot, Filippo et Spider : dans la deuxième, nous avons analysé en détails CarBot en nous occupant du montage mécanique. Nous avons aussi développé le concept de “bootloader” : ce système de programmation est utilisé pour transférer nos programmes (écrits en C, Basic, Assembleur, …) directement du PC vers la carte mère du robot.
Dans cette partie CarBot 2, soit la troisième de la chronique Robotique, nous nous concentrerons en revanche sur le logiciel de gestion de la carte-mère montée sur CarBot, nous analyserons quelques-uns des programmes simples capables de donner vie (!) au robot : nous verrons comment lire les valeurs des “Inputs” en entrée et, par l’intermédiaire des bons “Outputs”, commander les dispositifs externes afin de permettre à CarBot d’interagir avec son environnement et de répondre aux impulsions lui arrivant de l’extérieur.
C’est dans ce but que nous utilisons des programmes en Basic. Le choix s’est porté sur ce langage car, nous semble-t-il, c’est celui qui s’adapte le mieux à la gestion d’un système comme CarBot. Le Basic, en effet, n’est pas un langage de programmation d’un niveau trop bas et par conséquent compliqué comme l’Assembleur, mais il n’est pas non plus trop abstrait et de haut niveau comme le C.
Avant de commencer l’analyse des “listings”, revenons un instant au matériel de la carte-mère et ne nous occupons que des parties utilisées par les programmes : le coeur du système est le microcontrôleur PIC16F876 doté de 3 ports (A, B et C) de I/O pour un total de 22 broches. Comme on le voit sur le schéma publié, les deux “antennes” ou “moustaches” de détection des obstacles ont été reliées aux bits 4 et 5 du port A, les deux servomoteurs aux bits 1 et 2 du port B, les deux LED constituant les yeux du robot aux bits 3 et 4 du port C, enfin le haut-parleur est relié au bit 1 du port A. Rappelons en outre la logique de fonctionnement de ces dispositifs : les antennes de détection (pourvues de micro-interrupteurs) sont actives sur le front bas, ce qui signifie qu’on aura un 0 logique en entrée lorsque CarBot rencontrera un obstacle. Les deux servomoteurs sont commandés par des trains d’impulsions de durée variable (plus loin, nous donnerons d’autres informations plus détaillées sur leur fonctionnement). Les deux LED fonctionnent au moyen d’une logique directe, elles sont par conséquent allumées quand, en sortie de la broche correspondante, se présente un 1 logique. Enfin le haut-parleur est actif lorsque la broche correspondante est au 1 logique, même si, comme nous le verrons, sa gestion est réalisée via logiciel par l’intermédiaire de la fonction “Sound” (son).

Figure 1 : Connexion des dispositifs externes.

Table de vérité





Logiciel 1 : test haut-parleur et antennes
Commençons par étudier le premier programme. Il s’agit d’un test simple, conçu pour vérifier le fonctionnement correct du haut-parleur et des antennes. A chaque pression des antennes, un son déterminé est émis et la LED (oeil) se trouvant du côté de l’antenne affectée s’éteint. Si les deux antennes sont pressées en même temps, après un bip les deux yeux s’éteignent puis se rallument.
Analysons l’organigramme : tout d’abord, au début du programme, les LED du robot s’allument et s’éteignent deux fois et un son est émis. Puis le programme exécute des contrôles de l’état des antennes : si l’antenne gauche est pressée, après l’émission du son, la LED gauche s’éteint, si l’antenne droite est pressée, c’est la LED droite qui s’éteint, enfin si les deux antennes sont pressées, les deux LED s’éteignent. Si aucune de ces conditions ne se vérifie, les LED et le buzzer restent inactifs.
Regardons maintenant le “listing” (figure 2). Après chacune des définitions (du “LOADER_USER” utilisée par le “bootloader”, du paramétrage de la fréquence d’horloge (“CLOCK”) du PIC et du paramétrage du port A, comme numérique) il est spécifié, si les bits des ports A et C sont des “Inputs” ou des “Outputs” (un 1 indique broche en “Input”, un 0 broche en “Output”). Ensuite on définit à quelles broches des ports sont reliés les LED et les microinterrupteurs.
On spécifie que l’antenne gauche Ant_1 est reliée au bit 4 du port A, que l’antenne droite Ant_2 est reliée au bit 5 de ce même port, le haut-parleur “Speaker” est relié au bit 1 de A et les LED 1 et 2 sont reliées aux bits 3 et 4 du port C. Puis, après avoir défini certaines variables utilisées dans le programme, les ports A et C se mettent à 0 et le programme commence. Par l’intermédiaire de l’instruction “GoSub Yeux” la subroutine pour le clignotement des LED est appelée. Là, grâce à un cycle “FOR” et à l’instruction “Toggle” (qui inverse la valeur des bits spécifiques), on commande l’allumage et l’extinction des LED. Puis la subroutine d’émission du son (“GoSub Son”) est appelée. Elle se base sur l’instruction Son dans laquelle est spécifiée la broche (haut-parleur dans ce cas) à laquelle envoyer le ton, la valeur de la fréquence et la durée de ce ton. Comme dans le cas que nous avons analysé, il est possible de spécifier plusieurs tons de durées différentes. On note ensuite l’utilisation de l’instruction “Low Speaker”, qui abaisse le niveau de la broche hautparleur, arrêtant ainsi l’émission du son.
C’est alors qu’est appelée la subroutine “Ants” dans laquelle on exécute le test de l’état des micro-interrupteurs.
On exécute dans cet ordre les tests : sur Ant_1 (micro-interrupteur gauche) d’abord, sur Ant_2 (micro-interrupteur droit) ensuite et sur les deux éventuellement on passe aux fonctions correspondantes de gestion. Considérons, par exemple, le cas où le micro-interrupteur de gauche (subroutine Gauche) se ferme : après avoir appelé la subroutine pour le son, le bit 3 du port C, auquel est reliée la LED_1, passe au 0 et la LED s’éteint. Dans le cas où c’est le micro-interrupteur de droite (géré par la subroutine Droite) qui se ferme, le fonctionnement est le même que pour la subroutine précédente : un seul changement, on utilisera la LED_2 au lieu de la LED_1. Enfin, dans le cas où les deux micro-interrupteurs sont fermés, les deux LED s’éteignent puis se rallument.
L’analyse du premier “listing” est terminée. Ce programme simple nous a permis de comprendre comment lire les états des entrées, vérifier que les micro-interrupteurs sont pressés et modifier en conséquence les sorties afin de commander le haut-parleur et les LED.

Figure 2 : Test haut-parleur et antenne.

ORGANIGRAMME



LISTING

‘*************************************************************************
‘* Nom : Test Motherboard *
‘* Proces.: PIC16F876 *
‘* Note : Pour tester le haut-parleur et les antennes. *
‘*************************************************************************

‘------[ Définitions ]-----------------------------------------
DEFINE LOADER_USED ‘Utilisé par boot-loader
DEFINE OSC 20 ‘paramètre Clock à 20MHz
ADCON1 = 000111 ‘Port A = Numérique

‘------[ Vers Port ]-----------------------------------------
TRISA = 110000 ‘paramètre broches 4,5 Port A en Input;
‘Output reste
TRISC = 100100 ‘Paramètre broches 2,5 Port C en Input;
‘Output reste

‘------[ Définitions I/O ]-----------------------------------------
Ant_1 VAR PORTA.4 ‘Port Ant 1
Ant_2 VAR PORTA.5 ‘Port Ant 2
Speaker VAR PORTA.1 ‘Port Speaker
Led_1 VAR PORTC.3 ‘Port LED 1
Led_2 VAR PORTC.4 ‘Port LED 2

‘------[ Définitions Variables ]-----------------------------------------
ncount VAR BYTE ‘loop pour les autres
Note VAR BYTE ‘note pour Sound

‘------[ Définitions Constantes ]-----------------------------------------
Durée CON 100 ‘Durée note pour Sound

‘------[ Initialisation ]-----------------------------------------
PORTA =0
PORTC =0

‘------[ Début programme ]-----------------------------------------
ncount = 0
Note = 0

Début :
GoSub Yeux ‘clignotement LED
Note = 500
GoSub Son ‘emet son initial
GoSub Ants ‘test si contact sur antennes
GoTo Début ‘répétition du cycle

‘------[ Subroutine ]-----------------------------------------

Ants :
IF Ant_1 = 0 Then Gauche ‘contact sur antenne 1
IF Ant_2 = 0 Then Droite ‘contact sur antenne 2
IF Ant_1 AND Ant_2 = 0
Then Inverse ‘contact sur les deux antennes
Return

Son :
‘émission note
Sound Speaker, [Note, Durée, Note, Durée]
Low Speaker ‘mise à zéro speaker
Return

Yeux :
LED_1 = 0 ‘éteint deux LED
LED_2 = 0
For ncount=0 to 4 ‘clignotement des LED
Toggle LED_1
Toggle LED_2
Pause 100
Next
Return

Gauche :
Note = 10
GoSub Son ‘émet son gauche
LED_1 = 0 ‘éteint LED gauche
Return

Droite :
Note = 100
GoSub Son ‘émet son droit
LED_2 = 0 ‘éteint LED gauche
Return

Inverse :
Note = 50
GoSub Son ‘émet sons droit et gauche
LED_1 = 0 ‘éteint les deux LED
LED_2 = 0
LED_1 = 1 ‘allume les deux LED
LED_2 = 1
Return

End

Logiciel 2 : se déplacer et identifier les obstacles
Passons donc au second programme. il s’agit d’un logiciel un peu plus complexe, permettant au robot de se déplacer et de contourner les obstacles identifiés grâce à l’existence des antennes. Si un obstacle est identifié, le robot recule de quelques centimètres et change de direction.
Regardons l’organigramme (figure 3) : après quelques opérations initiales de signalisation (clignotement des yeux et émission d’un son) on entre dans le cycle principal du programme. Initialement, on vérifie qu’aucune antenne n’a rencontré d’obstacle (auquel cas, des mesures opportunes seraient prises) et ensuite le mouvement en avant se poursuit. Dans le cas où au moins une des deux antennes a été affectée, la direction du mouvement s’inverse pendant un certain temps, un son est émis, l’oeil situé du côté de l’obstacle s’éteint, une rotation est accomplie afin d’éviter l’obstacle, l’oeil se rallume et l’on revient dans le cycle principal pour poursuivre la progression.
Analysons le “listing” correspondant. Outre les définitions vues dans l’exemple précédent, il faut ajouter celles permettant de commander les servomoteurs. En particulier on déclare que le servomoteur droit (Servo 1) est relié au bit 2 du port B et que le servomoteur gauche (Servo 2) est relié au bit 1 de ce port B.
Avant de continuer l’analyse, donnons deux précisions quant à l’utilisation et la gestion des moteurs. CarBot est doté de deux servomoteurs commandant la vitesse de rotation des roues, ce qui permet au robot de se mouvoir en avant, en arrière ou de pivoter sur lui-même. On l’a vu dans les articles précédents, les moteurs utilisés sont des servomoteurs du type de ceux utilisés dans les aéromodèles, mais dûment modifiés afin de permettre la rotation complète dans les deux sens. Le mouvement est commandé en entrée par des trains d’impulsions rectangulaires dont la durée change le sens de la rotation. Si la durée des impulsions est de 1,5 ms, le moteur reste immobile, avec des durées de 1 à 1,5 ms, le moteur tourne dans une direction, enfin pour des durées de 1,5 à 2 ms, le moteur tourne dans la direction opposée.
Dans notre programme, la production des impulsions rectangulaires est réalisée par l’intermédiaire de l’instruction “PulsOut (Pin, Period)” produisant, sur la broche Pin spécifiée, une impulsion de durée égale à 2.10–6.Period secondes. Il est donc possible, en variant le paramètre Period, de produire des trains d’impulsions de durée opportune. En particulier pour obtenir des trains d’impulsions de durée égale à 1,5 ms, 1,0 ms et 2,0 ms, on doit utiliser des valeurs de Period égales respectivement à 750, 600 et 900.
La seconde précision concerne le montage des moteurs sur le châssis du robot. Ils sont en effet montés en sens opposés l’un par rapport à l’autre : c’est-à-dire que le moteur droit a 900 comme valeur de Period et il tourne donc dans un sens, le moteur gauche en revanche, pour la même valeur, tourne en sens inverse. En fait, si nous voulons faire avancer CarBot en ligne droite, le moteur de droite doit être commandé avec la valeur 900 et celui de gauche en revanche avec 600. Si, au contraire, on inverse les valeurs, CarBot se déplace toujours en ligne droite, mais au lieu d’avancer, il recule.
Ces choses étant entendues, nous pouvons comprendre les définitions des positions maximales et minimales des servomoteurs et celles des variables “Pos_servo 1” et “Pos_servo 2” utilisées pour mémoriser le Period correspondant aux deux moteurs.
Si nous poursuivons la lecture du “listing”, nous voyons que les ports utilisés sont initialisés, que les subroutines du clignotement des yeux et de l’émission initiale du son sont appelées et enfin qu’on entre dans le cycle principal où, par l’intermédiaire de la subroutine “Ants”, un test de l’état des micro-interrupteurs est exécuté et où, par l’intermédiaire de la subroutine “Avant”, la marche avant du robot est gérée.
Avant d’analyser comment est gérée la présence des obstacles, voyons comment se passe le mouvement en avant.
Considérons donc le code de la subroutine “Avant” : tout d’abord sont paramétrés en “Pos_Servo 1” et “Pos_Servo 2” les positions correctes des servomoteurs pour la marche avant (noter, comme nous l’avons expliqué plus haut, que pour le servomoteur droit, on utilise la valeur 900 etque pour le servomoteur de gauche, on utilise la valeur 600) et ensuite est appelée la subroutine “Exécute”, soit celle exécutant le mouvement proprement dit. Celle-ci, par l’intermédiaire de l’instruction “PulsOut”, produit les trains d’impulsions rectangulaires de durée opportune et commande donc le mouvement des roues.
Si l’on a compris comment est géré la marche avant, revenons à la subroutine “Ants” et à la gestion des obstacles. Cette subroutine exécute des tests des microinterrupteurs afin de vérifier s’il y a un obstacle et appelle éventuellement les fonctions opportunes. Prenons, par exemple, le cas où l’antenne gauche rencontre un obstacle : la subroutine “Gauche” est appelée, le robot recule de quelques centimètres vers la droite pour contourner l’obstacle. La subroutine “Arrière” gère le mouvement vers l’arrière : le fonctionnement est bien sûr opposé par rapport à la fonction “Avant”, ici toutefois les deux moteurs tournent en sens opposés par rapport au cas précédent (on utilise donc la valeur 600 pour le servomoteur droit et 900 pour le gauche). On note la présence du cycle “FOR” exécutant 20 fois le mouvement : ceci a été inséré afin de reculer d’une distance suffisante pour le contournement de l’obstacle.
La rotation vers la droite est en revanche réalisée en inversant la rotation du seul moteur droit. La position du servomoteur 2 (le gauche) reste en effet la même que dans le cas de la marche avant. En revanche, la position du servomoteur droit change (on passe de 900 à 600).
Dans ce cas aussi, le mouvement est réalisé plusieurs fois, ce qui permet de ne pas faire qu’une rotation de quelques degrés, mais une plus ample (environ 90°). Au sein de la subroutine “Gauche” sont également gérés l’extinction et l’allumage des LED.
Dans les deux cas restants, ceux où on rencontre un obstacle côté droit ou sur les deux antennes, le fonctionnement est analogue au précédent : CarBot doit reculer de quelques centimètres puis tourner à gauche d’environ 90° ou exécuter une rotation de 180°. Les deux valeurs avec lesquelles on commande les servomoteurs doivent donc changer. En outre, on doit gérer correctement l’allumage et l’extinction des deux LED.
On remarque, à l’intérieur de la subroutine “Inverse” (celle gérant le cas où les deux antennes sont affectées) que, dans le cycle “FOR” gérant la rotation à 180°, on utilise un pas (“Pas_2) plus faible que le pas (Pas_1) utilisé pour les rotations à 90°, ceci afin d’exécuter plusieurs fois la subroutine “Exécute” et donc de réaliser une rotation plus ample.
Ainsi s’achève la brève présentation des programmes de gestions de CarBot. On l’a vu, les “listings” (quoique for t simples et facilement compréhensibles) permettent de faire faire à notre robot tous les mouvements nécessaires pour se déplacer en évitant les obstacles. La finalité de cet article n’était certes pas de montrer tout ce que peut faire le robot, mais simplement d’expliquer les principes de base du logiciel de contrôle. En particulier, nous voulions expliquer comment lire en “Input” les états des dispositifs externes et comment commander les périphériques en “Output”, en particulier les deux servomoteurs.
Nous vous laissons développer le logiciel que nous venons de voir et lui ajouter toutes les fonctions que votre imagination vous inspirera.
Nous vous rappelons enfin qu’il est possible, par l’intermédiaire des deux connecteurs d’expansion SV1 et JP13/JP14/JP15, de superposer à la carte-mère d’autres platines supplémentaires, de façon à ajouter de nouveaux composants au système. Si vous avez compris, grâce à l’article, comme se fait la gestion des périphériques déjà présents sur CarBot, vous serez capables de bien vous débrouiller avec ces nouveaux éléments aussi.
Les codes originaux écrits en Basic des logiciels présentés dans l’article et des autres programmes pour CarBot sont tous disponibles et téléchargeables sur le site de la revue, sous forme de fichier avec extension .bas, donc directement chargeables par le compilateur Basic et transférables sur PC par le port sériel grâce au “bootloader”. Nous vous suggérons d’utiliser ces codes comme base initiale pour écrire de nouveaux programmes de gestion du robot.

Figure 3 : Se déplacer et identifier les obstacles.

ORGANIGRAMME



LISTING

‘*************************************************************************
‘* Nom : CarBot Antennes *
‘* Proces.: PIC16F876 *
‘* Note : Identifie les obstacles avec les antennes. *
‘*************************************************************************

‘------[ Définitions ]-----------------------------------------

DEFINE LOADER_USED 1 ‘Utilisé pour boot-loader
DEFINE OSC 20 ‘Paramètre Clock à 20MHz
ADCON1 = 000111 ‘Port A = Numérique

‘------[ Vers Port ]-----------------------------------------

TRISA = 110000 ‘paramètre broches 4,5 Port A en Input;
‘Output reste
TRISB = 000000 ‘paramètre broches Port B en
Output toutes
TRISC = 100100 ‘paramètre broches 2,5 Port C en Input;
‘Output reste

‘------[ Définitions I/O ]-----------------------------------------

Servo1 VAR PORTB.2 ‘Port Servo 1(Droite)
Servo2 VAR PORTB.1 ‘Port Servo 2(Gauche)
Ant_1 VAR PORTA.4 ‘Port Antenne 1
Ant_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

‘------[ Définitions Variables ]-----------------------------------------

Pos_Servo1 VAR WORD ‘position servo1 Droite
Pos_Servo2 VAR WORD ‘position servo2 Gauche
ncount VAR BYTE ‘utilisé dans les cycles for
Note VAR BYTE ‘note pour Sound

‘------[ Définitions Constantes ]-----------------------------------------

pos_max_1 CON 900 ‘Position Maximale Droite
pos_min_1 CON 600 ‘Position Minimale Droite
pos_max_2 CON 900 ‘Position Maximale Gauche
pos_min_2 CON 600 ‘Position Minimale Gauche
Retard CON 20 ‘Pause pour PulsOut in microsecondes
Pas CON 5 ‘Pas pour cycle arrière
Pas_1 CON 5 ‘Pas pour cycle gauche, droit
Pas_2 CON 2 ‘Pas pour cycle Inverse
Durée CON 50 ‘Durée note pour Sound

‘------[ Initialisation ]-----------------------------------------

PORTA =0
PORTB =0
PORTC =0

‘------[ Début programme ]-----------------------------------------

ncount = 0
Note = 0
GoSub Yeux ‘clignotement LED
Note = 50
GoSub Son ‘émet son initial

Début :
GoSub Ants ‘teste si contact sur antennes
GoSub Avant ‘mouvements en avant
GoTo Début ‘répétition du cycle

‘------[ Subroutine ]-----------------------------------------
Exécute :
PulsOut Servo1,Pos_Servo1 ‘train d’impulsions sur servo droit
PulsOut Servo2,Pos_Servo2 ‘train d’impulsions sur servo gauche
Pause Retard
Return

Antennes :
IF Ant_1 = 0 Then Gauche ‘contact sur antenne 1
IF Ant_2 = 0 Then Droit ‘contact sur antenne 2
IF Ant_1 AND Ant_2 = 0 Then Inverse ‘contact sur les deux
Return

Son :
Sound Speaker, [Note,Durée] ‘émission note
Low Speaker ‘mise à zéro speaker
Return

Yeux :
LED_1 = 0 ‘éteint les deux LED
LED_2 = 0
For ncount=0 to 4 ‘clignotement des LED
Toggle LED_1
Toggle LED_2
Pause 100
Next
Return

Avant :
Pos_Servo1 = pos_max_1 ‘paramètre valeurs pour servo droit
Pos_Servo2 = pos_min_2 ‘paramètre valeurs pour servo gauche
GoSub Exécute ‘exécute le mouvement
Return

Gauche :
‘il faut retourner en arrière et tourner à gauche pour éviter
‘l’obstacle identifié par Ant_1 (antenne gauche)
GoSub Arrière ‘retourne en arrière
Note = 10
GoSub Son ‘émet son gauche
LED_1 = 0 ‘éteint LED droite
For ncount=0 to 100 step Pas_1 ‘maintenant tourne à gauche
Pos_Servo1 = pos_min_1 ‘inverse mouvement
‘du servo droit
Pos_Servo2 = pos_min_2
GoSub Exécute ‘exécute la rotation
Next
LED _1 = 1 ‘rallume LED gauche
Return

Droite :
‘il faut retourner en arrière et tourner à gauche pour éviter
‘l’obstacle identifié par l’Ant_2 (antenne droite)
GoSub Arrière ‘retourne en arrière
Note = 100
GoSub Son ‘émet son droit
LED_2 = 0 ‘éteint LED droite
For ncount=0 to 100 step Pas_1 ‘maintenant tourne à gauche
Pos_Servo1 = pos_max_1
Pos_Servo2 = pos_max_2 ‘inverse mouvement
‘du servo de gauche
GoSub Exécute ‘exécute la rotation
Next
Led_2 = 1 ‘rallume LED droite
Return

Inverse :
‘il faut retourner en arrière et tourner à 180 degrés pour éviter
‘l’obstacle identifié par les deux antennes
GoSub Arrière ‘retourne en arrière
Nota = 50
GoSub Son ‘émet son inverse
Led_1 = 0 ‘éteint les deux LED
Led_2 = 0
For ncount=0 to 100 step Pas_2 ‘maintenant tourne à droite de
‘180 degrés
Pos_Servo1 = pos_min_1
Pos_Servo2 = pos_min_2
GoSub Exécute ‘exécute la rotation
Next
Led_1 = 1 ‘rallume les deux LED
Led_2 = 1
Return

Arrière :
For ncount=0 to 100 step Pas ‘retourne en arrière
Pos_Servo1 = pos_min_1 ‘inverse le mouvement du
‘servo de droite
Pos_Servo2 = pos_max_2 ‘inverse le mouvement du
‘servo de gauche
GoSub Exécute ‘exécute le mouvement
Next
Return
End


‘*************************************************************************
‘* Nom : Centrage ServoMoteurs *
‘* Proces.: PIC16F876 *
‘* Note : Permet de centrer les 2 Servomoteurs *
‘*************************************************************************

‘------[ Définitions ]-----------------------------------------
DEFINE LOADER_USED 1 ‘Utilisé pour boot-loader
DEFINE OSC 20 ‘Paramètre Clock à 20MHz
ADCON1 = 000111 ‘Port A = Numérique

‘------[ Vers Port ]-----------------------------------------
TRISB = 000000

‘-----[ Définitions I/O ]-----------------------------------------
Servo1 VAR PORTB.2 ‘Port Servo 1
Servo2 VAR PORTB.1 ‘Port Servo 2

‘------[ Initialisation ]-----------------------------------------
PORTB = 0

‘------[ Début programme ]-----------------------------------------
Début :
PulsOut Servo1, 748 ‘Centre le Servo 1 avec ‘1496 us
PulsOut Servo2, 750 ‘Centre le Servo 2 avec ‘1500 us
Pause 20 ‘Attend 20 ms
GoTo Début

End

Figure 4.

Figure 5 : l’utilisation pratique.
On l’a vu dans l’article, les servomoteurs sont commandés au moyen des paramètres “Period” de la fonction “PulsOut”. Nous avons déjà expliqué que pour des valeurs de “Period” égales à 900 ou 600 le moteur tourne dans un sens ou dans l’autre, alors que pour 750 il reste arrêté. Ces valeurs ont été calculées théoriquement avec la formule : T = 2 x 10 - 6 x Period.
En remplaçant T par la durée désirée, on obtient les valeurs de “Period”. En réalité, dans l’utilisation pratique, il y a toujours des tolérances. Par exemple, au cours de nos tests, il est arrivé que, pour “Period” égal à 750, les moteurs ne fussent pas tous les deux arrêtés : le droit tournait à vitesse minimale. Nous avons donc dû centrer les deux servomoteurs (au moyen du “listing” Centrer les Servomoteurs, figure 4) : le moteur gauche était arrêté pour “Period” égal à 750, le droit pour 748. Les valeurs maximales et minimales pour le servomoteur gauche étaient 900 et 600, pour le droit 898 et 598. On le voit, ces variations sont minimes, elles constituent une tolérance normale pour des appareils électroniques et peuvent être résolues en mettant en oeuvre le dispositif logiciel opportun.

Figure 6 : Le Pic Basic Compiler.

Figure 6a : Ecran du “PicBasic Compiler” : il est possible d’écrire directement dans la fenêtre le “listing” en basic.
Avec un clic, on obtient le code compilé au format .HEX.


Figure 6b : Fenêtre des paramètres du “PicBasic Compiler” : il est possible de spécifier si l’on veut utiliser la version de base ou pro et le registre où se trouve le compilateur.

Pour faire fonctionner CarBot, il est nécessaire d’écrire un programme qui lui fasse faire ce que nous désirons.
Le programme peut être écrit en n’importe quel langage, mais pour pouvoir être transféré dans le PIC16F876 il est nécessaire qu’il soit compilé au format .HEX, compréhensible par le microcontrôleur. Pour nos exemples, nous avons utilisé le langage de programmation Basic : nous avons donc dû nous munir d’un compilateur Basic pour PIC capable de convertir les “listings” écrits en Basic en instructions du code machine.
Dans l’article précédent, nous nous sommes déjà occupés du “bootloader” et du transfert, à partir du PC, des fichiers .HEX. Dans celui-ci, nous expliquons en revanche comment obtenir, à partir des “listings” en Basic, les fichiers .HEX correspondants. Pour cela, nous avons utilisé le “Packet” (paquet) “PicBasic Compiler” de μEngineering Labs. Avec ce logiciel, il est possible d’écrire un programme directement en Basic. C’est ensuite au compilateur de le transformer en un fichier écrit en code machine pouvant être mémorisé par le microcontrôleur via le “bootloader”. L’utilisation de ce logiciel rend la programmation beaucoup plus simple et rapide, elle permet de réaliser en peu de lignes de Basic ce qui en demanderait beaucoup en Assembleur.
Le logiciel est disponible en deux versions : une de base permet d’utiliser les fonctions avancées de programmation, commandes de saut, d’interaction, etc. et une pro ajoutant la gestion des “interrupts”, la possibilité d’utiliser “array”, une meilleure gestion des sérielles au niveau matériel et logiciel, etc. Pour nos robots, la version de base du compilateur suffit.

Figure 7 : Dans le prochain article, nous nous occuperons du deuxième robot, Filippo. Comme pour CarBot, nous étudierons tout d’abord l’aspect matériel des choses et le montage mécanique. Par la suite, nous analyserons la programmation logicielle.

Fin.

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

0 commentaires:

Enregistrer un commentaire

Related Posts Plugin for WordPress, Blogger...