Manipulateur

Institut Universitaire de Technologie de TOURS
Département Génie Electrique et Informatique Industrielle
Mini projet d’Informatique Industrielle
Le robot Tergane
Brahim EL GHOUL Thibaud LEVRARD
Groupe A2 - Promotion 2004 2006

M. Pierre POISSON
- -
Institut Universitaire de Technologie de TOURS
Département Génie Electrique et Informatique Industrielle
Mini projet d’Informatique Industrielle
Le robot Tergane
Brahim EL GHOUL Thibaud LEVRARD
Groupe A2 - Promotion 2004 2006

M. Pierre POISSON
Sommaire
Sommaire _________________________________________________________________ 5
Introduction _______________________________________________________________ 4
1. Présentation générale de la maquette _______________________________________ 5
1.1. Technologie des actionneurs et préactionneurs____________________________________5
1.2. Entrées/sorties ______________________________________________________________5
1.3. Module de communication série ________________________________________________6
1.4. Format des trames de communication___________________________________________6
2. Cahier des charges ______________________________________________________ 8
2.1. Fonctionnement escompté _____________________________________________________8
2.2. Environnement______________________________________________________________8
2.3. Contraintes matérielles _______________________________________________________8
2.4. Planning ___________________________________________________________________9
3. Réalisation du programme _______________________________________________ 10
3.1. Description graphique _______________________________________________________10
3.2. Analyse globale_____________________________________________________________15
3.3. Analyse fonctionnelle ________________________________________________________17
3.4. Résumé de l’analyse _________________________________________________________23
Conclusion _______________________________________________________________ 27
Table des illustrations_______________________________________________________ 28
Annexes__________________________________________________________________ 29
Introduction
Il nous à été proposé dans le cadre de la matière Informatique Industrielle de

réaliser un projet. L’objectif de ces projets est la réalisation par les étudiants d’un
programme lié à l’industrie. Trois séances nous ont permis de mener à bien ce projet,
ceci en relative autonomie.
Pour notre part nous avons choisi de réaliser la commande d’un bras
manipulateur, la pince Tergane. Vétuste mais toujours fonctionnelle, nous explicitons
dans ce dossier la démarche que nous avons suivie pour élaborer notre projet.
Dans une première partie nous présenterons la pince, puis dans une seconde
nous définirons le cahier des charges. Enfin nous étudierons la composition du
programme.
4
1. P r é se nt at ion gé né r ale de la maque t t e
Une présentation succincte du bras manipulateur va être faite ici. On verra la

technologie des actionneurs et préactionneurs, les différentes entrées sorties, la
communication série et le format des trames de communication.
1.1. Technologie des actionneurs et préactionneurs

Les préactionneurs 1 et actionneurs 2 du bras manipulateur sont de types
électriques. Ils sont majoritairement commandés de façon binaire, soit il y a une
tension et l’actionneur est activé, soit il n’y a pas de tension et l’actionneur ne se
déplace pas.
La base du bras, le coude, le poignet et l’épaule sont tous commandés de cette

manière. Il est bon de préciser que les commandes envoyées au robot sont ensuite
soumises à un traitement ; un asservissement de position est effectué afin que la
pince soit précise.
La pince n’est pas commandée de façon binaire. Il est en effet possible de

régler la vitesse à laquelle celle-ci s’ouvre ou se ferme. Ceci est réglable par
l’intermédiaire de la trame que l’on enverra au robot.
1.2. Entrées/sorties
On l’a vu précédemment, il y a cinq composants que l’on peut commander : la
base, l’épaule, le coude, le poignet et la pince.
Figure 1. Emplacement des éléments
1
Interface entre la partie commande et les actionneurs
2
Transforment l’énergie reçue en énergie utile
5
Ces composants sont commandés par le biais de trames que l’on envoie au
robot grâce à la liaison série.
Les deux parties suivantes permettent de rappeler les paramètres de la liaison

série et le format des trames requis par le robot.
1.3. Module de communication série

Pour pouvoir communiquer correctement, les paramètres suivant devront être
définis dans notre programme. Le robot à une interface de réception de trame avec
des paramètres bien définis. Si l’on veut pouvoir communiquer avec ce dernier, il
nous faut impérativement régler ces paramètres dans notre logiciel.
- Vitesse de communication :
- parité :
- bit de stop :
- AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
1.4. Format des trames de communication

Après avoir configuré notre logiciel pour qu’il puisse communiquer avec la
pince, il nous faut utiliser le format des trames qui a été défini par les constructeurs
du robot. Sans quoi le logiciel ne pourrait pas reconnaître nos requêtes.
On a deux types de trames différentes, une pour les éléments commandés de

façon binaire et une autre pour l’élément commandé analogiquement (la pince).
1.4.1. Trame analogique
La trame suivante permet d’ouvrir et fermer la pince à différentes vitesses.
P ± Y Y Y
« P » permet au module gestion des trames du robot de savoir que l’on veut
agir sur la pince.
« ± » définit si l’on veut fermer (+) ou ouvrir la pince (-).
« YYY » est un nombre qui définit la vitesse de fermeture de la pince. Ce

nombre varie de 0 (lent) à 450 (rapide).
La pince saisit les objets et un mécanisme permet de ne pas les écraser. Un

capteur détecte que la pince à suffisamment exercé de pression sur l’objet.
6
1.4.2. Trames binaires
On a la trame suivante :
X ± Y Y Y
- « X » est ici une lettre qui représente soit la Base (B), le Coude (C),
l’Epaule (E), le poignet (F),
- « YYY » est un nombre qui varie selon l’élément. Ce nombre permet de

définir à quel endroit se déplacera la pince.
Le tableau suivant définit les variations qui peuvent être appliquées. A noter
que l’on varie entre la partie positive et négative grâce au caractère situé entre le
« X « et les « YYY ».
Elément Représentation Extrémité négative Extrémité positive
Base B - 490 510
Epaule E - 511 360
Coude C - 495 3
Poignet F - 440 205
Pince P - 450 + 450
Figure 2. Récapitulatif de la valeur des trames
7
2 . C ahie r de s c har ge s
On va ici décrire le cahier des charges que nous avons défini pour le
fonctionnement du bras manipulateur. On exposera l’objectif visé du système et les
différentes contraintes liées au matériel et à l’environnement.
2.1. Fonctionnement escompté

A l’origine nous désirions que notre projet soit développé dans un processus
industriel ; le robot Tergane pourra être utilisé comme bras manipulateur.
Pour lui permettre une autonomie maximale, un mode manuel s’avère plus
que nécessaire. Ce mode manuel autorise tous les mouvements possibles de manière
aisée et précise. Dans un second temps, il serait intéressant d’aller plus loin en
intégrant une manette de commande qui remplacerait la souris ou le clavier.
Comme toute application industrielle, un mode initialisation est nécessaire

pour faciliter le maniement du bras par l’utilisateur ; ceci malgré la mise en référence
automatique du robot Tergane à sa mise sous tension.
Un troisième et dernier mode devra permettre une évolutivité optimale au

niveau des cycles, se sera le mode apprentissage. Ce mode permet à l’opérateur de
réaliser un cycle quelconque préenregistré. En effet, ce mode enregistre le nom d’un
cycle (que l’opérateur choisit) et les mouvements réalisés pendant la séquence
d’apprentissage. Ensuite ce cycle peut être choisi et réalisé par l’opérateur
indéfiniment.
Après consultation du cahier des charges du robot Tergane, nous avons

constaté que celui-ci nous envoie un message afin de valider la bonne ou la mauvaise
réception des trames envoyées : « message correct » ou « message incorrect ».
On réutilise ces dernières afin de suivre la justesse des différentes

informations qui transitent par la liaison série. Le message de la trame envoyé par
Tergane sera affiché sur le pupitre de commande.
2.2. Environnement
La pince a pour but d’être utilisée en milieu industriel. Le logiciel doit donc
être clair, concis et fiable. Une erreur de programmation pourrait entrainer l’arrêt
d’une chaîne de production par exemple.
2.3. Contraintes matérielles

Le module Tergane est, comme on l’a dit, vétuste. Certains moteurs offrant un
degré de liberté au bras manipulateur ne fonctionnent plus correctement. Le robot
possède des bugs intempestifs qui bloquent le fonctionnement de tous les
actionneurs. Nous ne sommes pas parvenus à localiser l‘origine de la panne. Nous
devions dans ce cas interrompre et rétablir l’alimentation du robot jusqu'à que celui-
ci se réinitialise automatiquement.
8
Ainsi il n’est plus possible d’effectuer la rotation définie dans la
documentation technique. Il faudra prendre en compte cette vétusté et veiller à ne pas
l’aggraver.
2.4. Planning
Le planning suivant à été réalisé :
Tâches réalisées 1 2 3 4
Programmation affichage des trames émises par
Tergane et bouton d'initialisation
Programmation des différents mouvements recti-
fication des positions prédéfinies dans le CDC
Test et modifications des mouvements et fin du
mode apprentissage
Fin et test du mode apprentissage
Planning prévu
Planning réelle
Figure 3. Planning
Nous nous sommes aperçus que le temps prévu pour réaliser le programme
était relativement cours.
9
3 . Ré alisat ion du pr ogr amme
Plusieurs parties vont ici nous permettre de décrire le fonctionnement du

programme. Nous verrons tout d’abord comment se présente graphiquement le
logiciel, puis nous expliciterons le fonctionnement global et enfin les sous fonctions
utilisées.
3.1. Description graphique

On présente ici la partie graphique du logiciel. Des idées d’améliorations vont
être faite ; la plupart du temps, ces améliorations auraient pu être faites sans
difficulté.
Voici l’ensemble des éléments qui composent notre logiciel. Les différents
éléments seront activés ou désactivés au cours de l’utilisation du logiciel.
Figure 4. Récapitulatif composants utilisés
La capture d’écran ci-dessus permet de résumer tous les composants utilisés.
Pour expliquer le fonctionnement du logiciel, nous allons procéder d’une

façon linéaire, c'est-à-dire dans l’ordre logique ou l’utilisateur se servira du logiciel.
10
3.1.1. Ouverture du logiciel
On lance le logiciel et la fenêtre suivante s’ouvre :
Figure 5. Fenêtre d'ouverture
On peut alors effectuer un choix entre différents modes. C'est-à-dire le mode :
- libre (Mode 1), où l’utilisateur commande le robot comme il le souhaite,
- le mode 2 ou le robot est initialisé à son état originel,
- le mode « apprentissage » où l’on sauvegarde chaque mouvement du robot,
- le mode de lecture des cycles enregistrés.

On décrit par la suite chaque mode.
3.1.2. Mode 1 : commande libre
Par définition le mode libre laisse à l’utilisateur toute liberté sur la commande.
Le logiciel envoie des trames au robot et celui-ci répond en réponse à ces trames. Au
fur et à mesure du programme on vérifie la réponse du robot. En cas d’erreur de
trame ou du robot, le message « Trame incorrecte » apparaît dans le label « lblEtat ».
On a la fenêtre graphique
suivante :
Figure 6. Mode libre
11
Problèmes majeurs rencontrés : la commande de la pince n’est pas une chose
aisée car elle connaît des moments de disfonctionnement.
Améliorations possibles : il serait plus aisé de pouvoir commander le bras

grâce à une manette ou un joystick. Ceci pour le mode libre mais aussi
apprentissage.
3.1.3. Mode 2 : initialisation
En sélectionnant le mode 2 on a la fenêtre suivante :
Figure 7. Mode initialisation
Cinq trames sont alors envoyées au robot pour mettre le robot à la position
voulue :
- une pour la base du bras, « B+000 »,
- une pour l’épaule, « E+000 »,
- une autre pour le poignet, « F+000 »,
- une pour la pince, « P-450 »
- une dernière pour le coude, « C+000 ».
Problèmes majeurs rencontrés : le programme s’exécute trop vite, il nous a

donc fallu trouver un moyen nous permettant de ne pas envoyer trop rapidement les
trames au robot.
Améliorations possibles : proposer différentes initialisations, ce qui

permettrait un gain en temps pour l’utilisateur. On pourrait ainsi définir une
initialisation en position basse ou haute, gauche ou droite …
12
3.1.4. Mode 3 : mode apprentissage
Ce mode permet de sauvegarder de façon permanente les cycles enregistrés

par l’utilisateur. C'est-à-dire que pendant une période donnée toutes les commandes
envoyées à la pince sont sauvegardées dans un fichier.
Le programme pourra ensuite être fermé, il sera toujours possible de lire les
cycles enregistrés.
Après sélection du mode apprentissage, « EditApr » permet de donner un nom

à la série de commandes qui sera sauvegardée. Le temps ne nous a pas permis de
gérer d’éventuelles erreurs de saisies que commettrait l’utilisateur.
Figure 8. Mode apprentissage
Lorsque l’utilisateur a saisi le nom du cycle, les fenêtres de commande de la

pince sont alors actives. Toutes les commandes envoyées sont à partir de ce point
sauvegardées dans le fichier qui porte le nom qu’a défini3 précédemment l'usager.
Lorsque l’utilisateur aura terminé les actions qu’il voudra réaliser, le

« BtnStop » lui permettra d’arrêter l’enregistrement et de revenir au choix des
modes.
La lecture de ce qui à été enregistré est réalisée par l’intermédiaire du dernier

mode.
3
A chaque fois que l’utilisateur définira un nouveau cycle, il sera créé un nouveau fichier qui portera le nom du
cycle.
13
Problèmes majeurs rencontrés : l’utilisation d’un fichier externe n’a pas été
chose facile. Des problèmes résultent toujours de cette difficulté ; notamment au
niveau de l’ouverture de fichiers qui pose des problèmes pour le mode 4.
Améliorations possibles : l’idéal serait de ne sauvegarder que les actions

majeures faites sur la pince. Pour le moment le moindre ajustement de trajectoire est
enregistré, ce qui est lourd.
3.1.5. Mode 4 : mode lecture des cycles enregistrés
Ce mode va simplement lire ce qui a été enregistré dans le fichier pendant

l’utilisation du mode apprentissage.
Une liste défilante permet à l’utilisateur de sélectionner quel cycle il désire

exécuter. Par manque de temps, aucune limite n’a été définie dans le nombre de
cycles qui pouvaient être enregistrés. Afin de limiter les problèmes il serait
préférable de bloquer à un certain nombre de cycles.
Figure 9. Mode lecture de cycles
Après sélection du cycle, chaque trame enregistrée est envoyée

successivement au module ; ceci dans l’ordre où l’utilisateur les a enregistrée.
Quand la lecture du cycle est terminée, l’utilisateur est de nouveau dans le

menu général et peut choisir entre les quatre modes.
Problèmes majeurs rencontrés : les objectifs n’ont pas été totalement atteints.
Du fait de difficultés liées à la lecture de fichiers, on ne peut lire que le dernier cycle
créé. Pour les mêmes causes on ne pourra pas lire un cycle après fermeture puis
réouverture du programme.
Améliorations possibles : Tout d’abord il serait agréable de pouvoir lancer en

boucle infinie un cycle, ce qui s’apparenterait à une automatisation. Ensuite pour
des questions de fiabilité, il serait intéressant, comme on l’a dit, de limiter le nombre
de cycles qui peuvent être sauvegardés.
14
3.2. Analyse globale
On a dans un premier temps défini comment l’utilisateur était graphiquement
guidé pour gérer la pince. Cette partie permet maintenant de décrire comment sont
pris en compte les événements crées soit par le click de souris de l’utilisateur, soit
par un événement externe (réception d’une trame émise par le robot par exemple).
Le programme peut se décomposer en trois parties :

- tout d’abord la partie graphique qui permet à l’opérateur de donner les instructions
à la machine,
- ensuite la partie émission qui va transcrire les ordres donnés graphiquement en
trames à envoyer au robot,
- puis une dernière partie qui récupérera toute les trames émises par le robot et qui
permettra d’indiquer les erreurs détectées par la pince.
La programmation que nous effectuons est événementielle. C'est-à-dire que
dès lors qu’un événement nouveau apparaît dans le programme, celui-ci est traité
« instantanément » par le programme.
L’ « ordinogramme » suivant permet de donner une idée du fonctionnement du

logiciel. Cependant il est important d’insister sur le fait que seule l’idée est ici
résumée. En effet, on ne peut représenter toutes les interactions qui sont effectuées
entre tous les composants du logiciel.
Début
Pas de
fermeture
de fenêtre
?
SwMarche
enclenché
?
RgChoix
Mode 1 Mode 2 Mode 3 Mode 4
Action libre de Sauvegarde de

l'utilisateur commandes envoyées
Envoie d'ordres Lecture d'un fichier et

définis par le concepteur envoie de commandes
Fermeture liaison série et feuille
Fin
Figure 10. Résumé de fonctionnement
15
Les appels aux sous fonctions « Action libre de l’utilisateur », « envois
d’ordres définis par le concepteur » etc. … n’en sont pas vraiment. Ces renvois
rappellent quelles actions seront gérées par l’ensemble du logiciel lors de la sélection
de tel ou tel mode.
Le principe du logiciel est simple, après ouverture du programme on peut

choisir entre quatre modes de fonctionnement. Un bouton d’approbation permet de
valider chaque choix que fait l’utilisateur. En réponse au choix du mode, certains
éléments seront accessibles ou non pour l’utilisateur.
16
3.3. Analyse fonctionnelle
On va ici expliciter les fonctions principales qui ont été programmées pour le
fonctionnement du logiciel.
Dans chaque cas un rappel des principaux paramètres utilisés sera fait, ensuite
un ordinogramme permettra de définir le fonctionnement de la sous-fonction, puis les
lignes de codes associées seront ensuite commentées.
3.3.1. Réception de trames
Cette fonction permet de réceptionner les trames en provenance de la pince.

La documentation technique de la pince nous apprend qu’à chaque fois que nous
envoyons une trame, celle-ci nous répond par l’intermédiaire d’une autre trame.
Les trames de réponses peuvent être de deux types, soit le module a

« compris » la trame que l’on vient de lui envoyer (affichage de « Trame correct »),
soit il ne la pas interprété (« trame incorrect »).
Pour un fonctionnement correct du logiciel, cette fonction de réception de

trame à du être désactivée lorsque le mode lecture était choisi. Le robot effectuait le
cycle écrit dans le fichier texte, puis le logiciel s’arrêtait. Cela s’explique par le fait
que l’on utilise une boucle pour lire les cycles. Pendant que les cycles étaient
réalisés, la fonction de réception ne pouvait plus fonctionner et le buffer continuait
d’emmagasiner des informations. A la fin de la lecture des cycles les informations
stockées par la fonction réception était énorme et ne pouvait être gérée.
a) Paramètres utilisés
Plusieurs techniques nous permettaient de réceptionner les trames. Nous avons

choisi de sélectionner la technique la plus simple. Ceci car il est toujours plus
intéressant pour un développeur d’utiliser la technique la plus simple, le gain en
temps est appréciable, surtout dans notre cas où le projet doit être réalisé en très peu
de temps.
Nous avons choisi de détecter la réception d’une trame sur l’événement

OnRxFlag. Dans les paramètres de la classe Serie, on paramètre le drapeau (ou Flag
en anglais) sur le caractère de fin de chaîne. Ainsi quand le module nous envoie une
trame, le drapeau est activé lorsqu’il y a détection du caractère de fin de chaine dans
le buffer de réception.
On peut se permettre d’utiliser cette fonction, car le système ne fonctionne pas

à grande vitesse. Le transfert de données est limité par le bras manipulateur à 9600
bauds.
Malgré le fait que le taux de transfert ne soit pas important, la fonction avait
parfois des ratés, et il arrivait que le premier caractère ne soit pas pris en compte.
Les deux conditions de la sous-fonction permettent de régler ce problème.
Le fait de réceptionner chaque trame émise par le robot permet d’obtenir un

logiciel fiable et robuste.
17
b) Ordinogramme
- Entier NbCaractères
Réception
- Tableau de 100 caractères
NbCar <- InputCount()
Lire buffet et écrire dans Trame
NbCar
< 25
?
Afficher(LedOn et lblEtat) erreur Afficher (LedOn et lblEtat) OK
Fin
Figure 11. Ordinogramme de la réception
c) code correspondant
{
int NbCar;
char Trame[50];
NbCar=Serie->InputCount(); // récupération de la valeur du nombre

// de caractères présent dans le buffer
if (NbCar<=25) // si la valeur est inférieure à 20 la réception peut être activée
{
Serie->Read (Trame,NbCar); // on lit la trame sur le port série
Trame[NbCar-1]='\0';
lblEtat->Caption=Trame; // on l'écrit sur le label
LedOn->Checked=true; // puis on active la Led
}
}
Figure 12. Code de la réception
3.3.2. Envoi de trames
Cette fonction sera réutilisée plusieurs fois dans notre logiciel. Elle permet
d’envoyer les commandes au robot pour qu’il agisse en fonction de ce qu’ordonne
l’utilisateur. Cette fonction d’envoi de trame est donc utilisée cinq fois, pour la
pince, l’épaule, la base, le coude, la pince et le poignet.
a) Paramètres utilisés
Les trames varieront en fonction de la position qu’aura souhaitée l’utilisateur.

Les objets graphiques permettant de simuler la position du bras manipulateur
(AbVCoude, AbPince, AbPoignet…). Ils renvoient- en fonction de la position de
18
leurs curseurs - une valeur qui varie dans la plage 4 correspondante à la partie que
l’on commande (Base, coude…). Cette valeur peut être récupérée par l’intermédiaire
du paramètre Value.
La fonction d’envoi sera utilisée pour la pince, la base, l’épaule… Cette

fonction sera placée sur l’événement OnValueChanged des objets de contrôle de
position. Le choix de cet événement permet d’avoir un fonctionnement fluide de la
pince tout en n’envoyant pas en continu des trames. Une trame sera envoyée
seulement quand l’utilisateur relâchera le bouton de sa souris.
b) Ordinogramme
Chaîne de 5 caractères
Envoie > TrameObjet
Ecrire « Value » de l'objet dans la chaîne
Envoyer la chaîne sur le port série
Fin
Figure 13. Ordinogramme Envoie
c) Code correspondant
{
char TrameBase [5];
sprintf (TrameBase,"B%+04d",AbHBase->Value ;); // Place dans la chaîne la Valeur du composant

//de commande
Serie->Write (TrameBase,5); //Ecrit TrameBase sur le port série

}
3.3.3. Ecriture de fichiers
Afin de sauvegarder les mouvements faits par le bras, on crée un fichier où

l’on placera tous les ordres envoyés au robot durant la période ou le logiciel était en
mode apprentissage.
a) Paramètres et événements utilisés
En premier lieu, il faut créer et ouvrir le fichier. Ceci sera fait dès lors que
l’utilisateur aura entré le nom du cycle et validé par l’appui sur le bouton la touche
entrée du clavier. Chaque nouveau cycle entrainera la création d’un nouveau fichier.
Pour détecter cela on se placera dans l’événement KeyPress de l’objet

EditApr. La détection de la touche « entrée » se fait grâce à la variable « &Key ».
Le fichier créé, il faut insérer dans le logiciel un module qui permettra de

sauvegarder chaque trame envoyée. Ce module, on l’insère à la suite de l’envoi de
4
Plage qui correspond à ce qui à été défini dans le paragraphe 1.4
19
trame. Ainsi on envoie la trame, puis on la stocke directement dans notre fichier. On
ajoutera de plus un « if » qui détectera si l’on se trouve dans le mode apprentissage.
b) Ordinogramme
Nouvel ordinogramme de la fonction « Envoi »
Envoie > TrameObjet
Ecrire « Value » de l'objet dans la chaîne
Envoyer la chaîne sur le port série
Mode
apprentissage
?
Ecrire la trame dans le fichier
Fin
Figure 14. Nouvelle ordinogramme de la fonction Envoie
c) code correspondant
- code pour détecter le mode apprentissage et stocker les trames.
{
if (RgChoix->ItemIndex==2) //Détection du mode apprentissage
{
n=fwrite (TrameBase,strlen(TrameBase), 1,pFichier); // écriture dans le fichier texte
}
}
- code pour créer le fichier
{
if (Key=='\r') // Détection de l'appui sur entrée
{
sprintf (NomCycle,"%s",EditApr->Text); // Récupération du nom de cycle donnée
pFichier=fopen(NomCycle,"w+t"); // Création du fichier texte
ListApr->Items->Add(NomCycle); // Actualisation de la liste défilante
CommandeVoir(); // Affichage des éléments de commandes

lblEtat->Caption=EditApr->Text; // Affichage du nom dans le label d'état
EditApr->Visible=false; // Cache l'élément de saisi du nom de cycle
20
RgChoix->Enabled=false; // Désactive le menu pour éviter la sortie
BtnRgOk->Enabled=false; //du mode apprentissage, ainsi que
} //le bouton de validation
}
3.3.4. Lecture de fichiers
Une fois les cycles sauvegardés et donc les fichiers créés, il nous reste à lire
ceux-ci et à envoyer au robot les trames sauvées.
a) Paramètres et événements utilisés
Après avoir sélectionné le dernier mode, l’utilisateur aura à choisir par le biais
de la liste défilante quel cycle il désirera lancer. On utilisera donc l’événement
OnClick de l’objet ListApr pour déclencher la lecture du fichier.
On lira le fichier par paquet de cinq caractères (trame de cinq caractères)

jusqu’à ce que la sous fonction de lecture de fichier nous indique que le fichier est
terminé. Une boucle nous permettra de réaliser successivement la lecture de chaque
trame.
Une fois ceci effectué on fermera le fichier pour écarter tout risque d’erreur.
b) Ordinogramme
Lecture > TrameEnvoi
Entiers local
>i
Initialisation du bras Entier global
>n
Désactivation du menu
Récupération du nom de
cycle sélectionné
Ouverture du cyle sélectionné
Temporisation
Acquisition nombre de trames

envoyées
Ecrire 5caractères du Fichier

dans la chaîne TrameEnvoi
Ecrire TrameEnvoi sur le

port série
Fichier non
terminé
?
Fermer le fichier
Figure 15. Ordinogramme lecture de fichiers

d) code correspondant
21
{
char TabEnvoi [500]={0};
int i=0;
Init(); // Initialise le bras

RgChoix->Enabled=false; // Désactive le menu pendant la lecture du cycle
BtnRgOk->Enabled=false; // Ainsi que son bouton de validation
ListApr->Visible=false; // Cache la liste pendant la lecture
pFichier=fopen(NomCycle,"r"); // Ouvre le fichier texte en mode lecture seule
n=fscanf(pFichier,"%s",TabEnvoi); // Acquisition nombre de lecture à faire
Sleep(1000); // Temporise afin que l'initialisation soit terminée

//avant la lecture du cycle
while(i<=(n/5)) // Tant que tout le fichier n'a pas été lu...
{
fgets(TabEnvoi,6,pFichier); // Ecriture du fichier texte dans TabEnvoi
i++;
Serie->Write(TabEnvoi,5); // On envoie TabEnvoi sur le port série
Sleep(300); // On temporise pour des problèmes de lenteur de la pince
}
fclose(pFichier);
RgChoix->Enabled=true; // On ré-active ensuite le menu et son bouton de
validation
BtnRgOk->Enabled=true;
}
3.3.5. Sous fonctions
On a créé des sous-fonctions pour faciliter la lecture du programme. Ainsi on

à une fonction d’initialisation de la pince, une d’obstruction des éléments de
commande (Base, coude…) et une d’affichage de ces derniers.
On a ainsi une lecture plus fluide du programme.
a) Initialisation
Pour ce mode, nous avons procédé par étape pour ramener la pince en position
initiale. Il nous a paru plus sûr d’ouvrir la pince puis de ramener le coude en position
initiale, suivi de l’épaule, de la base et enfin du poignet.
Agir ainsi nous permet, au cas ou il y aurait un objet dans la pince, de lâcher
l’objet puis de remonter le coude, l’épaule …
Déclaration privée : void __fastcall TFtergane::Init(void) ;
void __fastcall TFtergane::Init(void) // Sous programme d'initialisation du bras

{
Ftergane->Cursor=crHourGlass; // Affiche un curseur d'occupation
Serie->Write("P-400",5); // Ouvre la pince (opération la plus lente)

EtatPince=1; // Actualise l'état de la variable d'état de la pince
Sleep(75); // Temporise
Serie->Write ("C+000",5); // Puis Ramène le coude en position initiale

AbVCoude->Value=0; // Actualise l'élément de commande
22
Serie->Write("E+000",5); // Ramène ensuite l'épaule
AbVEpaule->Value=0; // Actualise l'élément de commande
Serie->Write("B+000",5); // Ramène la base

AbHBase->Value=0;
Sleep(75);
Serie->Write("F+000",5); // Ramène le poignet

AbPoignet->Value=0;
Sleep(200);
Ftergane->Cursor=crDefault; // Affiche le curseur normal

}
b) Affichage des éléments de commande
Il nous a souvent fallu afficher les cinq composants de commande graphiques

de la pince en même temps. D’où la création de cette fonction.
Déclaration privée : void __fastcall TFtergane::CommandeCache(void) ;
void __fastcall TFtergane::CommandeCache(void)

{
AbHBase->Visible=false;
AbVCoude->Visible=false;
AbVEpaule->Visible=false; // On cache les éléments de commande
AbPince->Visible=false; //la base , l'épaule, le coude...
AbPoignet->Visible=false;
}
c) Obstruction des éléments de commande
Il nous a souvent fallu cacher les cinq composants de commande graphiques

de la pince en même temps. D’où la création de cette fonction.
Déclaration privée : void __fastcall TFtergane::CommandeVoir(void)
void __fastcall TFtergane::CommandeVoir(void)

{
AbHBase->Visible=true;
AbVCoude->Visible=true; // On affiche les éléments de commande
AbVEpaule->Visible=true; //la base, l'épaule, le coude...
AbPince->Visible=true;
AbPoignet->Visible=true;
}
3.4. Résumé de l’analyse

Le tableau ci-dessous recense les différents éléments utilisés ainsi que leurs
propriétés principales.
23
ées Evénements pris en compte
tiales
Nom Variables utilisées (type, Description du comportement
portée)
A l’ouverture du programme la liaison série est

----- -------- ouverte et initialisée. En fin de programme elle
est fermée.
false
Si le bouton est enclenché, on se trouve au choix

des modes. Sinon aucun composant n’est
OnClick -------- accessible.
false
Signale la bonne (vert) ou mauvaise réception
------ -------- des trames (rouge).
false
Label permettant d’indiquer la signification du

at du ----- -------- label lblEtat.
eur »
Label indiquant diverses informations ;
----- -------- notamment la bonne réception des trames.
Etat»
RadioGroup jouant le rôle d’un menu ; les

Libre, ----- -------- différents modes d’utilisation du bras
tion, manipulateur sont choisis grâce à cet élément.
sage,
cle »
false
24
Permet de valider chaque action de l’utilisateur :
OnClick -------- nom de cycle, mode …
false
Key : Caractère local contenant Champ permettant à l’utilisateur de donner un

KeyPress la dernière touche du clavier nom à son cycle.
false tapée.
true
TabEnvoi : chaîne locale à
écrire sur le port série. Liste défilante (ComboBox) permettant de
OnSelect NomCycle : chaîne globale sélectionner quel cycle l’utilisateur veut
false contenant le nom du cycle créé. effectuer.
true n : entier global indiquant la fin
de lecture d’un fichier
OnClick -------- Bouton permettant de stopper l’enregistrement

false d’un cycle.
TrameCoude : chaîne locale

stockant les données à écrire
sur le port série et dans le Composant représentant le coude du robot.
ValueChanged fichier si besoin est. Quand la valeur est changée, le robot change de
position.
true
e=0
TrameEpaule : chaîne locale
sur le port série et dans le Composant représentant l’épaule du robot.
position.
true
e=0
25
TrameBase : chaîne locale
ValueChanged sur le port série et dans le Composant représentant la base du robot. Quand
fichier si besoin est. la valeur est changée, le robot change de
position.
true
e=0
TramePoignet : chaîne locale
ValueChanged sur le port série et dans le Composant représentant le poignet du robot.
fichier si besoin est. Quand la valeur est changée, le robot change de
position.
true
e=0
TramePince : chaîne locale
ValueChanged stockant les données à écrire Composant représentant la pince du robot.
true sur le port série et dans le Quand l’état est changé, la pince s’ouvre ou se
fichier si besoin est. ferme.
26
Conclusion
Notre mini-projet fonctionne et répond partiellement au cahier des charges.

Certaines fonctions que nous avions étudiées n’ont pu être insérées dans le logiciel
final à cause d’erreurs engendrées. La stabilité du logiciel a donc primé sur la
richesse des fonctions offertes.
Ce mini-projet réalisé en très peu de temps, a réclamé beaucoup de travail

personnel. Projeté dans le monde de l’entreprise, ce projet nous a permis de nous
rendre compte que respecter les délais et offrir un logiciel stable était un compromis
difficile ; ceci malgré le temps supplémentaire accordé.
Les commentaires qui agrémentent le corpus du programme autorisent une

reprise possible du logiciel. Ainsi les évolutions que nous proposons tout au long de
ce dossier pourraient aisément être développées.
27
Ta b l e d e s i l l u s t r a t i o n s
Figure 1. Emplacement des éléments................................................................................................................. 5
Figure 2. Récapitulatif de la valeur des trames................................................................................................. 7
Figure 3. Planning ........................................................................................................................................... 9
Figure 4. Récapitulatif composants utilisés ......................................................................................................10
Figure 5. Fenêtre d'ouverture ..........................................................................................................................11
Figure 6. Mode libre.......................................................................................................................................11
Figure 7. Mode initialisation ...........................................................................................................................12
Figure 8. Mode apprentissage..........................................................................................................................13
Figure 9. Mode lecture de cycles......................................................................................................................14
Figure 10. Résumé de fonctionnement..............................................................................................................15
Figure 11. Ordinogramme de la réception .......................................................................................................18
Figure 12. Code de la réception.......................................................................................................................18
Figure 13. Ordinogramme Envoie....................................................................................................................19
Figure 14. Nouvelle ordinogramme de la fonction Envoie ................................................................................20
Figure 15. Ordinogramme lecture de fichiers...................................................................................................21
Figure 16. Propriétés des composants..............................................................................................................26
28
An n e x e s
Annexes__________________________________________________________________ 29
1. Programme complet ____________________________________________________ 30
1.1. Fichier C++________________________________________________________________30
1.2. Fichier H __________________________________________________________________35
2. Rappel des objets_______________________________________________________ 37
3. Rappel des propriétés et classes utilisées ____________________________________ 37
29
1. P r ogr amme c omple t
Voici les lignes de codes qui permettent d’obtenir le programme décrit dans ce
dossier.
1.1. Fichier C++

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "U_Tergane2.h"
#include "stdio.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CPort"
#pragma link "_GClass"
#pragma link "AbCBitBt"
#pragma link "AbDBCtrls"
#pragma link "AbDial"
#pragma link "AbVSlide"
#pragma link "AbHSlide"
#pragma link "AbHMeter"
#pragma link "AbSwitch"
#pragma link "AbBar"
#pragma link "AbLED"
#pragma resource "*.dfm"
TFtergane *Ftergane;
//---------------------------------------------------------------------------
__fastcall TFtergane::TFtergane(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::FormActivate(TObject *Sender)
{
Serie->Connected=true; // Ouverture du port série
Init(); // initialisation de la pince
SwMarche->Enabled=true; // activation du bouton Marche/arret

}
//---------------------------------------------------------------------------
void __fastcall TFtergane::SerieRxFlag(TObject *Sender)
{
int NbCar;
char Trame[100];
NbCar=Serie->InputCount(); // récupération de la valeur du nombre

// de caractères présent dans le buffer
if(NbCar<=20) // si la valeur est inferieur a 20
{ // la réception peut être activée
Serie->Read(Trame,NbCar); // On lit la trame sur le port série

Trame[NbCar-1]='\0';
30
lblEtat->Caption=Trame; // On l'écrit sur le label
LedOn->Checked=true; // Puis on active la led pour indiquer que tout est correct
}
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::AbHBaseValueChanged(TObject *Sender)
{
char TrameBase[5];
sprintf(TrameBase,"B%+04d",AbHBase->Value ;); //place dans la chaîne la valeur du composant de

commande
Serie->Write(TrameBase,5); //Ecrit TrameBase sur port série
if(RgChoix->ItemIndex==2) //Détection du mode apprentissage

{
n=fwrite(TrameBase,strlen(TrameBase), 1,pFichier); // écriture dans le fichier texte
}
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::AbVCoudeValueChanged(TObject *Sender)
{
char TrameCoude[5]; // Idem que précédement pour le coude
sprintf(TrameCoude,"C%+04d",(int)AbVCoude->Value);
Serie->Write(TrameCoude,5);
if(RgChoix->ItemIndex==2)
{
n=fwrite(TrameCoude, strlen(TrameCoude), 1, pFichier);
}
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::AbVEpauleValueChanged(TObject *Sender)
{
char TrameEpaule[5]; // Idem que précédement pour l'épaule
sprintf(TrameEpaule,"E%+04d",(int)AbVEpaule->Value);
Serie->Write(TrameEpaule,5);
{
n=fwrite(TrameEpaule, strlen(TrameEpaule), 1, pFichier);
}
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::AbPoignetValueChanged(TObject *Sender)
{
char TramePoignet[5]; // Idem que précédement pour le poignet
sprintf(TramePoignet,"F%+04d",(int)AbPoignet->Value);
Serie->Write(TramePoignet,5);
{
n=fwrite(TramePoignet, strlen(TramePoignet), 1, pFichier);
}
}
31
//---------------------------------------------------------------------------
void __fastcall TFtergane::SwMarcheClick(TObject *Sender)
{
if(SwMarche->Checked==true) // Détecte l'activation du logiciel
{
CommandeVoir(); // Affiche les éléments de commande
RgChoix->Enabled=true; // Affiche RadioGroupe et bouton OK
}
else // Détecte l'état d'arrêt

{
CommandeCache(); // Cache les éléments de commandes
EditApr->Visible=false; // Cache éléments qui seront inutiles au redémarage du programme :
ListApr->Visible=false; //la liste, le bouton stop et l'edit
BtnStop->Visible=false;
RgChoix->ItemIndex=-1; // Désactive la séléction dans le RadioGroupe
RgChoix->Enabled=false;
BtnRgOk->Enabled=false;
fclose(pFichier); // Ferme le fichier qui pourrait être ouvert
}
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::FormClose(TObject *Sender, TCloseAction &Action)
{
Serie->Close(); // fermeture de la liaison série
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::BtnRgOkClick(TObject *Sender)
{
if(RgChoix->ItemIndex==0) // Détection mode Libre
{
Init(); // Initialisation de la pince
CommandeVoir(); // Affichage des éléments de commande

//EditApr->Visible=false; // Cache éléments inutils en mode libre:
//ListApr->Visible=false; //le champ de capture, la liste
//BtnStop->Visible=false; //défilante et le bouton stop
}
if(RgChoix->ItemIndex==1) // Détection mode initialisation

{
CommandeCache(); // Cache éléments de commande
//EditApr->Visible=false; // cache éléments inutils en mode
//ListApr->Visible=false; // Initialisation:
//BtnStop->Visible=false; // Le champ de capture, la liste
} // défilante et le bouton stop
if(RgChoix->ItemIndex==2) // Détection du mode apprentissage

{
CommandeCache(); // Cache les éléments de commande
//ListApr->Visible=false; // Cache la liste défilance
EditApr->Visible=true; // Demande le nom du cycle d'enregistrement
//BtnStop->Visible=true; // Affiche le bouton d'arret enregistrement du cycle
}
32
if(RgChoix->ItemIndex==3) // Détection mode lecture cycle
{
CommandeCache(); // Cache les éléments de commande
//EditApr->Visible=false; // Cache la saisi du nom de cycle
ListApr->Visible=true; // Affiche la liste défilante pour choisir le cycle
//BtnStop->Visible=false; // Cache le bouton d'arrêt
}
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::BtnStopClick(TObject *Sender)
{
CommandeCache(); // Cache les élément de commande
//EditApr->Visible=false; // Cache la saisi du nom de cycle

//ListApr->Visible=false; // de même pour la sélection des cycles enregistrés
//BtnStop->Visible=false;
fclose(pFichier); // Ferme le fichier désormais inutil
RgChoix->Enabled=true; // Ré-actite le menu
BtnRgOk->Enabled=true; // et son bouton de validation
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::EditAprKeyPress(TObject *Sender, char &Key)
{
if(Key=='\r') // Détection de l'appuie sur entrée
{
sprintf(NomCycle,"%s",EditApr->Text); // Récupération du nom de cycle donnée
pFichier=fopen(NomCycle,"w+t"); // Création du fichier texte
ListApr->Items->Add(NomCycle); // Actualisation de la liste défilante
CommandeVoir(); // Affichage des éléments de commandes

lblEtat->Caption=EditApr->Text; // Affichage du nom dans le label d'état
EditApr->Visible=false; // Cache l'élément de saisi du nom de cycle
RgChoix->Enabled=false; // Désactive le menu pour éviter la sortie
BtnRgOk->Enabled=false; //du mode apprentissage, ainsi que
} //le bouton de validation
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::ListAprSelect(TObject *Sender)
{
char TabEnvoi[500];

RgChoix->Enabled=false; // Désactive le menu pendant la lecture du cycle
BtnRgOk->Enabled=false; // Ainsi que son bouton de validation
ListApr->Visible=false; // Cache la liste pendant la lecture
pFichier=fopen(NomCycle,"r"); // Ouvre le fichier texte en mode lecture seule
Sleep(1000); // Temporise afin que l'initialisation soit terminée

//avant la lecture du cycle
while(n!=0) // Tant que tout le fichier n'a pas été lu...
{
n=fscanf(pFichier,"%s",TabEnvoi); // Ecriture du fichier texte dans TabEnvoi
if(n!=0) // SI le fichier n'est pas terminé

{
Serie->Write(TabEnvoi,5); // On envoie TabEnvoi sur le port série
Sleep(500); // On temporise pour des problème de rapidité de la pince
33
}
else // SINON on ferme le fichier
fclose(pFichier);
}
RgChoix->Enabled=true; // On ré-active ensuite le menu et son bouton de validation

}
//---------------------------------------------------------------------------
void __fastcall TFtergane::AbPinceStatusChanged(TObject *Sender)
{ // La pince est toujours initialisée ouverte
if(EtatPince==0) // SI la pince est fermé, on l'ouvre
{
Serie->Write("P-400",5) ; // Envoi le code d'ouverture à la pince
EtatPince=1; // Actualise l'état de la pince
}
else // SINON on ferme la pince

{
Serie->Write("P+400",5) ;
EtatPince=0 ;
}
}
//---------------------------------------------------------------------------
void __fastcall TFtergane::Init(void) // Sous programme d'initialisation du bras

{
Ftergane->Cursor=crHourGlass; // Affiche un curseur d'occupation
Serie->Write("C+000",5); // Ramène tout d'abord le bras en position initiale

AbVCoude->Value=0; // Actualise l'élément de commande
Serie->Write("E+000",5); // Ramène ensuite l'épaule

AbVEpaule->Value=0; // Actualise l'élément de commande
Serie->Write("B+000",5); // Ramène la base

AbHBase->Value=0;
Sleep(75);
Serie->Write("F+000",5); // Ramène le coude

AbPoignet->Value=0;
Sleep(75);
Serie->Write("P-400",5); // Ouvre la pince

EtatPince=1; // Actualise l'état de la variable d'état de la pince
Ftergane->Cursor=crDefault; // Affiche le curseur normal

}
void __fastcall TFtergane::CommandeCache(void)

{
AbHBase->Visible=false;
AbVCoude->Visible=false;
AbVEpaule->Visible=false; // On cache les éléments de commande
34
AbPince->Visible=false; //la base , l'épaule, le coude...
AbPoignet->Visible=false;
void __fastcall TFtergane::CommandeVoir(void)

{
AbHBase->Visible=true;
AbVCoude->Visible=true; // On affiche les éléments de commande
AbVEpaule->Visible=true; //la base, l'épaule, le coude...
AbPince->Visible=true;
AbPoignet->Visible=true;
}
1.2. Fichier H
class TFtergane : public TForm
{
__published: // Composants gérés par l'EDI
TComPort *Serie;
TLabel *lblEtat;
TLabel *lblTxtEtat;
TAbHSlider *AbHBase;
TAbRockerSwitch *SwMarche;
TAbVSlider *AbVCoude;
TAbDBVSlider *AbVEpaule;
TAbDial *AbPoignet;
TAbDBLED *LedOn;
TRadioGroup *RgChoix;
TButton *BtnRgOk;
TEdit *EditApr;
TAbColBitBtn *BtnStop;
TComboBox *ListApr;
TAbDBToggleSwitch *AbPince;
void __fastcall FormActivate(TObject *Sender);
void __fastcall SerieRxFlag(TObject *Sender);
void __fastcall AbHBaseValueChanged(TObject *Sender);
void __fastcall AbVCoudeValueChanged(TObject *Sender);
void __fastcall AbVEpauleValueChanged(TObject *Sender);
void __fastcall AbPoignetValueChanged(TObject *Sender);
void __fastcall SwMarcheClick(TObject *Sender);
void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
void __fastcall BtnRgOkClick(TObject *Sender);
void __fastcall BtnStopClick(TObject *Sender);
void __fastcall EditAprKeyPress(TObject *Sender, char &Key);
void __fastcall ListAprSelect(TObject *Sender);
void __fastcall AbPinceStatusChanged(TObject *Sender);
private: // Déclarations de l'utilisateur
FILE *pFichier;
char NomCycle[150];
int n;
int EtatPince;
void __fastcall Init(void); // Sous fonction Initialisation

void __fastcall CommandeCache(void); // Sous fonction cacher les éléments de commande
void __fastcall CommandeVoir(void); // Sous fonction afficher les éléments de commande
public: // Déclarations de l'utilisateur
__fastcall TFtergane(TComponent* Owner);
35
};
//---------------------------------------------------------------------------
extern PACKAGE TFtergane *Ftergane;
//---------------------------------------------------------------------------
#endif
36
2 . Rappe l de s obje t s
3 . Rappe l de s pr opr ié t é s e t c lasse s ut ilisé e s
37
ées Evénements pris en compte
tiales
Nom Variables utilisées (type, Description du comportement
portée)
A l’ouverture du programme la liaison série est

----- -------- ouverte et initialisée. En fin de programme elle
est fermée.
false
Si le bouton est enclenché, on se trouve au choix

des modes. Sinon aucun composant n’est
OnClick -------- accessible.
false
Signale la bonne (vert) ou mauvaise réception
------ -------- des trames (rouge).
false
Label permettant d’indiquer la signification du

at du ----- -------- label lblEtat.
eur »
Label indiquant diverses informations ;
----- -------- notamment la bonne réception des trames.
Etat»
RadioGroup jouant le rôle d’un menu ; les

Libre, ----- -------- différents modes d’utilisation du bras
tion, manipulateur sont choisis grâce à cet élément.
sage,
cle »
38
false
Permet de valider chaque action de l’utilisateur :
OnClick -------- nom de cycle, mode …
false
Key : Caractère local contenant Champ permettant à l’utilisateur de donné un

KeyPress la dernière touche du clavier nom à son cycle.
false tapée.
true
TabEnvoi : chaîne locale à
écrire sur le port série. Liste défilante (ComboBox) permettant de
OnSelect NomCycle : chaîne globale sélectionner quel cycle l’utilisateur veut
false contenant le nom du cycle créé. effectuer.
true n : entier global indiquant la fin
de lecture d’un fichier
OnClick -------- Bouton permettant de stopper l’enregistrement

false d’un cycle.
TrameCoude : chaîne locale

sur le port série et dans le Composant représentant le coude du robot.
position.
true
e=0
TrameEpaule : chaîne locale
sur le port série et dans le Composant représentant l’épaule du robot.
position.
true
39
e=0
TrameBase : chaîne locale
ValueChanged sur le port série et dans le Composant représentant la base du robot. Quand
fichier si besoin est. la valeur est changée, le robot change de
position.
true
e=0
TramePoignet : chaîne locale
ValueChanged sur le port série et dans le Composant représentant le poignet du robot.
fichier si besoin est. Quand la valeur est changée, le robot change de
position.
true
e=0
TramePince : chaîne locale
ValueChanged stockant les données à écrire Composant représentant la pince du robot.
true sur le port série et dans le Quand l’état est changé, la pince s’ouvre ou se
fichier si besoin est. ferme.
40

Manipulateur

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Manipulateur

Transféré par

Droits d'auteur :

Formats disponibles

Institut Universitaire de Technologie de TOURS

Département Génie Electrique et Informatique Industrielle

Mini projet d’Informatique Industrielle

Brahim EL GHOUL Thibaud LEVRARD

Groupe A2 - Promotion 2004 2006

Mini projet d’Informatique Industrielle

Brahim EL GHOUL Thibaud LEVRARD

Groupe A2 - Promotion 2004 2006

Il nous à été proposé dans le cadre de la matière Informatique Industrielle de

Une présentation succincte du bras manipulateur va être faite ici. On verra la

1.1. Technologie des actionneurs et préactionneurs

La base du bras, le coude, le poignet et l’épaule sont tous commandés de cette

La pince n’est pas commandée de façon binaire. Il est en effet possible de

Figure 1. Emplacement des éléments

Les deux parties suivantes permettent de rappeler les paramètres de la liaison

1.3. Module de communication série

1.4. Format des trames de communication

On a deux types de trames différentes, une pour les éléments commandés de

1.4.1. Trame analogique

La trame suivante permet d’ouvrir et fermer la pince à différentes vitesses.

« ± » définit si l’on veut fermer (+) ou ouvrir la pince (-).

« YYY » est un nombre qui définit la vitesse de fermeture de la pince. Ce

La pince saisit les objets et un mécanisme permet de ne pas les écraser. Un

- « YYY » est un nombre qui varie selon l’élément. Ce nombre permet de

Elément Représentation Extrémité négative Extrémité positive

Base B - 490 510

Epaule E - 511 360

Poignet F - 440 205

Pince P - 450 + 450

Figure 2. Récapitulatif de la valeur des trames

2.1. Fonctionnement escompté

Comme toute application industrielle, un mode initialisation est nécessaire

Un troisième et dernier mode devra permettre une évolutivité optimale au

Après consultation du cahier des charges du robot Tergane, nous avons

On réutilise ces dernières afin de suivre la justesse des différentes

2.3. Contraintes matérielles

Plusieurs parties vont ici nous permettre de décrire le fonctionnement du

3.1. Description graphique

Figure 4. Récapitulatif composants utilisés

La capture d’écran ci-dessus permet de résumer tous les composants utilisés.

Pour expliquer le fonctionnement du logiciel, nous allons procéder d’une

On lance le logiciel et la fenêtre suivante s’ouvre :

Figure 5. Fenêtre d'ouverture

On peut alors effectuer un choix entre différents modes. C'est-à-dire le mode :

- libre (Mode 1), où l’utilisateur commande le robot comme il le souhaite,

- le mode 2 ou le robot est initialisé à son état originel,

- le mode « apprentissage » où l’on sauvegarde chaque mouvement du robot,

- le mode de lecture des cycles enregistrés.

Figure 6. Mode libre

Améliorations possibles : il serait plus aisé de pouvoir commander le bras

3.1.3. Mode 2 : initialisation

En sélectionnant le mode 2 on a la fenêtre suivante :

Figure 7. Mode initialisation

- une pour la base du bras, « B+000 »,

- une pour l’épaule, « E+000 »,

- une autre pour le poignet, « F+000 »,

- une pour la pince, « P-450 »

- une dernière pour le coude, « C+000 ».

Problèmes majeurs rencontrés : le programme s’exécute trop vite, il nous a

Améliorations possibles : proposer différentes initialisations, ce qui

Ce mode permet de sauvegarder de façon permanente les cycles enregistrés

Après sélection du mode apprentissage, « EditApr » permet de donner un nom

Figure 8. Mode apprentissage