Вы находитесь на странице: 1из 23

CARNANDET Christophe

REIBEL Thomas

RAPPORT DE PROJET

LEGO MINDSTORMS
Le chariot pendule

- Licence EEA-
2004/2005

REIBEL Thomas
CARNANDET Christophe
Page 1 sur 23 Projet Chariot pendule
CARNANDET Christophe
REIBEL Thomas

Remerciements

La ralisation de ce projet naurait pas t possible sans la participation et laide de Mr


Urban, professeur responsable de ce projet, qui nous a guid tout au long de notre tude.

Nous tenons galement remercier Mr Buessler pour son aide dans la partie
informatique et sa patience.

Mme Woesteland nous a galement apport son aide indispensable pour le rsum en
Anglais et nous len remercions.

Nous remercions toute personne ayant collabore dune faon quelconque


llaboration du projet dcrit dans ce rapport.

Page 2 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Sommaire

Remerciements............................................................................................................................2

Introduction.................................................................................................................................4

I) Les Legos Mindstorms............................................................................................................5


1.1. Capteurs et actionneurs....................................................................................................5
1.2. Le RCX :..........................................................................................................................5
1.3. La communication avec le RCX......................................................................................6
1.4. Le langage de programmation utilis par Lego...............................................................7

II) LegOS/Brickos.......................................................................................................................9
2.1. Prsentation :....................................................................................................................9
2.2. Voici dautres logiciels quivalents :.............................................................................10
2.3. Compilation vers BrickOS :...........................................................................................10
2.4. Installation de BrickOS :................................................................................................11

III) Le chariot pendule..............................................................................................................11


3.1. Description lmentaire.................................................................................................11
3.2. Fonctionnement du systme...........................................................................................14
3.3. Les fonctions utilises dans le programme....................................................................15
3.4. Analyse des donnes......................................................................................................17

Conclusion................................................................................................................................19

ANNEXE..................................................................................................................................20

English report of Reibel Thomas..............................................................................................22


Summary of the project of Carnandet Christophe....................................................................23

Page 3 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Introduction

Nous sommes actuellement en Licence EEA luniversit de Haute Alsace la FST de


Mulhouse. Et dans le cadre de nos tudes, il nous a t propos de raliser un projet
correspondant notre domaine. Dans ce rapport nous vous prsenterons notre tude qui porte
sur les Lego Mindstorms.

Ce projet qui nous a t confi par monsieur Urban, professeur dautomatisme au


laboratoire TROP, consiste en un asservissement de position et plus exactement celui dun
pendule mont sur un chariot.

Dans un premier temps nous vous prsenterons les Lego Mindstorms qui nous ont t
mis disposition par un kit RIS qui regroupe tous les lments ncessaires la ralisation du
robot.
Par la suite nous vous dcrirons plus en dtail le cerveau du robot savoir le RCX
ainsi que les diffrents capteurs et actionneurs quil peut commander.

Dans un deuxime temps nous vous ferons dcouvrir le langage utilis habituellement
par Lego Mindstorm pour programmer les diffrents robots dcrits dans le manuel du kit.
A travers ce chapitre nous verrons que dautres langages permettent doptimiser les
possibilits de programmation dont Bickos fait partie.

Nous expliquerons ensuite le cheminement accompli ainsi que les difficults et


problmes rencontrs pour arriver au projet final ainsi que son principe de fonctionnement.

Page 4 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

I) Les Legos Mindstorms


Pour ce projet nous avons utilis les Legos Mindstorms prsents sous forme dun kit
appel RIS . La particularit de ces Legos est quils permettent de concevoir des robots
programmables. Pour ce faire le kit comporte diffrents actionneurs et capteurs commands
par une brique appele RCX comportant un microcontrleur.

1.1. Capteurs et actionneurs

Voici la prsentation des capteurs et actionneurs les plus utiliss.

1.3.1. Les moteurs :


Les moteurs sont livrs dans le Kit RIS. Ils permettent plusieurs vitesses de rotation.
Ce qui permet daffiner le contrle des moteurs.

1.3.2. Capteur de contact :


Retourne une valeur binaire selon que le contact est enfonc ou non.

1.3.3. Capteur de rotation :


Permet de grer les mouvements du robot de manire plus volue quune gestion
simple des deux moteurs. Cette technologie permet de dterminer le sens de rotation ainsi que
lamplitude des rotations effectues par une roue. Ce capteur permet de mesurer une rotation
de 1/16ime de tour, ce qui correspond une prcision de 22,5.

1.3.4 Capteur de Luminosit :


Permet de mesurer lintensit lumineuse. Le capteur possde une petite LED
infrarouge qui illumine la scne devant lui et une photodiode qui mesure lintensit
lumineuse. Sa valeur varie de 0 1024.

1.2. Le RCX :

Le RCX (Robotic Command eXplorer) est un microcontrleur programmable. Il fut


dvelopp conjointement par LEGO et le Massachusetts Institute of Technology lors dune
tude de lapprentissage de linformatique aux enfants. Il permet de crer des programmes de
contrle qui gre les priphriques intgrs du RCX. On distingue parmi les priphriques, les
priphriques internes tel que les 3 entres et 3 sorties, lcran LCD, les boutons, le haut
parleur et les priphriques externes comme les capteurs et actionneurs.

Le RCX est compos de :


De 3 entres pour les diffrents capteurs tel que les capteurs de contact ou bien les
capteurs dintensit de lumire ;
De 3 sorties pour les moteurs ;

Page 5 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Dun affichage digital qui nous permet de contrler certaines valeurs telles que la
puissance de la batterie, les valeurs des diffrents capteurs... Cet affichage est aussi
trs utile pour le dboguage de certains programmes ;
Dun port infrarouge qui permet de tlcharger les programmes et dchanger des
donnes avec lordinateur lors dune application ;
De 32 Ko de mmoire RAM ;
Dun processeur Hitachi.

Port infrarouge

3 entres
Affichage
digital (LCD)

3 sorties

Analyse de la mmoire du RCX :


La mmoire du RCX est dcompose en plusieurs zones.
Dans la RAM de 32 Ko, la mmoire programmable totale vaut 28 Ko car 4 Ko sont
rservs aux routines de gestions des priphriques RCX. Cette mmoire programmable est
galement partage entre le systme dexploitation et les programmes utilisateur.
Schma de lorganisation de la mmoire :

Mmoire programme Routine pour


Utilisateur priphriques RCX RAM 32 Ko

Mmoire programme RCX excutif.

ROM 16 Ko
Firmware de dmarrage

1.3. La communication avec le RCX

La communication entre un ordinateur et le RCX se fait au moyen dun port infrarouge


(IR). Il sagit dune communication half- duplex, en effet le rcepteur IR est satur pendant

Page 6 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

que lmetteur fonctionne. Le RCX utilise une porteuse 38 kHz, cependant le rcepteur est
accord sur une modulation de 76 kHz, ce qui permet la compatibilit entre les produits Lego
les plus anciens et les plus rcents. Le dbit est de 2400 bps, cest dire toutes les 417 s ce
qui se rapproche des tlcommandes pour tlviseur.

La communication se fait en mode matre- esclave o le RCX est un esclave. Chaque


donne est transporte dans un paquet. On encode avec un code NRZ (No Return to Zero), la
trame est constitue dun bit de start, huit bits de donnes, un bit de parit et un bit de stop (ce
qui correspond au schma classique dune liaison RS232).

Quatre niveaux de communication sont mis en uvre :


La commande : ce niveau de communication permet denvoyer des commandes aux
RCX ou de recevoir des requtes ;
Le paquet : tout type de donnes est encapsul dans un paquet constitu dune entte,
des bits de donnes dont chaque octet est suivi de son complment, un checksum qui
correspond la somme de tous les octets et qui est lui aussi suivi de son complment ;
La liaison RS232 : elle est constitue dune liste des diffrents changes relatifs une
communication srie (ex : Receive Data- RCX->PC, Transmit Data- PC->RCX, etc.) ;
La transmission : un 0 est cod par un pulse de 417 s une frquence de 38 kHz,
pour un 1 la frquence est nulle ;

Lutilisation de lIR pour communiquer des donnes au RCX pose des problmes, en
effet la perte de paquet arrive frquemment. Les rayons infrarouges ne pouvant pntrer des
objets opaques, ce systme est trs directif et la tour USB et le capteur du RCX doivent tre
en vue directe une distance infrieure un mtre.

1.4. Le langage de programmation utilis par Lego

Pendant les premires semaines nous avons commenc par installer notre poste de
travail puis par dcouvrir le langage de programmation utilis par Lego, cest cette partie qui
va tre prsente dans ce chapitre.

Il est tout dabord utile de prciser que tout au long du projet, nous avons rencontr
diverses difficults qui nous ont considrablement ralenti dans notre avancement :
Des problmes dcran et de lecteur de CD-ROM que nous avons d changer
lun comme lautre ;
Des problmes avec la tour Lego (lmetteur permettant de tlcharger les
programmes vers le RCX) ;
Divers problmes avec le PC au cours des diffrentes sances qui nous ont
conduit devoir changer plusieurs fois de PC et devoir tout rinstaller: fichier uxtheme.dll
introuvable , des ralentissements considrables, etc. ;

Ceci tant dit, nous allons maintenant vous prsenter le travail ralis au cours de ces
diffrentes sances.

Nous avons ainsi commenc par effectuer les MISSIONS, qui sont en fait un tutorial.
La programmation seffectue sous forme de blocs qui ont chacun une fonction prcise. Il
existe des petits blocs, qui correspondent aux fonctions de bases (moteur droit activ,

Page 7 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

attendre,etc.), et des gros blocs, qui correspondent en fait un ensemble de petits blocs
(avancer pendant 3 secondes, faire danser le robot pendant 4 secondes,etc.). On peut rajouter
des fonctions si on choisit dajouter des capteurs, il faut alors choisir dans quel tat doit tre le
capteur pour que la fonction sexcute.

Une fois le programme ralis, il faut le tlcharger sur le robot et le lancer.

Nous avons ensuite commenc la partie CHALLENGE o un certain nombre dactions


raliser par le robot sont dcrites et o le but est de programmer ces actions.
Ainsi nous avons ralis 3 robots :
Loverbot : les challenges consistaient grer les capteurs positionns sur un
pare-choc simple (un capteur) puis sur un pare-choc double (deux capteurs). Nous avons
galement utilis un capteur de lumire pour que le robot soit capable de suivre une ligne
noire ou encore de jouer de la musique en fonction de la luminosit.
Le roverbot :

Nous lavons utilis pour tester la gestion des diffrentes fonctionnalits de


commandes des moteurs.
Linventorbot : les challenges consistaient principalement grer les chronos,
le temps ainsi que de nous perfectionner dans la gestion de certains blocs trs peu utiliss
jusqu maintenant que sont les blocs OUI-NON, ATTENDRE JUSQU'A, TANT QUE et
certains autres utiliss dans un contexte diffrent que ceux rencontrs prcdemment.

Page 8 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Au cours de ces exercices nous avons pu observer que ce langage convenait


parfaitement pour des tches simples et prdfinies. En revanche pour des systmes plus
complexes ou non prvues par Lego, la programmation semble plus complexe. Cest pourquoi
nous avons choisit dutiliser un systme de programmation qui nous permet de dvelopper nos
programmes de faon moins complique.

II) LegOS/Brickos

2.1. Prsentation :

Pour programmer le RCX prsent prcdemment, il existe plusieurs systmes


dexploitation. Nous avons vu que le langage de programmation donne avec les LEGO
MINDSTORMS tait simple mais limit.
Afin de remdier ce problme nous avons dcid dopter pour un OS plus
performant tel que le BRICKOS qui offre un bon compromis entre souplesse dutilisation et
efficacit.

Brickos est en faite une amlioration de LegOS qui est un des premiers langages
destins au RCX. LegOS a t dvelopp par Markus Noga dans les annes 90. Il est
multitche et permet le chargement dynamique de programmes grce linterface infrarouge.
Ce systme dexploitation gre galement lensemble des Entres/sorties du RCX. Il fournit
une librairie permettant de remplacer le firmware de la brique par un OS plus puissant. Le
code de programmation est crit en langage C/C++.

Les diffrents avantages de LegOS/BrickOS :


- un OS puissant alternatif au firmware standard,
- davantage de place en mmoire disponible,
- un protocole de communication,
- un ensemble de librairies,
- la possibilit de faire du multitches sans premption,

Page 9 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

- une gestion dynamique de la mmoire.

2.2. Voici dautres logiciels quivalents :

code RCX LeJOS NQC brickOS pbForth


Not Quite
Langage Graphique Java C C/C++ Forth

Remplacement non
du firmware disponible oui non Oui oui
Nombres en
point flottant non oui non Non non

Affichage
programmable non oui non Oui oui
Trigonomtrie
et
mathmatique
avances non oui non Non non
Langage
interprt oui oui oui Non oui

2.3. Compilation vers BrickOS :

Le compilateur est charg de transformer le programme C/C++ en format BrickOS par


lintermdiaire dun compilateur crois gcc (appeler par la commandes make depuis
linterprteur de commandes Unix Cygwin). Pour cela il cre partir du programme en C/C+
+ un fichier avec lextension .lx . Le fichier .lx qui est un fichier binaire, est charg dans la
brique grce la commande dll qui les transfre par lintermdiaire des ports infrarouges
du PC vers la Brique. Mais avant de transfrer le programme de lutilisateur il faut charger
lOS. Ceci seffectue grce la commande firmdl3 .

Schema de la compilation vers Brickos :

Programme.c Programme.lx
Progamme.h Compilateur Programme.o dll
make

firmdl3

LegOS.srec

Cependant LOS, le compilateur et les outils de chargement de code sur le RCX ont t
dvelopps sur une plate-forme Unix. Il faut donc interprter les commandes pour pouvoir les
utiliser sous Microsoft Windows. On utilise pour cela le logiciel Cyqwin32.

Page 10 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

2.4. Installation de BrickOS :

Etape 1 : installation de Cygwin, linterprteur Unix sous Windows.


o Excuter le fichier Cygwin.exe et suivre les instructions.

Etape 2 : Installation du compilateur crois pour Hitachi-H8.


o Dcompresser le fichier lego-buildgcc.zip dans le rpertoire build que vous
crez vous mme.
$ cd /build/buildgcc.sh

Etape 3 : Installation de Brickos0.9.0


o Copier le fichier dans le rpertoire cygwin.
$ tar xvfz brickos-0.9.0.tar.gz
o Renommer le rpertoire crer brickos-0.9.0 en brickos .
o Compilation de BrickOS :
$ cd /brickOS
$ ./configure; make
$ cd util
$ make strip

Etape 4 : Tlchargement de lOS :


$ ./firmdl3 ../boot/brickOS.srec
o Avant de transfrer le systme dexploitation il faut dfinir le port dutilisation
de la tour mettrice. (Pour nous port USB)
$ export RCXTTY=USB

Linstallation de ce logiciel nous a pos plusieurs problmes, en effet pour des raisons
que nous ignorons, lorsque nous allumions le PC, il arrivait parfois quil soit dfectueux et
que lon doive le rinstaller et ce plusieurs fois (une vingtaine environ).

III) Le chariot pendule

3.1. Description lmentaire

Notre projet consiste faire bouger le chariot de telle sorte que le balancement du
pendule cesse de faon plus rapide que son balancement normal.
Nous avons dabord ralis le robot avec les Legos Mindstorms mis notre disposition.

Voici la reprsentation du robot :

Page 11 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Comme nous pouvons lobserver sur cette image, le robot est constitu de plusieurs
lments dont voici les dtails :

Le capteur dangle :
Pour obtenir linformation de langle du pendule, le capteur qui nous intresse serait le
capteur de rotation Lego. Cependant, ce capteur peut seulement mesurer en incrmentant de
360/16=22.5 degr. Cette prcision tant insuffisante, nous utiliserons un potentiomtre de
meilleure qualit (de valeur maximal de 10k) coll une bride standard de LEGO et
lectriquement connect au RCX.
Ce potentiomtre est utilis au point de suspension du pendule. Le logiciel convertit ce
signal en mouvement horizontale du pendule not yp.

Le capteur de vitesse :
Comme il ny a pas de capteur de vitesse standard fournit, nous utilisons donc un
moteur DC qui, en fonctionnement gnratrice, produit une tension proportionnelle sa

Page 12 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

vitesse de rotation. Nous avons galement rajout une rsistance de 10k afin de linariser la
mesure ralise.
Ce moteur est coupl un des moteurs conducteurs au moyen dun rapport de vitesse
de 24/40=0,6.

Le frein lectrodynamique :
Il sagit dun moteur DC court-circuit, reli mcaniquement au moteur
dentranement, qui fonctionne comme un frein lectrodynamique. Ce frein fait de la roue
dente une rsistance mcanique linaire dont le couple est proportionnel la vitesse
angulaire.

Le capteur de rotation :
Il sagit du capteur de rotation standard de Lego, il est coupl aux moteurs par un
rapport de vitesse de 24/16=1,5. Le logiciel convertit ce signal en position linaire du chariot
note yc.

Voici une vue dtaille des diffrents lments monts directement sur le chariot :

Page 13 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

3.2. Fonctionnement du systme.

Le but du systme est de stabiliser le pendule et donc de corriger son dplacement


lorsque celui-ci est en mouvement. Le pendule est stabilis par le dplacement du chariot.
Pour diminuer ce dplacement, le robot effectue plusieurs mesures dans le but dobtenir la
position du pendule et du chariot afin de contrler le mouvement de celui-ci, en commandant
les moteurs (par le signal u).

La position du pendule est mesure par le potentiomtre situ sur laxe de rotation du
pendule. La valeur brute envoye par ce capteur de rotation est ensuite convertit en
mouvement horizontal du pendule par la mthode qui suit :

Angle obtenu grce au potentiomtre.


LENGHT

Dplacement de la charge = LENGTH * sin (angle)

Chariot

La position du chariot est mesure par le capteur de rotation qui est directement li aux
roues conductrices. Nous utilisons galement un capteur de vitesse afin de dterminer la
vitesse du chariot.
Donc grce ces mesures, le robot dtermine la commande des moteurs pour corriger
le balancement du pendule. Plus le dplacement est grand, plus le chariot se dplacera loin et
vite.

Page 14 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Lorsque le systme est en marche, on distingue deux modes de fonctionnement.


Tout dabord au dmarrage, le programme effectue une initialisation des diffrentes
mesures. Puis le programme rentre dans une boucle infinie (jusqu ce que lon teigne le
RCX) o chaque itration le programme relve les mesures des diffrents capteurs et
commande les moteurs en fonction du signal de commande. Pendant ces itrations, diffrentes
valeurs sont mises par le RCX : le temps, la position du pendule, le signal de contrle des
moteurs, la vitesse et la valeur de position du pendule dsire.

3.3. Les fonctions utilises dans le programme.

Le programme principal utilise diffrentes fonctions (le programme principal est mis
en annexe). En voici quelques unes :

void initialise_sensors() /*initialise les diffrents capteurs*/


{
/* Capteur dangle du pendule */
ds_passive(&SENSOR_2);

/* Activation du capteur de rotation*/


ds_active(&SENSOR_1); /*fonction qui active le capteur*/
ds_rotation_on(&SENSOR_1); /*commence la mesure*/

/* Calibre le capteur de rotation 0 */


ds_rotation_set(&SENSOR_1,0);

/* Active le capteur de vitesse */


ds_active(&SENSOR_3);
ds_rotation_on(&SENSOR_3);

/* Calibre le capteur de vitesse 0 */


ds_rotation_set(&SENSOR_3,0);
}

double pendulum_angle(double angle_0) /*mesure de langle du pendule*/


{
double angle,resistance;
unsigned int angle_raw;
angle_raw = SENSOR_2/64; /*recupration de la valeur brute du capteur*/
resistance = 1.0*angle_raw*INTERNAL_RESISTANCE/
(MAX_INT_ANGLE-angle_raw); /* convertit la valeur en ohms*/
angle = 2*PI*(resistance/POT_RESISTANCE); /*convertit en radians*/
angle = 0.85*angle; /*facteur correctif*/
return angle-angle_0;
}

double motor_velocity() /*mesure de la vitesse*/


{

Page 15 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

int velocity_raw;
double velocity;
velocity_raw = (SENSOR_3/64) - 512; /*valeur brute obtenue par le capteur*/
velocity = velocity_raw/VELOCITY_FACTOR;
return velocity;
}

double bob_position(double angle)


{
double position;
position = LENGTH*sin(angle);
return position;
}

double cart_position()
{
int position_raw;
double position;
position_raw = ROTATION_1;
position = position_raw/TICKS_PER_METRE; /* metre */
position = 0.82*position; /* facteur correcteur */
return position;
}

double drive(double u) /* Convertit le signal de contrle u en vitesse des moteurs */


{
int u_int;
u = -u; /*change le signe*/

/*transforme u en un signal logique*/


if (u>1) u = 1;
if (u<-1) u = -1;

if (u>0) {
motor_a_dir(fwd); /*dirige les moteurs vers lavant*/
motor_c_dir(fwd);
u_int = u*MAX_SPEED;
}
else
{ motor_a_dir(rev); /*dirige les moteurs vers larrire*/
motor_c_dir(rev);
u_int = -u*MAX_SPEED;
};

motor_a_speed(u_int); /* Vitesse du moteur */


motor_c_speed(u_int);
u = -u;
return u;
}

Page 16 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

void put_data(double elapsed, double y, double u, double v, double w)


{ /*convertit les doubles en nombres sans virgules*/
int I[N_data];

I[0] = elapsed*100;
I[1] = y*I2R;
I[2] = u*I2R;
I[3] = v*I2R;
I[4] = w*I2R;

putint(I); /*renvoi ces valeurs au PC*/


};

3.4. Analyse des donnes

Nous avons vu dans le programme quune fonction permettait denvoyer des donnes.
Monsieur Buessler nous a ralis une commande permettant de rcuprer les donnes sous
Matlab, ces donnes sont dabord stockes dans un registre auquel cette commande permet
daccder. A partir de ces donnes, nous avons trac les courbes correspondantes lvolution
temporelle de ces valeurs.

600 1000
position commande

400
500

200
0
0

-500
-200

-400 -1000
0 200 400 600 800 1000 0 200 400 600 800 1000

600 1
vlocit setpoint

400
0.5

200
0
0

-0.5
-200

-400 -1
0 200 400 600 800 1000 0 200 400 600 800 1000

Page 17 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

On constate que pour un grand basculement du pendule, le systme ragit bien mais
lorsque le basculement devient plus faible, le chariot a du mal se dplacer ce qui est d au
couple de frottement du sol sur les roues.
On remarque bien que la commande du moteur (u) est loppose du signal de position.
Le chariot se dplace donc en sens inverse au dplacement du pendule.

Page 18 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Conclusion

Bien quayant rencontr de nombreux problmes, nous avons finalement russi


tlcharger le programme et faire fonctionner le chariot pendule. De mme nous avons pu
analyser les donnes utiles pour comprendre le fonctionnement du programme. Mme si nous
nen avons pas eut le temps ( cause des divers problmes cits au-dessus), il semble donc
possible damliorer le programme pour que lasservissement soit plus rapide.

Ce projet nous a permis de dvelopper notre sens du travail en quipe. Il nous a aussi
permis de dcouvrir la programmation applique aux robots avec le logiciel de
programmation fourni par Lego ainsi quavec BrickOS et Cygwin.

Ce projet sinscrit donc parfaitement dans le cadre de notre formation en EEA et


particulirement en automatique.

Page 19 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

ANNEXE
Le programme principal:
int main(int argc, char **argv)
{
int i;

double kk;
double bob, angle, angle_0, position, position_old, velocity;
double w = 0.0; /* mtre */
double y, y_con, u, u_out;
double state[N_state];
double t=0.0;

sleep(1);
lcd_clear();

/* Initialisation des capteurs et des diffrents vecteurs */


new_U=0;
i_U = 0;
initialise_sensors();
initialise_u(U);
initialise_u(U_new);
initialise_state(state);
set_ustar(ustar,Ustar,i_U);

cputs("WAIT");

/* Configure la communication avec la tour usb */


lnp_integrity_set_handler(get_U);
cputs("START");
first_time = sys_time; /*initialise le temps de dpart*/

/* Initialisation des mesures*/


kk = 0;
angle_0 = pendulum_angle(0.0);
position_old = cart_position();
u_out = 0.0;
u = 0.0;

while(1) /* Boucle infinie */


{
angle = pendulum_angle(angle_0); /*mesure langle par rapport langle de
dpart*/
bob = bob_position(angle); /*mesure le dplacement du pendule*/
position = cart_position(); /*mesure la position du chariot*/
velocity = motor_velocity(); /*mesure la vitesse du chariot*/

Page 20 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

y = position+bob; /* calcule la position du pendule */

#ifdef USE_CART_POSITION
y_con = position; /* Sortie contrle */
#else
y_con = y;
#endif

elapsed = (sys_time-first_time)/1000.0; /*dfinit le temps*/


/* Positionne la nouvelle valeur de U */
if (new_U==1)
{
for (i=0;i<N_U;i++)
U[i] = U_new[i]; /* Change U */
new_U = 0;
i_U = 0;
/* Rinitialise ustar */
set_ustar(ustar,Ustar,i_U);
};

w = 0;
for (i=0;i<N_U;i++)
{
w = w + U[i]*ustar[i];
};

lcd_int(i_U);

/* Contrle */
#ifdef OPEN_LOOP
u = w;
#else
u = controller(y_con,u_out,w,state);
#endif

u_out = drive(u); /*commande des moteurs*/


put_data(elapsed,y,u_out,velocity,w); /* Envoi les donnes au PC */

/* Incrmente le compteur pour prdfinir Ustar */


if (i_U<N_T-1)
i_U++;

t = t+DT; /* Incrmente le temps*/


position_old = position;

/* Prochain vecteur Ustar*/


set_ustar(ustar,Ustar,i_U);
}
return 0; }

Page 21 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

English report of Reibel Thomas

For my B.S. in engineering I made a project and wrote a report.

The project that I chose because I found it interesting was to do implementation


compared to a study. Moreover I think that knowledge is better when combined with
practice. Also I preferred realising an automatic project because it is a subject which interests
me much.

I worked with a team (with Christophe Carnandet); my tasks consisted in producing an


automatic robot in Lego. This robot is a cart pendulum. This pendulum had to be stabilized
when I started the program.

To begin, I initially had to familiarize myself with LEGOS MINDSTORMS which is


our support for realization. Its characteristics are that it is composed of a control unit, "the
RCX" in order to carry out programs. At the time of our first weeks I discovered the software
allowing to programming. For that I decided to train myself with the use of programs.

Thereafter, I have to allot the various projects to each group. I began the project by
building the robot. Then I had to analyze and transferred the program thanks to the Brickos
software.
Finally I had to analyze the operation of the system.

As a conclusion, I think that this project was very useful for me to challenge my
knowledge. Also this project is complete because it covers different aspect (Automatics and
computing).

Page 22 sur 23 Projet Chariot pendule


CARNANDET Christophe
REIBEL Thomas

Summary of the project of Carnandet Christophe

Within the framework of B.S. Electronics, Electrical Engineering and Automatism at


the University of Mulhouse, the professors asked us to carry out a final project. This project is
carried out in a team with Thomas Reibel. The goal of this project is to produce a pendulum,
this one being on a cart. The objective being that the cart must move so that the pendulum
stops as quickly as possible. I chose this project because I am interested in automated systems
and in particular in linked systems and it fits perfectly with my field.

With this goal in mind we used Legos Mindstorms, we made the programs on the
computer then we transferred them towards a Legos brick containing a microcontroller, called
RCX, this one being able to analyze input signals (contact, light detector) or to actuate
engines.

First, we built different robots starting from the software provided with the Legos box,
but we noticed that this software was not practical to use, indeed, it is practical for simple
programs but it is more delicate to use for more complex programs. Thats why we chose to
use an other programming language, C/C++. In the course of this first experiment, we
encountered a lot of problems like PC malfunctions, problems with the Legos tower. These
problems were resolved by changing the PC and reinstalling the Legos tower driver.

This software, called brickOS, enabled us to compile the programs. The code is
constituted of various functions which manage the information sent by the sensors and makes
the cart move according to this information in order to stop the pendulum. We also tried to
make the RCX communicate with the PC in order to be able to recover the information which
enabled us to improve the system.

This very interesting project enabled me to look further into my knowledge in


automatisms as well in a programming. It also allowed me to discover the Legos
programming and the Cygwin software. The fact that the theme was in English enabled me to
improve my English level.

In conclusion, I can say that this project is perfectly registered in the framework that I
have chose and complete the license certificate.

Page 23 sur 23 Projet Chariot pendule

Вам также может понравиться