Informatique D'instrumentation

TP du Module
Informatique d’Instrumentation
S2
2009
TP1 TP2
TP3 TP4
Longueur = V × ∆T
TP5
PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Mesures physiques Matière : Informatique d’instrumentation S2
Sommaire
2009
Travaux pratiques n°1 : Apprentissage Labview +

Entrées-Sorties Numériques ...............................................5
A. Commande, indicateur, types de données.......................................... 5
1. Création des commandes et indicateur depuis la face avant ................................................. 5
2. Création des commandes et indicateur depuis la face diagramme ........................................ 5
3. Remplacement d'une fonction ............................................................................................. 5
4. Types de données et représentation ..................................................................................... 6
B. Structure : Boucle WHILE ................................................................ 6
1. Faire tant que vrai : boucle infinie ....................................................................................... 6
2. Faire tant que le bouton stop est faux .................................................................................. 6
3. Arrêt de la boucle sur test logique ....................................................................................... 6
4. Registre à décalage : Réaliser une rampe par 100. ............................................................... 6
5. Auto-indexation : résultat dans un indicateur de type tableau .............................................. 6
6. Créer un graphique sur la face avant à partir de l’indicateur ................................................ 6
C. Programmation de la carte entrées-sorties numériques...................... 7
1. Measurement Automation eXplorer .................................................................................... 7
2. Programmer une tension analogique en sortie sous MAX.................................................... 7
3. Programmer un mot de huit bits sur un port numérique sous Labview ................................. 7
4. Récupérer une valeur binaire numérique sous Labview ....................................................... 7
5. Acquérir les valeurs d’un accéléromètre 3 axes qui oscille, lié à un pendule. ....................... 7
D. Structure CONDITION ..................................................................... 8
Travaux pratiques n° 2 : Tableaux, tracés, Entrées-
sorties analogiques ...............................................................9
A. Tableaux ........................................................................................... 9
1. Création d’un tableau à l’aide d’une boucle For et d’un tunnel ............................................ 9
2. Calcul progressif de la moyenne des éléments du tableau .................................................... 9
3. Programmer un train d’impulsion........................................................................................ 9
B. Tracé d’une tension sinusoïdale simulée ........................................... 9
C. Entrées-sorties analogiques ............................................................... 9
1. MAEx Convertisseur une voie Numérique Analogique DAC0 .......................................... 10
2. Labview : Convertisseur une voie Numérique Analogique ................................................ 10
3. Convertisseur une voie Numérique Analogique DAC0 : Burst ......................................... 10
4. Acquisition des deux voies analogiques ............................................................................ 10
5. Etude d’une diode électroluminescente DEL..................................................................... 10
D. Création de tableaux avec des fonctions spécifiques ....................... 11
E. Tracé d’une fonction sinus + bruit................................................... 12
F. Tracé d’une Cycloïde ...................................................................... 12

Travaux pratiques n°3 : Circuit logique programmable
sous ABEL ..........................................................................13
A. Conversion par rampes.................................................................... 13
1. Visualisation du fonctionnement ....................................................................................... 13
2. Code pour afficheur 7 segments ........................................................................................ 13
3. Branchement de la carte de conversion.............................................................................. 13
4. Prise en compte du résultat du comparateur et affichage sur deux chiffres hexadécimaux.. 14
5. Limitation du temps de conversion.................................................................................... 14
B. Conversion par approximations successives.................................... 14
1. Visualisation du fonctionnement et programmation de rampes sur 8 bits ........................... 14
2. Prise en compte de la résolution du CNA et affichage sur deux chiffres décimaux............. 14
3. Mise en évidence des limites du fonctionnement ............................................................... 14
C. Annexe : Carte de logique programmable. ...................................... 15
D. Annexe : Logiciel ISP-LEVER ....................................................... 16
1. Ouvrir le programme ISP-lever_navigator......................................................................... 16
2. Ouverture d’un projet........................................................................................................ 16
3. Ecriture du programme en source Abel (voir ci-dessous)................................................... 16
4. Compilation du programme avec l’outil ISP...................................................................... 16
5. Programmation du composant cible avec l’outil ISP.......................................................... 16
6. Lancer l’outil ISP de téléchargement du code exécutable sur la carte qui va servir aux tests
16
7. Téléchargement du code exécutable sur la carte ................................................................ 16
8. Exécuter le programme ..................................................................................................... 16
Travaux pratiques n°4 robots en environnement
WEBOTS............................................................................17
A. Le logiciel Webots .......................................................................... 17
1. Lancement de Webots....................................................................................................... 18
2. Visualisation du monde virtuel.......................................................................................... 18
3. Déplacement du robot dans le monde virtuel ..................................................................... 18
4. Programmer le robot à base d’automate de contrôle ......................................................... 18
B. Exercices......................................................................................... 19
1. Faire s'arrêter le robot devant un obstacle.......................................................................... 19
2. Évitement d'obstacles........................................................................................................ 19
3. Suivi de ligne .................................................................................................................... 20
4. Suivi de mur ..................................................................................................................... 20
Travaux pratiques n°5 : Robot epuck pilotésous labview
.............................................................................................21
A. Connecter le robot epuck avec le logiciel labview .......................... 21
1. Appairer un port série avec le robot au travers d’une liaison Bluetooth.............................. 21
2. Prise en main et test de fonctionnement du robot............................................................... 21
3. Programmation sous LabView au travers de la liaison série............................................... 22
B. Mouvement rectiligne uniforme de longueur donnée ...................... 22
1. Calcul préliminaire............................................................................................................ 22
2. Programmer sous labview un évènement........................................................................... 22
C. Mouvement rotation sur place d’angle donné.................................. 22
2. Programmer sous labview un 2ème évènement................................................................... 22

D. Mouvement de contournement circulaire ........................................ 23
E. Enchaînement de mouvements différents........................................ 23
2. Créer une trajectoire carrée ............................................................................................... 23
3. Réaliser la trajectoire suivante........................................................................................... 23

Durée : 4h
Travaux pratiques n°1 Date : sem 32/2009
Travaux pratiques n°1 : Apprentissage Labview + Entrées-

Sorties Numériques
Vous devez avoir lu le document « PRESENTATION DE LabVIEW ».

Créer un répertoire à vos noms (ex : Dupond_Durand) dans le répertoire « Mes Documents ».
A chaque étape, sauvegardez votre travail dans un fichier. Vous rendrez en fin de chaque séance un
compte rendu de TP écrit sous Word. Vous en conservez un exemplaire pour vos révisions. Ce compte
rendu doit contenir les captures écrans ou des images obtenues par copier coller à partir de Labview.
A. Commande, indicateur, types de données
Ce premier exercice va vous permettre de vous familiariser avec les notions de commande, indicateur,
types de données, fonctions …
1. Création des commandes et indicateur depuis la face avant
1 Créer deux entrées ou commandes nommées A et B dans la face avant. Depuis la palette
Commandes, Commandes à Commandes Numériquesà Numérique positionner le subvi dans la face
avant, puis frapper le texte A (ou B) qui s'inscrit alors dans le rectangle prévu pour l'étiquette. Valider
ce texte en cliquant sur l'outil √ valider (situé dans la barre des outils) ou en cliquant dans une zone
libre de la face avant.
2 Créer une sortie ou indicateur nommé S (Commandes à Indicateurs

Numériquesà Numérique). Passer dans le diagramme. Observer la couleur orange correspondant à des
éléments de type réel. Les commandes sont encadrées d'un bord épais, alors que l'indicateur est
encadré d'un bord mince.
3 Amener dans la face diagramme la fonction Additionner (Fonctionsà Arithmétiqueà Express

Numérique). Sélectionner l'outil Bobine (de la Palette d’outils) et câbler les deux commandes et
l'indicateur à la fonction Additionner. Toute connexion qui apparaît en pointillés noirs n'est pas
correcte et peut être effacée grâce à CTRL+B.
4 Repasser dans la face avant et, avec l'outil Doigt, donner une valeur à A et B. Faire exécuter le
programme en cliquant sur la flèche Exécuter (tant que cette flèche est brisée, l'exécution est
impossible : erreurs de câblage, …)
2. Création des commandes et indicateur depuis la face diagramme
Depuis la face avant, effacer les commandes et indicateur créés précédemment afin de ne garder que
la fonction Additionner.
Passer dans la face diagramme. Prendre la bobine. Cliquer droit sur la sortie de la fonction afin de
faire apparaître son menu local. Sélectionner Créer à Indicateur. L'indicateur apparaît alors,
automatiquement câblé. Faire la même chose au niveau des deux entrées en sélectionnant Créer à
Commande. Renommer ces éléments en utilisant l'outil Texte.
Faire exécuter le programme, en ayant auparavant sélectionné l’icône Animer l’exécution depuis la
face diagramme. Observer le déroulement de cette exécution.
3. Remplacement d'une fonction

Dans le menu local de la fonction Additionner, sélectionner Remplacer. Choisir alors dans la palette la
fonction division. Exécuter le programme.
4. Types de données et représentation
1. Changer le type de la variable A en sélectionnant Représentation dans le menu local. Passer alors
en entier de type I16. La couleur orange (type flottant) devient bleue (type entier).
2 Créer un indicateur. Modifier en la précision avec Format & Precision dans son menu local.
Demander 7 chiffres significatifs. Augmenter alors la taille de l'indicateur en tirant sur son coin.
Dupliquer l’indicateur. Modifier le format en binaire. Dupliquer l’indicateur. Modifier le format en
hexadécimal. La variable A est de type entier signé sur 32 bits et se trouve formatée en sortie sous 3
formes : décimale, binaire et héxadécimale.
3 A partir de la commande B de type flottant, modifier cette commande en un bouton rotatif,
limiter la valeur entre 0 et 5.0, créer un indicateur, puis en changer le type en U8. Un point indique la
conversion du type de la donnée en un autre type. Expliquer la règle d’arrondi en variant la commande
et en considérant les valeurs correspondantes de l’indicateur.
B. Structure : Boucle WHILE
1. Faire tant que vrai : boucle infinie
On se propose de réaliser une rampe montante en dent de scie qui compte de zéro à 255, puis repasse à
zéro. L'algorithme est le suivant : Faire afficher le compteur de boucle i tant que vrai.
Fonctionsà Contrôle d’exécution amener la boucle Boucle While dans le diagramme du VI.
Créer un indicateur sur le compteur de boucle. Changer le type en U8. Pour ralentir l'exécution du
programme, mettre un délai de 30 ms dans la boucle, grâce à la fonction Temps d’attente dans
Fonctions>>Contrôle d’exécution. Observer l’indicateur.
2. Faire tant que le bouton stop est faux
Placer un inverseur (que vous trouverez dans Fonctions>>Arithmétique>>Booléen) entre le bouton
stop et la condition de boucle. Observer le fonctionnement de votre programme.
Dans le menu local de la condition de boucle changer l’option Arrêter sur condition vraie en
Continuer sur condition vraie. Observer le fonctionnement de votre programme.
3. Arrêt de la boucle sur test logique
Reprendre l'exercice en quittant la boucle après 1000 exécutions ou lors de l'appui sur le bouton
STOP. Un opérateur logique (Fonctions>>Arithmétique>>Booléen) et une comparaison (reliée à
l’itération de boucle) sont nécessaires (Fonctions>>Arithmétique >>Comparaison).
4. Registre à décalage : Réaliser une rampe par 100.
Algorithme : Faire {Sß S+1 ; si(S>99) Sß 0 ; Sinon Sß S ;} tant que {numéro de boucle < 1000 ;}.
La valeur S passe d’une itération de la boucle à la suivante au moyen d’un registre à décalage sur le
bord de la boucle et l’initialiser à zéro.
5. Auto-indexation : résultat dans un indicateur de type tableau
Pour réaliser le passage dans un tableau des valeurs successives calculées dans la boucle while, il faut
tirer un fil jusqu’au bord de la boucle, faire un click droit pour faire apparaître un menu déroulant,
sélectionner l’indexation. En cliquant droit dessus, on crée un indicateur.
6. Créer un graphique sur la face avant à partir de l’indicateur
Afficher le graphique et compter le nombre de dent de scie.

C. Programmation de la carte entrées-sorties numériques
1. Measurement Automation
eXplorer
Vérifier le fonctionnement de la carte analogique et
logique en utilisant le logiciel MAX. Nous vous
demandons de vérifier que les entrées analogiques sont
en mode référencé et non en mode différentiel. Voir la
notice de la carte d’entrées-sorties.
2. Programmer une tension analogique en sortie sous MAX

Créer une tçache sous Max permettant de programmer une valeur analogique sur la platine de sortie au
travers de la carte USB NI6009. En mode test sous MAX, exécuter cette tâche et programmer la
ension analogique à 3 Volts. Vérifier avec un oscilloscope la valeur de la sortie correspondante.
Brancher cette sortie sur la carte de conversion-comparaison en entrée du comparateur.
3. Programmer un mot de huit bits sur un port numérique sous Labview
En utilisant la bibliothèque polymorphe DAQMX sous Labview, envoyer les huit valeurs binaires
correspondant au compteur sur sur la platine de sortie au travers de la carte USB NI6009.. Brancher la
carte de conversion-comparaison avec la nappe. Observer à l’oscillo la sortie du Convertisseur
Numérique Analogique et la sortie du comparateur sur la carte IUT_CAN.
Carte_IUT_CAN
Sortie CNA
analogique
Entrée du
Platine de Comparateur comparateur
connexions
Convertisseur
Logiciels de traitement D7 D0 Sortie comparateur

compatible TTL
4. Récupérer une valeur binaire numérique sous Labview

Récupérer la sortie du comparateur dans une entrée numérique PI.1 en utilisant la bibliothèque
polymorphe DAQMX sous Labview. Programmer l’arrêt de la boucle incrémentant le compteur quand
le comparateur bascule.
5. Acquérir les valeurs d’un accéléromètre 3 axes qui oscille, lié à un pendule.
Brancher le capteur accéléromètre 3 axes sur les entrées analogiques de la carte de conversion NI
6009. Préciser une fréquence d’acquisition et un nombre de points compatible avec la carte
d’acquisition. Lancer l’acquisition. Afficher les résultats dans un graphe.

D. Structure CONDITION
Le but de cet exercice est d’afficher "résultat positif ou nul" ou "résultat négatif" en fonction du
résultat d'une soustraction. Ceci nécessite l'utilisation de chaînes de caractères et de la structure
condition. L'algorithme est le suivant :
Faire
S← A-B
si S≥0 afficher "résultat positif ou nul"
sinon afficher "résultat négatif"
Tant que stop faux
• Réaliser la soustraction de deux nombres réels.
• Amener la structure Condition (Fonctions>>Contrôle d’exécution>>Structure condition). Son
test d'entrée est fait par un booléen noté « ?» qui recevra le résultat de la comparaison. On peut
faire apparaître la case Vrai ou Faux en cliquant sur un triangle de la petite fenêtre.
• Dans chacun des cas, il faut introduire une chaîne de caractères, obtenue en sélectionnant
Fonctions>>Toutes les fonctions>>Chaîne>>Constante Chaîne. Entrer alors la chaîne
voulue. On constate sa couleur rose.
• Relier la première chaîne au bord droit de la structure. Un tunnel apparaît alors dont l'intérieur
reste blanc tant que la seconde chaîne n'y a pas été reliée.
• Relier la deuxième chaîne à ce tunnel ; celui-ci devient alors noir. Tout tunnel ainsi créé dans
une structure Condition doit être câblé dans le cas Vrai et dans le cas Faux.
• Créer un indicateur depuis le menu local du tunnel.
Carte_IUT_CAN
Sortie CNA Entrée du

analogique comparateur
Sortie comparateur
compatible TTL
D7 D0

Mesures physiques Matière : Informatique d’Instrumentation S2
Travaux pratiques n°2 Durée : 4h
Tableaux, tracés et Date : sem 33/2009
Entrées-sorties analogiques
Travaux pratiques n° 2 : Tableaux, tracés, Entrées-sorties

analogiques
A. Tableaux
1. Création d’un tableau à l’aide d’une boucle For et d’un tunnel
• Avec la Fonctionsà Arithmétiqueà Numérique « Nombre aléatoire », créer et afficher un
tableau de 20 nombres aléatoires compris entre –3 et +7.
2. Calcul progressif de la moyenne des éléments du tableau
• A l’aide d’un registre à décalage, calculer, à chaque tour de boucle, la somme des éléments
déjà présents dans le tableau. Puis, afficher la moyenne des éléments du tableau.
3. Programmer un train d’impulsion
• Programmer un train de 5 impulsions de + à -20Volts. Longueur de 10 échantillons. Le dernier
échantillon est à zéro.
•
B. Tracé d’une tension sinusoïdale simulée
• Créer un tableau contenant N valeurs de la fonction sinus
(Fonctionsà Numériqueà Trigonométrique) pour des valeurs d'angle comprises entre 0 et
2π*P, P étant le nombre de périodes. N, P et l'amplitude A sont fixés depuis la face avant.
• Tracer la courbe grâce à la fonction Graphe (Commandesà Graphe) en fonction des indices
du tableau.
• Tracer la courbe en fonction de la valeur de l'angle. Il faut alors créer un Cluster, grâce à la
fonction Assembler (Fonctionsà Cluster), contenant, dans l'ordre, la valeur à l'origine de
l'angle, le pas et le tableau de valeurs. Pensez à regarder l’aide.
C. Entrées-sorties analogiques
Une carte USB Ni6009 est raccordée au PC. Elle est
reliée à une platine afin de brancher des entrées sorties
numériques et analogiques. Cette carte dispose de 16
entrées analogiques, 2 sorties analogiques, différents
signaux de contrôle et des entrées-sorties numériques.
Tous les signaux ne sont pas câblés sur la platine. Voir
ci-dessous.
Logiciels de traitement

1. MAEx Convertisseur une voie Numérique Analogique DAC0
• Nous voulons utiliser la carte en mode DaqMx. On utilise le logiciel Measurement Automation
Explorer (MAX) pour vérifier que la carte est présente. E : en mode test, on envoie un signal
continu sur la sortie DAC0 que l’on mesure à l’oscilloscope. On utilise le logiciel
Measurement Automation Explorer (MAX) pour vérifier que la carte est présente. En mode
test, on envoie un signal continu sur la sortie DAC0 que l’on mesure à l’oscilloscope.
2. Labview : Convertisseur une voie Numérique Analogique
• On envoie la sinusoïde sur la sortie DAC0 à une fréquence d’échantillonnage de de 40 kHz.
Visualiser à l’oscillo et mesurer la fréquence correspondant à la périodicité du signal.
•
•
3. Convertisseur une voie Numérique Analogique DAC0 : Burst
• On envoie un train de 10 impulsions sur la sortie correspondant à une fréquence de 40 kHz.
Vérifier le fonctionnement du « Burst » à l’ocillo.
• On branche cette sortie sur un transducteur à ultrasons. On récupère un signal par réflexion sur
le deuxième transducteur. On visualise les deux voies à l’oscillo.
4. Acquisition des deux voies analogiques
• Faire un programme indépendant qui réalise l’acquisition simultanée des deux voies en tenant
compte des amplitudes et en synchronisant sur le début du Burst . (tâche DaqMX sous le
logiciel MAX ). Afficher le résultat avec un graphe sous Labview.
•
5. Etude d’une diode électroluminescente DEL
• Créer un signal binaire rampe sur 50 pas, pleine échelle à 256.
• L’envoyer sur la carte d’entrée sortie numérique USB NI6009.
• Branchez la nappe sur la carte IUT_CAN_LED.
• A chaque pas, récupérer la tension (en mode unipolaire) et le courant (en mode différentiel)
aux bornes de la LED sur la carte CARTE_IUT_CAN_LED par l’utilisation de la carte USB
NI6009.
• Effectuer les 50 pas et afficher le résultat dans un graphique.

Sortie tension aux
Carte_IUT_CAN bornes de la LED
Sortie CNA
analogique
Platine de
connexions
Convertisseur
Logiciels de traitement D7 D0
Mesure de courant dans la LED

en mode différentiel
Carte_IUT_CAN_LED
Sortie CNA
analogique
Sortie tension aux

bornes de la LED
D7 D0 Mesure de courant dans la LED

en mode différentiel
D. Création de tableaux avec des fonctions spécifiques

Pour cet exercice, vous ne devez pas utiliser la notion de tunnel. Vous devrez créer vos tableaux à
partir des fonctions de la palette « Fonctions>>Toutes les fonctions>>Tableau ».
• A l'aide d’une boucle For et de la fonction Nombre aléatoire, créer un tableau contenant N
nombres entiers compris entre 0 et 100. N doit pouvoir être fixé depuis la face avant. Vous
aurez besoin d’utiliser la notion de registre à décalage et d'appeler la fonction Construire un
tableau. A l’aide de l’outil « flèche », vous pouvez agrandir la taille de cette fonction afin
d’augmenter le nombre des entrées du tableau. Afin d’initialiser le registre à décalage, vous
devez utilisez la fonction Initialiser un tableau, en choisissant 0 comme valeur pour la
dimension 0.
• Compléter l'exercice précédent en séparant dans deux tableaux distincts les nombres pairs et
impairs.

E. Tracé d’une fonction sinus + bruit
• Tracer la fonction sinus + bruit avec un rapport de puissance du sinus par rapport au bruit de
20 dB, puis de 0dB. Des fonctions dans la bibliothèque de Labview fournissent la puissance
d’un signal.
• Réalisant un tracé où l’affichage se fait en continu des itérations de la boucle FOR.
F. Tracé d’une Cycloïde
• Tracer en fonction du temps une fonction sinus de période donnée, puis une deuxième fonction
sinus de fréquence triple.
• Réalisant un tracé où l’affichage se fait en continu des itérations de la boucle FOR et en
affichage de type X-Y ou nuage de points.

Durée : 4h
Travaux pratiques n°3 Date : sem 34

2009
Travaux pratiques n°3 : Circuit logique programmable sous ABEL

Objectif : Programmer un circuit logique
Carte CNA + comparateur 5V
programmable intégré à une carte électronique
avec un logiciel spécialisé en langage ABEL de
façon à expérimenter différents algorithmes de +
Ve
conversion analogique-numérique -
CNA
Le schéma ci-contre présente les connexions de Vcna
la carte IUT –CAN avec la carte contenant le
circuit de logique programmable. n
Le kit de développement de circuit Nappe

programmable est décrit en détail en annexe. La
programmation en langage ABEL est décrite
dans un fichier PDF sur le bureau du PC.
A. Conversion par rampes. Horloge pin 26 I/O3 pin 18
1. Visualisation du EPLD
fonctionnement Lattice
Recopier le dossier « CNA_CAN » sur 1096E n
Mes_documents et le renommer avec vos
initiales.
Ouvrir ISP_Lever_Navigator. Ouvrir le projet CAN (voir annexe 5). Visualiser la programmation du
composant, compiler le source, créer l’exécutable. Lancer le programme qui permet le téléchargement,
valider son fonctionnement en utilisant le bouton poussoir droit (pins 22 et 25 programmées en
circuit anti-rebond) comme « horloge manuelle » de façon à identifier les différentes phases du
fonctionnement, la sortie étant branchée sur la carte à LED.
2. Code pour afficheur 7 segments
Créer une table de vérité permettant de faire fonctionner l’afficheur 7 segments de droite. [voir les
numéros des broches en annexe 4]
3. Branchement de la carte de conversion
La carte « CNA+comparateur » est à relier par une nappe sur un des connecteurs 25 broches de la carte de logique programmable. Utiliser une entrée
Ve continue et la sortie Vcna "CNA" 0 V – 10 V. Vérifier le fonctionnement du comparateur et en particulier son niveau de sa sortie qui doit être compris
entre 0 V et 5 V. Le comparateur est relié à l'entrée I/03 (pin 18) au travers de la nappe.
Adapter le programme à un comptage sur 8 bits.
Vérifier le fonctionnement à l'oscilloscope en remplaçant l'entrée bouton poussoir par une horloge de
fréquence 10 kHz prise sur la sortie "TTL synchro" du générateur GBF. L'oscilloscope sera
synchronisé sur le front descendant de Vcna (instant où la rampe repasse de sa valeur max à 0 V).
Modifier le programme pour réaliser une rampe avec 8 bits de précision

4. Prise en compte du résultat du comparateur et affichage sur deux chiffres
hexadécimaux.
Adapter la table de vérité de façon à afficher le résultat "8 bits" sur les deux afficheurs 7 segments dès
que le comparateur commute. Le comptage générant la rampe doit aller jusqu'à sa valeur maximale.
"Input
comp pin 18 ;
"nœuds intermédiaires
r7,r6,r5,r4,r3,r2,r1,r0 node istype 'reg';
resultat = [r7,r6,r5,r4,r3,r2,r1,r0];
equations
resultat.clk=comp; "Stockage sur front montant
resultat:=cpt; "Valeur stockée
5. Limitation du temps de conversion

Modifier la programmation de façon que la rampe s'arrête dès que la valeur à convertir est atteinte.
B. Conversion par approximations successives

1. Visualisation du fonctionnement et programmation de rampes sur 8 bits
Mettre le programme « approx_4_bits » actif. Visualiser la programmation du composant et valider
son fonctionnement en utilisant le bouton poussoir droit (pin 26 et 27 à programmer en circuit anti-
rebond) comme « horloge manuelle » de façon à identifier les différentes phases du fonctionnement.
Utiliser une entrée Ve continue et la sortie Vcna "CNA" 0 V – 10 V.
Adapter le programme à une approximation sur 8 bits.
Vérifier le fonctionnement à l'oscilloscope en branchant une horloge de fréquence 10 kHz prise sur la
sortie "TTL " du générateur. L'oscilloscope sera synchronisé sur le front descendant de Vcna de
façon à être en début de conversion.
Choisir des valeurs qui conduisent à des fonctionnement "remarquables"(résultats 0xAA ou 0x55
et 0x0F ou 0xF0) et les imprimer.
2. Prise en compte de la résolution du CNA et affichage sur deux chiffres
décimaux.
La table de vérité conduisant à l'affichage en dixième de volt peut être calculée automatiquement par
une séquence de programmation dont l'exemple est donné.
Si valeur < seuil_0 alors chiffre=0 sinon si valeur < seuil-1 alors chiffre=1 sinon si valeur <
seuil-2 alors chiffre=2 …
Analyser cette séquence et adapter les seuils de façon que l'affichage corresponde exactement à celui
de la source de tension continue. La table de vérité (TruthTable) de transcodage hexadécimal sur les
deux afficheurs 7 segments est toujours utilisée. Il est nécessaire d'ajouter la commande du point
décimal sur l'afficheur de gauche.
3. Mise en évidence des limites du fonctionnement
Visualiser le fonctionnement à l'oscilloscope en faisant varier Ve. Prendre par exemple une variation
sinusoïdale de fréquence assez basse (10 à 50 Hz) , d'amplitude 4 V et d'offset 5 V.
L'oscilloscope sera synchronisé en externe sur la sortie "TTL synchro" du GBF.
Observer la première conversion et faire apparaître l'erreur due à l'absence d'échantillonneur-bloqueur
en faisant varier la fréquence et éventuellement l'offset.
Imprimer et commenter le résultat.

C. Annexe : Carte de logique programmable.
Afficheur 7 segments Afficheur 7 segments

gauche - sortie PLCC droit-sortie PLCC
a - 17 e-9 a-5 e - 43
b - 16 f-8 b-4 f - 42
c - 15 g-7 a c-3 g - 41
5V Masse 0V d - 10 point ( dp) - 6
f g b
d - 44 point ( dp) - 40
e c
d dp I/O 3
« pin » PLCC 18
Connecteur
bus vers carte CNA ou CAN
ou afficheurs - 3 chiffres
bus CNA : d7-d6-d5-d4-d3-d2-d1-
d0
sortie PLCC : 39-38-37-32-31-30-29-28
Circuit PLCC Lattice

isp LSI 1016E-80PLCC44 I/O 9 commun avec
bouton poussoir droit
« pin » PLCC 27
Bouton poussoir gauche
« pins » PLCC 22 et 25 Bouton poussoir droit
Connecteur PC « pins » PLCC 26 et 27
Interface parallèle
liaison avec logiciel ispLEVER
Le circuit logique est programmable directement sur la carte où il est utilisé. La carte est connectée à
une maquette comportant un circuit de conversion numérique-analogique (CNA) et un comparateur
déjà câblé.
Numéro des pattes contrôlant le CNA
On dispose sur la carte également de deux afficheurs à 7 segments en sorties.
Numéro des pattes contrôlant les afficheurs :
Afficheur gauche Afficheur droit a
a -> pin 17 a -> pin 5 f g b

b -> pin 16 b -> pin 4
c -> pin 15 c -> pin 3
e c
d -> pin 10 d -> pin 44
e -> pin 9 e -> pin 43
d
f -> pin 8 f -> pin 42
g -> pin 7 g -> pin 41
Point -> pin 6 Point -> pin 40
La programmation est faite par un PC à travers son interface parallèle sous le logiciel ISP-
LEVER

D. Annexe : Logiciel ISP-LEVER
1. Ouvrir le programme ISP-lever_navigator
2. Ouverture d’un projet

Open project
Se mettre dans le répertoire du projet. Ouvrir le projet : ***.syn. Enregistrer
Si le source n’apparaît pas , Double click sur Untitled : donner un descriptif du projet
Source New
Choisir ABEL-HDL Module
Remettre dans Module Name et File Name le nom du projet et écrire dans Title le
descriptif donné précédemment (facultatif)
3. Ecriture du programme en source Abel (voir ci-dessous)

Editer une fonction logique combinatoire
Declarations File Save
File Exit (on sort de l’éditeur)
Equations
Truth_table
END
4. Compilation du programme avec l’outil ISP

Sélectionner le nom du programme dans le volet gauche Le positionner en module actif (Clic droit), il
apparaît en gras. Dans le menu déroulant, lancer la compilation en double cliquant sur ‘Compile
logic’.
5. Programmation du composant cible avec l’outil ISP

Dans le volet gauche double-cliquer sur le symbole du composant. Si le composantsélectionner le
composant Lattice isp LSI 1016E-100PLCC44 (vérifier le nom sur le composant lui-même). Dans le
menu déroulant, lancer la création d’un exécutable en double cliquant sur « FIT Design ».
6. Lancer l’outil ISP de téléchargement du code exécutable sur la carte qui va

servir aux tests
Double cliquer sur le bouton de la barre des menus représentant un composant
Un nouveau logiciel se lance sur le PC : ISP VM System.
7. Téléchargement du code exécutable sur la carte

Configuration à bouton Scan (vérification de la liaison et reconnaissance du circuit)
Dans la fenêtre qui apparaît si le circuit est reconnu, il faut appuyer dans la case donnant le nom du
fichier à télécharger.
Appuyer sur Browse. Rechercher le fichier JEDEC que vous venez de créer : ***.jed .
Vérifier que l’opération par défaut est bien : Erase, Program & Verify
Cliquer sur le bouton « GO » Le transfert du fichier s’effectue via le câble parallèle ; Les DELs
vertes et jaunes de la carte doivent clignoter. Attendre la fin du téléchargement.
8. Exécuter le programme
Il peut être nécessaire de débrancher le câble de liaison pour que le programme fonctionne
correctement.

Durée : 4h
Date : sem 35/2009
Travaux pratiques n°4
Travaux pratiques n°4 robots en environnement WEBOTS1

A. Le logiciel Webots
Le but de ce TP est d'expérimenter des outils logiciels d'aide à la conception de système, en particulier
pour la programmation de robots. Vous utiliserez un outil de conception orienté automate d'état pour
contrôler les mouvements d'un robot : le simulateur Webots qui simule un robot se déplaçant dans un
monde virtuel ou télécharge un code s’exécutant sur le robot réel.
Figure 1: Robot e-puck. Figure 2a: Vue 1 du robot dans le monde virtuel.
Figure 2b: Vue 2 du robot dans le monde virtuel.
La figure 1 montre le robot e-puck que vous utiliserez. Ce robot embarque huit capteurs infrarouges
directionnels (capteurs de proximité), une caméra, et pour les dernières versions trois capteurs au sol.
Les figures 2 montrent le monde virtuel dans lequel va évoluer le robot. On remarquera les lignes
rouges et jaunes qui correspondent à la portée des capteurs de proximité implantés sur le robot, et les
deux lignes violettes qui indiquent les limites du champ de vision de la caméra, également embarquée
1
(S. Bouaziz, M. Fan, S. Le Hégarat, R. Reynaud) créateurs du TP

sur le robot. Ces capteurs permettront au robot de voir son environnement, d'éviter des obstacles ou
de suivre une trajectoire au sol, à condition que le programme de commande lui ordonne de le faire.
Votre travail se situe donc au niveau de la programmation du robot pour lui faire effectuer des
évitements d'obstacles ou bien des suivis de lignes noires par exemple.
1. Lancement de Webots
Double-cliquez sur l'icône de Webots sur le bureau. Deux fenêtres s'ouvrent. L'une avec le monde en
3D, c'est la fenêtre principale de Webots, l'autre avec le système de programmation BotStudio orienté
automate d'états. Le projet qui vous concerne est à l’emplacement ~Webots/projetcts/robots/e-
puck/controllers/obstacle/obstacle.bsg.
Si Webots et/ou BotStudio ne fonctionnent plus, fermez Webots et relancez le.

2. Visualisation du monde virtuel
Dans la fenêtre de visualisation du monde 3D, il est possible de changer le point de vue pour mieux voir la
scène. Le changement de point de vue s'effectue de plusieurs manières en utilisant la souris combinée avec les
touches Shift ou CTRL.
♦ Pour effectuer une rotation de la scène, il faut déplacer la souris en maintenant le bouton gauche de la
souris enfoncé.
♦ Pour effectuer une translation de la scène, il faut déplacer la souris en maintenant le bouton droit de la
souris enfoncé.
♦ Pour zoomer, il faut utiliser la molette de la souris.
Si vous êtes perdu dans l'espace 3D, sélectionnez Restore Initial Viewpoint dans le menu Edit.
3. Déplacement du robot dans le monde virtuel
♦ Pour déplacer le robot en translation, il faut presser la touche shift, cliquer sur le robot avec le
bouton gauche de la souris et déplacer la souris tout en maintenant la touche shift enfoncée.
♦ Pour déplacer le robot en rotation, if faut presser la touche shift et cliquer sur le robot avec le bouton
droit de la souris. Puis, cliquer à côté du robot avec le même bouton et déplacer la souris tout en
maintenant la touche shift enfoncée.
4. Programmer le robot à base d’automate de contrôle
La programmation du robot s'effectue grâce à la fenêtre Botstudio par la description de l'automate de contrôle
du robot. La figure 3 montre la fenêtre qu'il faudra utiliser pour programmer le robot.
Figure 3: fenêtre de programmation du robot.
L'icône permet de télécharger l'automate sur le robot virtuel ou réel (selon le port choisi : simulation ou
COMxxx).

Un état permet de donner des ordres aux roues pour avancer ou reculer. Les 2 roues du robot sont
indépendantes. Pour programmer un état, on programme la vitesse de chacune des roues. La figure 4 montre la
programmation d’un état ‘avancer’ (valeurs positives et égales pour les roues).
Figure 4: programmation d’un état. Figure 5: programmation d’une transition.

Les transitions permettent de changer d'état en fonction de conditions. Ces conditions sont liées par exemple :
- à la valeur des capteurs de proximité ;
- à la valeur de la caméra ;
- à la valeur de la temporisation.
La grandeur mesurée par le capteur de proximité est l’intensité infrarouge réfléchie par l’obstacle, qui est donc
d’autant plus élevée que l’obstacle est proche. Ainsi, lorsqu'un capteur de proximité a une valeur strictement
inférieure à 5, cela signifie qu'il ne voit pas d'obstacle. Lorsque cette valeur est supérieure ou égale à 5, cela
signifie qu'il y a un obstacle qui sera plus ou moins loin. Si on souhaite agir dès la présence d'un obstacle, on
utilisera la condition ‘strictement supérieur à 6’ par exemple. Une transition pourra contenir plusieurs
conditions sur différents capteurs en même temps. La figure 5 montre la programmation d’une transition
‘obstacle à gauche’ (valeurs à 5 pour les capteurs de proximité sur le coté gauche du robot).
Le capteur de vision permet d’acquérir des images qui sont traitées par un programme embarqué sur le robot.
Ce programme détecte les pixels de ‘noir’ au sol (lignes du bas de l’image), calcule le barycentre et renvoie sa
position par rapport au centre (en colonnes) de l’image. Ce capteur indique donc si une ligne noire est détectée
à gauche (valeurs négatives entre -10 et -1) ou à droite (valeurs positives de 1 à 10) de l’axe horizontal frontal
du robot.
B. Exercices
1. Faire s'arrêter le robot devant un obstacle
a) Créer 2 états, un ‘avancer’ et un autre ‘stopper’.
b) Relier ces deux états par une transition allant de ‘avancer’ vers ‘stopper’ et lui donner un nom.
c) Donner une condition sur la transition pour que l'automate change d'état s'il voit un obstacle devant. Les
capteurs utilisés sont les capteurs de proximité.
d) Sauvegarder le programme.
e) Effectuer une simulation.
f) Ajouter une condition permettant au robot de redémarrer s'il ne perçoit plus d'obstacle.
g) Sauvegarder.
2. Évitement d'obstacles
a) Faire avancer le robot ; lorsque qu'il perçoit un obstacle, le faire reculer pendant 2 secondes. Une
temporisation (par exemple 2 secondes) peut être spécifiée sur une transition entre deux états en cliquant
sur le chronomètre et en ajustant sa valeur (en dixièmes de seconde).
b) Sauvegarder le programme et tester en simulation.
c) Après avoir fait reculer le robot, le faire tourner pendant un temps à déterminer ; puis le faire repartir en
évitant à nouveau les obstacles. Sauvegarder, simuler.
d) Transférer le programme sur le robot réel.

3. Suivi de ligne
a) Programmer le robot pour qu'il suive une ligne noire tracée sur un sol blanc. On rappelle que le capteur
utilisé ici est la caméra.
b) Tester le programme en simulation, puis sur le robot réel.
c) On souhaite maintenant que le robot suive la ligne en allant le plus vite possible, c’est-à-dire notamment
en minimisant les enchaînements de changement de direction gauche-droite-gauche-etc…. On suppose
par ailleurs que les tournants sur la ligne peuvent avoir deux (et seulement deux) rayons de courbure.
Proposer une solution à 5 états.
d) Tester la solution précédente sur le robot réel.
4. Suivi de mur
a) Programmer le robot pour qu'il suive un mur. On ne précise pas le capteur utilisé.
b) Tester le programme en simulation, puis sur le robot réel.

Durée : 4h
Date : sem 36/2009
Travaux pratiques n°5
Travaux pratiques n°5 : Robot epuck pilotésous labview

On rappelle les différents modes de contrôle du robot epuck. On dispose de deux actionneur, les
moteurs pas à pas contrôlant la vitesse d’avancement de chacune des deux roues de façon
indépendante. On peut évidemment envoyer une succession de commande de vitesse des roues pour
obtenir une trajectoire pour le robot. Dans le TP à base d’automate de contrôle sous le logiciel
Webots, nous supposons être dans un état donné (correspondant à une vitesse d’avancement pour la
roue droite et la roue gauche) et nous y restons jusqu’à ce qu’une condition de sortie nous permette de
transiter dans un autre état (correspondant à une autre vitesse d’avancement pour la roue droite et la
roue gauche).
Il est relativement délicat de reprogrammer l’équivalent du contrôle d’automates d’état sous Labview,
mais nous pouvons imaginer contrôler la trajectoire du robot en utilisant le langage de programmation
SERCOM du robot EPUCK pour contrôler régulièrement la vitesse d’avancement pour la roue droite
et la roue gauche (D Vitesse_gauche, vitesse_droite) en maintenant la durée de la commande de telle
façon que l’on contrôle la trajectoire du robot.
A bas niveau le contrôle de la trajectoire sera défini par une succession de commande du type :
Vitesse_gauche, Vitesse_droite, Durée
A un niveau géométrique, une trajectoire sera définie par une succession de trois mouvements
simples : un mouvement rectiligne de longueur donnée ; un mouvement de rotation sur place à angle
de rotation donné ; un mouvement de contournement à angle de rotation et rayon de braquage donnés.
Le but du TP est de contrôler la trajectoire par enchaînement de mouvements simples différents après
avoir défini les trois mouvements simples.
A. Connecter le robot epuck avec le logiciel labview
1. Appairer un port série avec le robot au travers d’une liaison Bluetooth
Pour communiquer avec le robot, il faut utiliser une liaison sans fil de type Bluetooth. Les étapes
suivantes sont nécessaires :
1. Vous disposez d’une clé USB vers Bluetooth à brancher sur le PC. Pour des raisons techniques,
nous vous demandons de choisir la boite contenant la clé USB qui a déjà été installée sur votre
PC. Brancher la clé USB et vérifier que le périphérique Bluetooth a été correctement reconnu.
2. Le périphérique Bluetooth est déjà installé sur le robot. Ce type de liaison sans fils a pour but
d’autoriser des liaisons point à point dans un milieu hostile. En conséquence chaque périphérique
doit avoir un nom différent et un PIN-CODE pour autoriser la communication. Le périphérique a
pour nom e-puck _1234 et pour PIN-CODE 1234. Mettez le robot en marche.
3. Les deux bouts de la connexion point à point étant opérationnel, il faut réaliser la connexion.
Cliquer sur l’icône Bluetooth avec un click droit. Dans le menu déroulant qui apparaît choisir
« Paramètres Bluetooth ». La fenêtre ci-contre apparaît. Choisir le périphérique, l’un des e-puck
en faisant un click droit et appuyer sur « connecter » dans le menu déroulant. Rentrer le PIN-
CODE quand on vous le demande. Quand la connexion est réalisée, sélectionner le périphérique et
cliquer «détail… ». La connexion est établie et le port série virtuel que vous devez utiliser sous
VISA est affiché dans les détails.
2. Prise en main et test de fonctionnement du robot.

a) Lancer MAX
Vérifier la présence du port série virtuel que vous devez utiliser sous VISA.
b) Lancer le programme de test e-puck -monitor à partir de la liaison série

Lancer le programme de test Epuck-Monitor. Préciser le port série virtuel associé au robot par
Bluetooth. Etablir la communication. Vérifier que les principales fonctions que vous allez utiliser
sont opérationnelles.
3. Programmation sous LabView au travers de la liaison série
Dans le directory « TP_epuck», sélectionner le programme « Tp_epuck S2 ». Ouvrir le diagramme.
La programmation de ce composant se fait à l’aide d’une structure évènement dans laquelle des blocs
de programmes sont activés au moment où certains évènement à préciser ont lieu.
Vérifier que vous contrôlez à nouveau le robot au travers de l’interface Labview. Ce contrôle est
effectué au travers d’un langage de communication dénommé SERCOM. Vous devez imprimer dans
votre compte-rendu l’ensemble des blocs déjà programmés, préciser sur quel évènement un bloc est
activé.
B. Mouvement rectiligne uniforme de longueur donnée
1. Calcul préliminaire
La commande « D 300,300 » envoyée au robot signifie que les moteurs vont tourner à 300 tics par
seconde, sachant qu’il y a 1000 tics par tour, et que vous devez mesurer le rayon des roues (autour de
4cm de diamètres) pour calculer l’avancement effectué durant une durée de ∆T.
Longueur = V × ∆T
2. Programmer sous labview un évènement

Cet évènement fait avancer le robot dans un mouvement rectiligne uniforme de longueur donné, puis
le robot stoppe.
C. Mouvement rotation sur place d’angle donné
La commande « D 100,-100 » envoyée au robot signifie que les moteurs vont tourner à + ou - 300 tics
par seconde, sachant qu’il y a 1000 tics par tour, et que vous connaissait le rayon des roues (autour de
4cm de diamètres) et l’entraxe des roues (autour de 5cm) pour calculer l’avancement effectué durant
une durée de ∆T par chaque roue. Si on veut tourner d’un angle donné, on trouve la durée durant
laquelle on doit laisser tourner le robot.
Angle
2.
Longeur = Angle × Entraxe / 2 = V × ∆T

Programmer sous labview un 2ème évènement
Cet évènement fait avancer le robot dans un mouvement de rotation sur place d’angle donné, puis le
robot stoppe.
D. Mouvement de contournement circulaire

La commande « D Vitesse_gauche, vitesse_droite» envoyée au robot signifie que les moteurs vont
tourner à Vitesse_gauche ou vitesse_droite tics par seconde, sachant qu’il y a 1000 tics par tour, et que
vous connaissait le rayon des roues (autour de 4cm de diamètres), l’entraxe des roues (autour de 5cm)
et le rayon de braquage (à définir) pour calculer l’avancement effectué durant une durée de ∆T par
chaque roue. Si on veut contourner d’un angle donné à rayon de braquage, on obtient 2 équations à 3
inconnues dont on tire la durée durant laquelle on doit laisser tourner le robot.
Déplacement_Gauche = V_Gauche × ∆T = Angle × (Rayon + Entraxe / 2)

Déplacement_Droit = V_Droit × ∆T = Angle × (Rayon - Entraxe / 2)
Rayon de braquage
Angle
2. Programmer sous labview un 3ème évènement

Cet évènement fait avancer le robot dans un mouvement de contournement d’angle et de rayon de
braquage donnés, puis le robot stoppe.
E. Enchaînement de mouvements différents
1. Programmer sous labview un 3ème évènement

Cet événement lit un fichier décrivant une trajectoire et enchaîne les différentes actions.
Imprimer le fichier, et les commandes élémentaires.
2. Créer une trajectoire carrée
Cet événement lit un fichier décrivant une trajectoire et enchaîne les différentes actions.
Imprimer le fichier, et les commandes élémentaires.
3. Réaliser la trajectoire suivante
Contrôler la trajectoire du robot. Cet événement lit un fichier décrivant une trajectoire et
enchaîne les différentes actions. Imprimer le fichier, et les commandes élémentaires.
Rotation sur place -45°

Translation 10cm
Rotation sur place -45°
Translation 15cm

Contourner 7cm, 135°
Translation 12cm
Contourner 7cm,90)°
Translation 12cm
Contourner 7cm,45°

Informatique D'instrumentation

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

Informatique D'instrumentation

Transféré par

Droits d'auteur :

Formats disponibles

TP du Module

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Travaux pratiques n°1 : Apprentissage Labview +

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Travaux pratiques n°1 : Apprentissage Labview + Entrées-

Vous devez avoir lu le document « PRESENTATION DE LabVIEW ».

2 Créer une sortie ou indicateur nommé S (Commandes à Indicateurs

3 Amener dans la face diagramme la fonction Additionner (Fonctionsà Arithmétiqueà Express

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

2. Programmer une tension analogique en sortie sous MAX

Logiciels de traitement D7 D0 Sortie comparateur

4. Récupérer une valeur binaire numérique sous Labview

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Sortie CNA Entrée du

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Travaux pratiques n°2 Durée : 4h

Tableaux, tracés et Date : sem 33/2009

Travaux pratiques n° 2 : Tableaux, tracés, Entrées-sorties

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Mesure de courant dans la LED

Sortie tension aux

D7 D0 Mesure de courant dans la LED

D. Création de tableaux avec des fonctions spécifiques

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Travaux pratiques n°3 Date : sem 34

Travaux pratiques n°3 : Circuit logique programmable sous ABEL

Le kit de développement de circuit Nappe

Adapter le programme à un comptage sur 8 bits.

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

5. Limitation du temps de conversion

B. Conversion par approximations successives

Adapter le programme à une approximation sur 8 bits.

Imprimer et commenter le résultat.

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Afficheur 7 segments Afficheur 7 segments

Circuit PLCC Lattice

Numéro des pattes contrôlant le CNA

On dispose sur la carte également de deux afficheurs à 7 segments en sorties.

Numéro des pattes contrôlant les afficheurs :

Afficheur gauche Afficheur droit a

a -> pin 17 a -> pin 5 f g b

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

2. Ouverture d’un projet

3. Ecriture du programme en source Abel (voir ci-dessous)

4. Compilation du programme avec l’outil ISP

5. Programmation du composant cible avec l’outil ISP

6. Lancer l’outil ISP de téléchargement du code exécutable sur la carte qui va

7. Téléchargement du code exécutable sur la carte

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Travaux pratiques n°4 robots en environnement WEBOTS1

Figure 2b: Vue 2 du robot dans le monde virtuel.

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Si Webots et/ou BotStudio ne fonctionnent plus, fermez Webots et relancez le.

Figure 3: fenêtre de programmation du robot.

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

Figure 4: programmation d’un état. Figure 5: programmation d’une transition.

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com

PDF Creator - PDF4Free v2.0 http://www.pdf4free.com