Cours:StartMindstorm
Retour à la liste des Tps
Précision sur quelques logos dans les énoncés :
![]() |
Action à effectuer et comprendre sans besoin de compétences particulières |
![]() |
Problématique que vous devez résoudre |
Nous allons programmer la brique levo mindstorm EV3 à l'aide de l'ensemble logiciel c4ev3.
Vous pourrez bien entendu utiliser votre ordinateur Windows/Linux/Mac à condition d'avoir mené à bien l'ensemble des configurations nécessaires.
Nous utiliserons l'IDE éclipse pour l'édition, la compilation, le téléchargement ainsi que l'exécution des programmes.
Prise en main d'éclipse
Eclipse fonctionne à l'aide de projet : chaque fois que vous souhaitez écrire un nouveau programme, il convient d'en faire un nouveau.
Nouveau projet
Voici les étapes nécessaires à la bonne configuration d'un projet pour programmer la brique EV3 :
- File>New>C Project ... ça doit vouloir dire faire un nouveau projet en langage C !
- 1ère fenêtre :
- choisir un nom pour le projet : tp1
- projet de type : Executable/Hello World EV3 Project
- Toolchains : Cross ARM/EV3 GCC (votre ordinateur est une architecture x86_64, la brique EV3 comme la plupart des smartphones une architecture ARM => ce n'est pas la même chose on fait de la cross-compilation)
- Suivant, enfin NEXT plutôt !
- 2ème fenêtre, il faut vérifier :
- API path : /opt/lego/EV3-API/API
- Upload path : SD-Card
- Source : src
- NEXT
- 3ème fenêtre :
- on décoche debug
- on garde Release
- NEXT
- 4ème fenêtre, il suffit normalement de vérifier :
- Toolchain name : Linaro ARM Linux GNU EABI (arm-linux-gnueabi-gcc)
- Toolchain path :
- EV3 Uploader : /usr/lib/ev3duder
- FINISH
Compilation/Exécution
Le code source du programme "minimum" devrait s'afficher à l'écran. Sinon, on le retrouve à gauche dans l'arborescence du projet dans le projet que l'on vient de créer, dans le dossier "src", par exemple "tp1.c" :
#include <ev3.h>
int main(void)
{
//TODO Place here your variables
InitEV3();
//TODO Place here your code
LcdPrintf(1, "Hello World!\n");
Wait(SEC_2);
FreeEV3();
return 0;
}
Avant d'expliquer plus en détail ce programme, nous allons :
- le compiler :
- dans la barre d'icône au dessus de l'écran
- l'icône en forme de marteau : build
- on vérifie en bas de l'écran dans l'onglet "console" que tout s'est bien déroulé.
- on vérifie qu'il n'y a pas d'astérisque (*), à côté du nom du fichier, par ex tp1.c*
- si c'est le cas, il faut sauvegarder le fichier et recommencer
- Un robot connecté en USB et démarré ça pourrait servir maintenant !
- Exécution du programme
- barre de menu
- EV3>Upload and run ... je vous laisse traduire !
- On regarde l'écran, on doit voir le message "Hello World!"
Le programme :
Quelques explications sur le programme maintenant :
- On doit nécessairement écrire une fonction "main"
- elle est exécutée au lancement du programme
- int main(void) :
- elle retourne une valeur de type entier
- la valeur est récupérée à la fermeture du programme
- si la valeur est 0, tout s'est bien passé
- sinon la valeur représente un code d'erreur
- int main(void) :
- on ne passe pas de paramètre à la fonction main
- on peut aussi écrire : int main()
- { : la déclaration de la fonction main commence juste après l'accolade ouvrante
- } : la déclaration de la fonction main se termine juste avant l'accolade fermante
- return 0;
- on quitte la fonction (main ici) en envoyant la valeur 0 : tout s'est bien passé.
- si on ajoute des lignes après "return", elles ne seront pas exécutées
- Le reste du programme correspond à l'exécution de fonctions :
- il y a toujours des parenthèses après le nom d'une fonction
- il peut y avoir des valeurs entre les parenthèses : ce sont des paramètres
- InitEV3() : fonction d'initialisation des moteurs/capteurs ...
- FreeEV3() : pour remettre la brique lego dans un état "normal" à la fermeture
Etude de la fonction LcdPrintf
Les fonctions de la librairie c4ev3 sont détaillées et accessibles sur cette page.
Vous devrez par la suite la consulter régulièrement, il n'est pas question de retenir le nom ni l'usage des fonctions mais juste de savoir exploiter une documentation.
Par commodité, la fonction LcdPrintf est donnée ci-dessous :
Syntaxe | LcdPrintf(couleur,texte) | ||||
---|---|---|---|---|---|
Paramètres |
|
Modifier votre programme pour afficher le message suivant :
Informatique S1 TP1 - prise en main utilisation de la fonction LcdPrintf
LcdPrintf(1, "debut");
LcdPrintf(1, "suite");
|
Ce n'est ici qu'un aperçu de cette fonction LcdPrintf, nous y reviendrons progressivement.
Police de caractère
Un petit bonus : on peut changer la tailler de la police à l'aide de la fonction LcdSelectFont :
Syntaxe | LcdSelectFont(taille) | ||
---|---|---|---|
Paramètres |
|
Voici les tailles obtenues en fonction de la valeur du paramètre :
Valeur du paramètre taille | Largeur police | Hauteur police | symbolique |
---|---|---|---|
0 | 9 px | 8 px | FONTTYPE_NORMAL |
1 | 8 px | 8 px | FONTTYPE_SMALL |
2 | 16 px | 16 px | FONTTYPE_LARGE |
3 | 7 px | 5 px | FONTTYPE_TINY |
Observer les différentes tailles de police possible.
Modifier votre programme pour que chaque ligne du texte affiché soit d'une taille différente :
Informatique S1 TP1 - prise en main utilisation de la fonction LcdPrintf
moteur ... action !
Nous allons utiliser les 3 fonctions suivantes pour piloter les moteurs du robot :
Syntaxe | OnFwdReg (output,speed) | ||||
---|---|---|---|---|---|
Description | Mettre en rotation le moteur dans le sens + | ||||
Paramètres |
|
Syntaxe | OnRevReg (output,speed) | ||||
---|---|---|---|---|---|
Description | Mettre en rotation le moteur dans le sens - | ||||
Paramètres |
|
Syntaxe | Off(output) | ||
---|---|---|---|
Description | arrêter le moteur | ||
Paramètres |
|
Le paramètre output peut prendre l'une des valeurs indiquées dans le tableau suivant :
valeur pour output | Description |
---|---|
OUT_A ou OUT_B ou OUT_C ou OUT_D | modifier la vitesse d'une seule sortie (A, B, C ou D) |
OUT_AB ou OUT_AC ou OUT_AD OUT_BC ou OUT_BD ou OUT_CD |
mettre la même vitesse sur un couple de sortie |
OUT_ABC ou OUT_BCD | mettre la même vitesse sur 3 sorties |
OUT_ABCD ou OUT_ALL | changer la vitesse des 4 sorties |
premier pas
******************************************* ******************************************* *** ATTENTION AUX CHUTES DE ROBOT *** ******************************************* *******************************************
Voici la correspondance entre le nom de la sortie et le rôle du moteur pour le robot :
sortie | A | B | C | D |
---|---|---|---|---|
emplacement | bras | moteur Gauche | moteur Droit | --- |
#include <ev3.h>
int main(void)
{
InitEV3();
OnFwdReg(OUT_C,20);
FreeEV3();
return 0;
}
... et constater que le moteur de la sortie C .... ne tourne pas !!
Eh oui :
- on initialise le robot
- on change la vitesse du moteur C
- on arrête le robot => du coup le moteur s'arrête
il manque donc une pause, oui oui c'est ça la fonction Wait(duree_ms)
Ajouter une pause et faire tourner le moteur
Vérifier chaque moteur individuellement
Modifier le sens de rotation, il faut utiliser une autre fonction !!
un trajet
ligne droite
Rien de bien compliqué, il faut mettre les 2 moteurs à la même vitesse et attendre que àa se passe !
- fait avancer le robot de 40cm en ligne droite
- puis le fait reculer de 20cm, toujours en ligne droite
rotation sur place
Pour tourner sur place, les 2 roues doivent tourner en sens opposé avec la même valeur de vitesse.
Faire tourner votre robot sur place
cercle
On souhaite maintenant que le robot se déplace sur une trajectoire circulaire.
Les vitesses des 2 roues doivent donc être différentes.
Plus la différence de vitesse est grande, plus le rayon de courbure sera petit, et inversement bien sûr.
Ecrire un programme qui déplace votre robot sur un cercle dont vous modifierez le rayon de courbure.
mesure
Un peu de rigueur ne fait pas de mal :
On sait (par expérimentation) qu'à la "vitesse de rotation Wr" 20, le robot parcourt une distance de 7065mm en 70000ms.
Wr = k * d / t => k=198,16
Une deuxième expérience permet de calculer l'écartement des roues :
- Wr=20
- durée = 70000ms
- rotation effectuée = 7884° = 137,6 rad
L'écartement des roues étant de 103mm, on peut calculer la longueur de l'arc de cercle que doit parcourir les roues pour faire un 1/4 de tour.
On souhaite effectuer cette rotation avec Wr=20.
Calculer le temps de rotation nécessaire et vérifier par expérimentation
forme géométrique
On souhaite faire décrire à la trajectoire du robot une forme géométrique.
On commence par un carré, dont le côté sera de 100mm.
Ecrire un programme répondant à ce cahier des charges
Modifier votre programme pour avoir un carré de côté 200mm.
On constate que la même valeur apparaît plusieurs fois dans le programme et il est important de la modifier partout lorsque l'on souhaite changer la taille !
D'où la notion de variable
On choisira ici :
- le nom de variable : dureeCote
- pas d'accents
- pas d'espaces
- un nom représentatif de son usage
- un type : int
- c'est un nombre entier
- signé (positif ou négatif)
- nous verrons plus tard les nombres non signés
- on affecte une valeur initiale, par exemple 100
- on remplace la valeur par le nom de la variable
exemple :
#include <ev3.h>
int main(void)
{
int dureeCote = 100;
InitEV3();
OnFwdReg(OUT_BC,20);
Wait(dureeCote);
Off(OUT_BC);
FreeEV3();
return 0;
}
modifier votre programme pour supprimer les valeurs numériques dans les appels de fonction