Cours - ISN Codelab

Transcription

Cours - ISN Codelab

Programmation NXC
Application à la commande
c
d’un robot NXT Lego
Richard M OREAU
Extrait
Laboratoire Ampère - Département PC & GMC
[email protected]
Last update October 10, 2012
Richard M OREAU – 1 / 84
Plan du cours
Objectifs du cours
Plan du cours
Objectifs
Caractéristiques du
c
robot NXT de Lego
Programmation
c
1. Caractéristiques du robot NXT de Lego
Programme NXC
Programmation
Multi-tâches
Conclusion
2. Programmation du Robot NXT
3. Not eXactly C : "Pas exactement du C"
4. Programmation multi-tâches en NXC
Objectifs du cours
Objectifs du cours
Plan du cours
c
)
Commande d’un robot NXT (Lego Mindstorms
Quatre types de capteur
Trois actionneurs (servomoteurs)
Un boîtier NXT
Programme NXC
Quatre boutons
Programmation
Multi-tâches
Un générateur de son
Conclusion
Un écran LCD (100x64, 17ms)
Une connexion USB (12Mo/sec)
Une liaison Bluetooth (460.8Ko/sec)
Objectifs
c
robot NXT de Lego
Programmation
Structure d’un programme NXC
main, données, algorithmes, fonctions, subroutines
Structure d’un programme multi-tâches NXC
Temps, Tâches, synchronisation
Brique NXT
Objectifs du cours
c
robot NXT de Lego
NXT
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
NXT avec ses capteurs et ses actionneurs
Objectifs du cours
c
robot NXT de Lego
NXT
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
Bricx Command Center
Objectifs du cours
Connexion de la brique NXT au lancement du logiciel
c
robot NXT de Lego
NXT
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
Objectifs du cours
Fenêtre principale du logiciel Bricx Command Center (BricxCC)
c
robot NXT de Lego
NXT
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
Objectifs du cours
c
robot NXT de Lego
NXT
Dans le menu Edit -> Preferences - Onglet General
(Dé)cocher l’option Use MDI Mode pour (dés)activer le Multiple
Document Interface.
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
Objectifs du cours
c
robot NXT de Lego
Dans Preferences - Onglet Compiler - Onglet Common
Choisir le langage NXC.
NXT
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
Objectifs du cours
c
robot NXT de Lego
Dans Preferences - Onglet Compiler - Onglet NBC/NXC
Choisir Use Internal Compiler et Switches -q
NXT
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
Objectifs du cours
c
robot NXT de Lego
Dans Preferences - Onglet Start Up
Réglages des options de démarrage : Port USB et Brick Type NXT
NXT
Architecture
Programmation
BricxCC
Problèmes
Programmation
Programme NXC
Programmation
Multi-tâches
Conclusion
Quelques problèmes
Objectifs du cours
c
robot NXT de Lego
NXT
Architecture
Le robot n’est pas visible par le logiciel
Programmation
BricxCC
Problèmes
Programmation
Allumer le robot !
Tools / Find Brick
Programme NXC
Programmation
Multi-tâches
Conclusion
Plus de piles
Reset (bouton à l’arrière du robot au niveau port USB)
Téléphones, PDA, ...
Interférences avec la liaison Bluetooth
Interférences IR avec le capteur de luminosité
Plan du cours
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
c
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Les capteurs
Objectifs du cours
Capteur de luminosité
Capteur de son
Capteur de contact
Capteur ultrason
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Configuration des capteurs
Objectifs du cours
c
robot NXT de Lego
4 capteurs nommés S1, S2, S3, S4 ou IN_1, IN_2, IN_3, IN_4
Un type
Programmation
Les capteurs
SENSOR_TYPE_NONE
Capteur générique passif
SENSOR_TYPE_TOUCH
Capteur de contact
SENSOR_TYPE_LIGHT
Capteur de luminosité
SENSOR_TYPE_SOUND_DBCapteur de son
SENSOR_TYPE_LOWSPEED Capteur I2 C (Inter Integrated Circuit Bus)
Capteur Ultrason, magnétique, RGB,
pression, infra rouge, etc.
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Un mode
SENSOR_MODE_RAW
SENSOR_MODE_BOOL
SENSOR_MODE_EDGE
SENSOR_MODE_PULSE
SENSOR_MODE_PERCENT
Intervalle entre 0 et 1023
Booléen (0 ou 1)
Nombre de transitions booléennes
Nombre de périodes booléennes
Valeur entre 0 et 100
Configuration des capteurs
Objectifs du cours
c
robot NXT de Lego
Programmation
Une configuration : un type + un mode
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
Configuration
Type
Mode
SENSOR_TOUCH
SENSOR_LIGHT
SENSOR_PULSE
SENSOR_TYPE_TOUCH
SENSOR_TYPE_LIGHT
SENSOR_TYPE_TOUCH
SENSOR_MODE_BOOL
SENSOR_MODE_PERCENT
SENSOR_MODE_PULSE
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Action des capteurs
Objectifs du cours
c
robot NXT de Lego
Programmation
Initialiser le type, le mode et la configuration
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
SetSensorType(sensor,type);
SetSensorMode(sensor,mode);
SetSensor(sensor,configuration);
SetSensorType(S1,SENSOR_TYPE_TOUCH);
SetSensorMode(S1,SENSOR_MODE_BOOL);
SetSensor(S1,SENSOR_TOUCH);
Exercices I
Le son
L’affichage
Les fichiers
Récupérer une information d’un capteur
Exemples
Exercices II
Sensor(n);
SensorUS(n);
x=SENSOR_1;
dist=SensorUS(S4);
Programme NXC
Programmation
Multi-tâches
renvoie la valeur du capteur n (n=Si iǫ[1, 4])
renvoie la valeur du capteur I2 C n;
Lit le capteur 1 et sauvegarde sa valeur dans x
Lit le capteur US et sauvegarde la distance dans dist
Conclusion
Remettre à 0 un capteur cumulatif
ClearSensor(sensor);
ClearSensor(S1);
Action des capteurs
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Configurations spécifiques
SetSensorTouch(sensor);
SetSensorLight(sensor);
SetSensorSound(sensor);
SetSensorLowspeed(sensor);
Les actionneurs
Gestion du temps
Programme de
commandes
// capteur de contact: 1 = appuyé, 0 = relâché
// capteur de luminosité: échelonné de 0 à 100
// capteur de son: échelonné de 0 à 100
// capteur Ultra Son: échelonné de 0 à 255 cm
Exercices I
Le son
NB : Certains capteurs peuvent avoir des configurations spécifiques.
SetSensorType(sensor,IN_TYPE_LIGHT_ACTIVE);
// lumière active sur le capteur luminosité pour améliorer la précision à très courte
distance
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Les boutons
BTNEXIT, BTNRIGHT, BTNLEFT et BTNCENTER
ButtonCount(button,reset);
// renvoie le nombre de fois où button a été appuyé, remise à 0 si reset est égal à true
ButtonPressed(button,reset);
// renvoie si le bouton button est appuyé, remise à 0 si reset est égal à true
Les actionneurs
Objectifs du cours
c
robot NXT de Lego
Version RCX
Version NXT
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Poids
Vitesse
Couple
Encodeur intégré
Synchronisation
RCX
28 g
340 tr/min
5,5 N.cm
X
X
NXT
80 g
170 tr/min
50 N.cm
√
√
Configuration des actionneurs
Objectifs du cours
c
robot NXT de Lego
Programmation
3 actionneurs et 4 combinaisons :
Les capteurs
OUT_A, OUT_B, OUT_C
Les actionneurs
OUT_AB, OUT_AC, OUT_BC, OUT_ABC
Gestion du temps
Programme de
commandes
Commande en puissance
Exercices I
Le son
Commande en pourcentage de - 100 % à + 100 %
L’affichage
Les fichiers
OnFwd(outputs,power);
OnFwd(OUT_A,75);
// Moteur A en avant à 75%
Exemples
OnRev(outputs,power);
OnRev(OUT_AC,75);
// Moteurs A et C en arrière à 75%
OnFwd(OUT_AC,-75);
// Moteurs A et C en arrière à 75%
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Arrêt
Float(outputs);
Off(outputs);
// arrêt sans freinage
// arrêt avec freinage
Commande des actionneurs
Objectifs du cours
c
robot NXT de Lego
Commande en position
RotateMotor(outputs,power,angle);
Commande PID de la position
RotateMotorPID(outputs,power,angle,P,I,D);
Programmation
Les capteurs
Les actionneurs
Gestion du temps
// P : Proportionnel, I : Intégrateur , D : Dérivateur
Programme de
commandes
Exercices I
Le son
L’affichage
Commande en vitesse
OnFwdReg(outputs,power,OUT_REGMODE_SPEED);
// La vitesse est maintenue constante (accélération si nécessaire)
Les fichiers
Exemples
Exercices II
Programme NXC
Commande synchronisée
OnFwdReg(outputs,power,OUT_REGMODE_SYNC);
// La vitesse de tous les moteurs désignés par outputs est identique
Programmation
Multi-tâches
Conclusion
Suivi des actionneurs
Objectifs du cours
c
robot NXT de Lego
MotorActualSpeed(output);
// renvoie la puissance envoyée sur le moteur output
Programmation
Les capteurs
Les actionneurs
Suivi de la commande
Gestion du temps
Suivi des rotations effectuées
Programme de
commandes
Angles
MotorRotationCount(output);
// renvoie le nombre de degrés effectués sur le moteur output
Compte remis à zéro à chaque nouvelle commande
ResetRotationCount(output);
// remise à zéro du nombre de degrés effectués sur le moteur
output
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Suivi du PID
MotorRegPValue(output);
MotorRegIValue(output);
MotorRegDValue(output);
// récupère les valeurs du PID
Gestion du temps
Objectifs du cours
c
robot NXT de Lego
Tick (précision : 1 ms)
Wait(timeout)
Programmation
Attente en ms
Paramètres : unsigned int
Attention : pas de valeur négative, sinon risque d’attente très
Les capteurs
Les actionneurs
Gestion du temps
longue
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Primitives
CurrentTick(); // renvoie le temps en ms, type unsigned long (4 octets)
x=FirstTick(); // renvoie le temps en ms là où le programme a été lancée
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Arrêt programmé de la brique NXT
SleepTimer();
SetSleepTime(tps);
SleepTime();
ResetSleepTimer();
SetSleepTimer(tps);
SleepNow();
// renvoie la valeur du compteur d’arrêt de la brique
// initialise la valeur du compteur d’arrêt automatique à tps minutes
// renvoie le temps courant restant avant l’arrêt automatique de la brique
// remise à zéro du compteur d’arrêt automatique (évite l’arrêt)
// initialise le compteur courant d’arrêt automatique à tps minutes
// arrêt de la brique
Programme de commandes
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Une tâche principale
task main
Séquence de commandes
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
task main()
{
/*séquence de commandes*/
}
Programmation
Multi-tâches
Conclusion
Premier programme
Objectifs du cours
c
robot NXT de Lego
Programmation
Premier programme :
Les capteurs
Les actionneurs
Utilisation des moteurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
task main()
{
OnFwd(OUT_A, 75);
OnFwd(OUT_B, 75);
Wait(4000);
OnRev(OUT_AB, 75);
Wait(4000);
Float(OUT_AB);
}
// Moteur A en avant à 75%
// Moteur B en avant à 75%
// Attente de 4 secondes
// Moteurs A et B en arrière à 75%
// Attente de 4 secondes
// Arrêt moteurs A et B sans freinage
Le son
Objectifs du cours
c
robot NXT de Lego
Un son à la fois, attendre la fin du précédent pour jouer le suivant
Programmation
Les capteurs
Les actionneurs
Programme de
commandes
Exercices I
L’affichage
Jouer une fréquence
PlayToneEx(frequency,duration,volume,loop);
PlayTone(frequency,duration);
// Frequency en Hz, Duration en ms, loop à true pour un son en boucle
Les fichiers
Exemples
Exercices II
Programme NXC
PlayTone(440,1000);
// Joue un do pendant 1 seconde
Programmation
Multi-tâches
Conclusion
Jouer une mélodie
PlayFileEx("SoundFile.rso",volume,repeat);
// Lecture du fichier SoundFile, volume de 0 à 4, repeat à true pour
jouer en boucle
Gestion du temps
Le son
Un générateur de son
Arrêter
StopSound();
L’affichage via l’écran LCD
Objectifs du cours
c
robot NXT de Lego
Caractéristiques
100 x 64 pixels, taux de rafraîchissement 17ms
Programmation
Les capteurs
8 lignes(LCD_LINE1, ...,LCD_LINE8)
Les actionneurs
1 caractère : 8 pixels en hauteur, 6 pixels en largeur
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Affichage
X : colonne, Y : ligne
TextOut(X,Y,string,clear);
// Affiche string à partir de la position (X,Y), efface si clear est égal à true
NumOut(X,Y,value,clear);
// Affiche value à partir de la position (X,Y), efface si clear est égal à true
ClearScreen();
// Efface tout l’écran
GraphicOut(X,Y,"GraphicFile.ric");
// Affiche GraphicFile à partir de la position (X,Y)
PointOut(X,Y); LineOut(X1,Y1,X2,Y2); CircleOut(X,Y,R); RectOut(X,Y,L,H);
L’affichage via l’écran LCD
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
Exemple :
#define LargChar 6
// Largeur d’un caractère (6 pixels)
ClearScreen();
TextOut(0,LCD_LINE3,"test LCD :",false);
NumOut(LargChar*11,LCD_LINE3,11,false);
NumOut(LargChar*11,LCD_LINE3,2,false);
NumOut(LargChar*11,LCD_LINE3,3,true);
TextOut(0,LCD_LINE3,"test LCD :",false);
// efface l’écran
// affiche test LCD :
// affiche test LCD : 11
// affiche
3
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
La gestion des fichiers
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
// crée le fichier filename avec la taille size et renvoie handle
Les actionneurs
CloseFile(handle);
Gestion du temps
// ferme le fichier caractérisé par handle
Programme de
commandes
DeleteFile("filename.txt");
Exercices I
// supprime de la mémoire du NXT le fichier "filename.txt"
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Création et connexion
CreateFile("filename.txt",size,handle);
Récupération des fichiers sur la machine de développement
NeXT Explorer du logiciel BricxCC
Si un bug apparaît lors du remplissage du fichier : le fichier
devient irrécupérable
Conclusion
Opération sur les fichiers
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Write(handle,value);
// écrit value dans le fichier caractérisé par handle
Les actionneurs
Gestion du temps
Programme de
commandes
Read(handle,value);
// lit value dans le fichier caractérisé par handle
Exercices I
Le son
L’affichage
WriteLn(handle,value);
Les fichiers
// écrit value+CR+LF dans le fichier caractérisé par handle
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
ReadLn(handle,value);
// lit value dans le fichier caractérisé par handle, puis lit CR et LF
Conclusion
Exemples de programme
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Tester les capteurs et afficher leur valeur sur l’écran LCD (1/2) :
task main()
{ SetSensorTouch(S1);
while(1)
{
NumOut(0,LCD_LINE3,SENSOR_1,true);
}
}
// Activation du capteur de contact
// Boucle infinie
// Affichage de la valeur de S1
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
task main()
{ int x;
SetSensorLowspeed(S4);
while(1)
{
x=SensorUS(S4);
NumOut(0,LCD_LINE4,x,true);
}
}
// Création de la variable x
// Activation du capteur ultrason
// Boucle infinie
// Enregistrement valeur de S4 dans x
// Affichage de la variable x
Objectifs du cours
Tester les capteurs et afficher leur valeur sur l’écran LCD (2/2) :
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
task main()
{
int x;
SetSensorTouch(S1);
SetSensor(S2,SENSOR_LIGHT);
SetSensorMode(S2,SENSOR_MODE_RAW);
SetSensorLowspeed(S3);
while(1)
{
x=SensorUS(S3);
NumOut(0,LCD_LINE2,SENSOR_1);
NumOut(0,LCD_LINE4,SENSOR_2);
NumOut(0,LCD_LINE6,x);
}
}
// Activation du capteur de contact
// Activation du capteur luminosité
// Choix du mode RAW pour S2
// Activation du capteur ultrason
// Boucle infinie
// Enregistrement de S3 dans x
// Affichage de la variable x
Conclusion
Objectifs du cours
Opérations sur les boutons et afficher leur valeur :
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
task main()
{
int x, y, z;
while(1)
{
x=ButtonCount(BTNLEFT,false);
y=ButtonCount(BTNRIGHT,false);
z = y-x;
NumOut(0,LCD_LINE3,z,true);
if (ButtonPressed(BTNCENTER,false))
{
ButtonCount(BTNLEFT,true);
ButtonCount(BTNRIGHT,true);
}
}
}
// Création des variables x, y, z
// Boucle infinie
// Comptage nbre de pression sur BTNLEFT
// Comptage nbre de pression sur BTNRIGHT
// Affichage de la valeur de x
// Affichage de la valeur de z
// Remise à zéro du compteur
// Remise à zéro du compteur
Objectifs du cours
Opérations sur les moteurs, affichage et sons :
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
task main()
{
int x;
OnFwd(OUT_A,75);
Wait(2000);
x=MotorTachoCount(OUT_A);
Off(OUT_A);
Wait(2000);
PlayFileEx("Goodbye.rso",3,false);
Wait(1000);
}
// Moteur A en avant
// Pendant 2 secondes
// Enregistrement du nombre de degrés effectués
// Arrêt du moteur
// Affichage de la valeur de x
// Pendant 2 secondes
// Lecture du fichier Goodbye.rso
// Pause d’1 seconde
Programmation
Multi-tâches
Conclusion
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Attente d’un signal provenant d’un capteur :
task main()
{ SetSensor(S1,SENSOR_TOUCH);
OnFwd(OUT_AC, 75);
until (SENSOR_1 == 1);
Off(OUT_AC);
}
// Configuration du capteur de contact
// Moteurs A et C en avant à 75%
// Attente du contact
// Arrêt moteurs A et C avec freinage
Action suite à une activité d’un capteur :
task main()
{ SetSensorTouch(S1);
OnFwd(OUT_AC, 75);
while (true)
{
if (SENSOR_1 == 1)
{
OnRev(OUT_AC, 75); Wait(2000);
Off(OUT_AC);
}
}
}
// Configuration du capteur de contact
// Fait avancer le robot
// Boucle infinie
// Test contact
// Fait reculer le robot
// Arrêt avec freinage des moteurs
Objectifs du cours
Création et sauvegarde de données dans un fichier txt :
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
Gestion du temps
Programme de
commandes
Exercices I
task main()
{
byte fileHandle;
string write;
DeleteFile("NxtIsCool.txt");
DeleteFile("NxtSays.txt");
CreateFile("NxtIsCool.txt", 512, fileHandle);
Le son
L’affichage
for (int i=2; i<=10; i++ )
{ write = "NXT is cool";
string tmp = NumToStr(i);
write = StrCat(write,tmp, " times!");
WriteLn(fileHandle,write);
}
CloseFile(fileHandle);
RenameFile("NxtIsCool.txt","NxtSays.txt");
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
}
Plan du cours
Objectifs du cours
c
robot NXT de Lego
Programmation
Les capteurs
Les actionneurs
c
Gestion du temps
Programme de
commandes
Exercices I
Le son
L’affichage
Les fichiers
Exemples
Exercices II
Programme NXC
Programmation
Multi-tâches
Conclusion
Introduction à NXC
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Déclaration de données
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Initialisation des données
Définition des constantes
Tâche : séquences d’instructions
Commande robot
Opérations sur des données
Appels de fonctions
Structures algorithmiques
Conclusion
Introduction à NXC
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Not eXactly C : pas exactement du C
Langage de programmation proche du langage C (Syntaxe
C-like)
c
Programmation des briques NXT de Lego
Programmation multi-tâches
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
Syntaxe
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
max et Max sont différents
Syntaxe
Mots clés
Les Données
Liste de mots clés réservés
cf. diapo suivante
La base
Les structures
algorithmiques
Les Fonctions NXC
Différence entre les minuscules et les majuscules
Identificateur
suite de lettres, chiffres, _ ne commençant pas par un chiffre
Ne_le x1
_12
IF : ok
Né_le 2_A 2000 if : pas ok
Exercice III
Programmation
Multi-tâches
Conclusion
Commentaire
/* commentaire à la C */
// commentaire à la C++
Liste non exhaustive de mots clés
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
abs
case
do
if
priority
sign
sub
unsigned
asm
char
else
inline
repeat
start
switch
until
bool
const
false
int
return
stop
task
void
break
continue
for
long
safecall
string
true
while
byte
default
goto
mutex
short
struct
typedef
Conclusion
Les données
Objectifs du cours
c
robot NXT de Lego
Toute information manipulée par le programme
constantes, variables
Programmation
Programme NXC
un identificateur (avec un nom pertinent)
Introduction à NXC
Syntaxe
une initialisation
Mots clés
un commentaire
Les Données
La base
Les structures
algorithmiques
Caractérisée par
Les Fonctions NXC
Types entier :
entier sur 8 bits (1 octect) : bool, byte, char, unsigned char
Exercice III
entier signé sur 16 bits (2 octets) : short, int ([-32768, 32767]),
Programmation
Multi-tâches
unsigned int
Conclusion
entier signé sur 32 bits (4 octets) : long, unsigned long
Chaîne de caractère
Tableau de byte : string
Les données
Objectifs du cours
c
robot NXT de Lego
Valeurs
Décimal
Programmation
Hexadécimal
Programme NXC
Booléen : 0 correspond à false et différent de 0 correspond à true
Introduction à NXC
Syntaxe
Mots clés
Déclaration de données
Les Données
Int nombreTour; // nombre de tours effectués
La base
Les structures
algorithmiques
Int MissionTerminee = 0;
Les Fonctions NXC
Int a, b;
Exercice III
Programmation
Multi-tâches
Conclusion
Déclation de tableaux
int lesPositions[10]; // ensemble de points à atteindre
Déclaration de lesPositions[0], lesPositions[1], ...,
lesPositions[9]
Les données
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
Déclaration des variables : locale ou globale ?
int x;
task main();
{
int y;
x=y
{
int z;
y = z;
}
y = z;
}
task foo()
{
x=1;
y=2;
}
// x est une variable globale
// y est locale dans la tâche main
// ok
// Début du sous bloc de programmation
// Déclaration de la variable locale z
// ok;
// erreur, z n’existe plus
// ok, x est globale
// erreur, y n’est pas globale
Les structures de données
Objectifs du cours
c
robot NXT de Lego
Déclaration, initialisation et utilisation
struct robot
{ string name;
int vitesse; };
Programmation
Programme NXC
// nom du robot
// vitesse du robot
Introduction à NXC
task main()
{ robot monRobot;
monRobot.name = "Astro";
monRobot.vitesse = 0 ;
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
// le robot
// vitesse initiale nulle - robot à l’arrêt
OnFwd(OUT_A, 50);
// le robot avance
// Affichage vitesse robot
while (true);
{ monRobot.vitesse=MotorActualSpeed(OUT_A);
TextOut(0,LCD_LINE3,"vitesse : ", true);
NumOut(64,LCD_LINE3,monRobot.vitesse, true); }
}
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
Affectation possible si les types sont identiques
Les opérateurs
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Opérateur
=
+=
-=
*=
/=
%=
++
–
==
!=
!
&&
||
Action
Variable affectée de la valeur
Variable incrémentée de la valeur
Variable décrémentée de la valeur
Variable multipliée par la valeur
Variable divisée par la valeur
Varaible prend la valeur du reste
Incrémentation de 1
Décrémentation de 1
Égalité
Différent
Négation logique
ET logique
OU logique
Exemple
x=2; // x prend la valeur 2
x+=2; // 2 est ajoutée à x
x-=2; // 2 est retirée à x
x*=2; // x est multipliée par 2
x/=2; // x est divisée par 2
x%=5 // si x valait 2, x prend la valeur 1
x++ // si x valait 2, x prend la valeur 3
x– // si x valait 3, x prend la valeur 2
x==2 // Vrai si x vaut 2 sinon faux
x!=2 // Vrai si x différent de 2 sinon faux
!x // Négation de x
x && y // Vrai si x ET y sont vrais sinon faux
x || y // Vrai si x OU y sont vrais sinon faux
Exercice III
Programmation
Multi-tâches
Quelques conseils :
Conclusion
Attention à la priorité des opérations (2+3*4 différent de
(2+3)*4)
Parenthésage (enlève les ambiguïtés et aide à la relecture du
code)
Les fonctions de base
Objectifs du cours
c
robot NXT de Lego
Fonctions sur les chaînes de caractères
Fonctions sur les entiers
Programmation
Programme NXC
Introduction à NXC
Syntaxe
x = StrToNum(str);
str = NumToStr(x);
i = StrLen(str);
str = StrCat(str1,str2);
// renvoie la valeur numérique de str
// renvoie la chaîne de caractère de l’entier x
// renvoie la longueur de str
// str est composé de str1 suivi de str2
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
x = Sin(θ);
x = Cos(θ);
θ = Asin(x);
θ = Acos(x);
x = Sqrt(y);
// θ en degrés, valeur entre -100 et 100
// θ en degrés, valeur entre -100 et 100
// renvoie le arcsin de x (-100..100) en degré (-90..90)
// renvoie le arccos de x (-100.100) en degré (0..180)
// renvoie la racine carrée de y
Les structures algorithmiques
Objectifs du cours
Alternative
c
robot NXT de Lego
Programmation
Programme NXC
Condition
Cas Parmi
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Tant que
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
Jusqu’à
Répétition
Boucle
for
Répéter
plusieurs fois
if (expression)
{instructions}
[else {instructions}]
switch(expression)
{
case valeur1 : {instruction}; break;
case valeur2 : {instruction}; break;
defaut : {instruction} ;
}
while (expression)
{instructions};
do
{instruction};
while (expression);
for (initialisation;condition;incrémentation)
{instruction};
repeat (expression)
{instructions} ;
La structure alternative
Objectifs du cours
c
robot NXT de Lego
Programmation
Booléen : 0 => faux, différent de 0 => vrai
La condition est une expression
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
int dureeTour = 400
...
...
if (SENSOR_1)
{
OnFwd(OUT_AC,75);
Wait(dureeTour);
Off(OUT_AC);
}
else
{
OnRev(OUT_AC,75);
Wait(dureeTour);
Off(OUT_AC);
...
}
// durée de rotation
// si le capteur est appuyé
// avance
// arrêt
// Le capteur est relâché
// recule
// arrêt
La structure cas parmi
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Pour éviter des conditions en cascade
Peu importe l’ordre des valeurs mais les valeurs sont différentes
int nb ;
task main()
{
...
switch (nb)
{
case 1 :
OnFwd(OUT_A, 75);
break;
// déclaration variable
// selon la valeur de nb
// tourne à droite
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
case 3 :
OnFwd(OUT_C, 75);
break;
// tourne à gauche
default :
Off(OUT_AC);
break;
// arrêt
}
...
}
La structure tant que
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
attention aux {}
int dureeAction = 100
int NbActionsMax = 5
int NbAction = 0
// durée de fonctionnement
// Nombre d’actions à réaliser
// Nombre d’actions en cours
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
task main()
{
while (NbAction <NbActionsMax)
{
OnFwd(OUT_AC, 75); // avance
Wait(dureeAction);
Off(OUT_AC);
// arrêt
nbAction++;
// Pour afficher la variable NbAction sur l’écran LCD
NumOut(0,LCD_LINE3,NbAction); Wait(dureeAction*10);
}
}
/* Il faut s’assurer que l’action modifie les données afin que l’expression
soit fausse à un moment donné */
Les autres formes de structures de boucle tant que
Objectifs du cours
c
robot NXT de Lego
Tâches répétitives
Programmation
while (SENSOR_1 != ValeurRecherchée)
{
// Traitement
}
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Boucles infinies
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
while (1) // ou while (true)
{
// Attente ou vérification
// Traitement
}
La structure Repeat
Objectifs du cours
c
robot NXT de Lego
Programmation
Nombre d’itérations connues
Programme NXC
Introduction à NXC
Syntaxe
int dureeAction = 100
int NbActionsAFaire = 5
task main()
{
repeat (NbActionsAFaire)
{
OnFwd(OUT_AC, 75);
Wait(dureeAction);
Off(OUT_AC);
}
}
// avance
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
// arrêt
La structure for
Objectifs du cours
c
robot NXT de Lego
Programmation
Nombre d’itérations connues
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
int dureeAction 100
int NbActionsAFaire = 5
int i ;
// Le compteur
task main()
{
for ( i=0 ; i <NbActionsAFaire ; i++ )
{
OnFwd(OUT_AC, 75);
Wait(dureeAction);
Off(OUT_AC);
}
}
// avance
// arrêt
Les Fonctions NXC
Objectifs du cours
c
robot NXT de Lego
256 fonctions au maximum (y compris le main et les tâches)
pas de déclaration
Les fonctions sub
permet d’économiser de la mémoire
Les fonctions inline void
prend plus de mémoire mais le nombre n’est pas limité
Les macros en utilisant #define
rend le code plus compact et améliore la lisibilité
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
Les Fonctions NXC
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
// avec la fonction sub
}
// avec la fonction inline
inline void turn_around(int pwd, int turn_time)
{
OnRev(OUT_C, pwr);
Wait(turn_time);
OnFwd(OUT_AC, pwr);
}
task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
turn_around(75);
Wait(2000);
turn_around(75);
Wait(1000);
Off(OUT _AC);
}
task main()
{
OnFwd(OUT_AC, 75);
Wait(1000);
turn_around(75, 2000);
Wait(2000);
turn_around(75, 500);
Wait(1000);
Off(OUT _AC);
}
sub turn_around(int pwr)
{
OnRev(OUT_C, pwr);
Wait(900);
OnFwd(OUT_AC, pwr);
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
Les Fonctions NXC
Objectifs du cours
c
robot NXT de Lego
Premier exemple de macro pour faire tourner le robot
Programmation
Programme NXC
Introduction à NXC
Syntaxe
#define turn_around {OnRev(OUT_A,75); Wait(3400); \
PlayTone(333,1000);Wait(1000);}
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
task main()
{
OnFwd(OUT_AC,75);
Wait(1000);
turn_around;
OnFwd(OUT_AC, pwr);
Wait(2000);
turn_around;
Wait(1000);
turn_around;
}
Les Fonctions NXC
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
Second exemple de macro avec des arguments
#define turn_right(s, t)
#define turn_left(s, t)
#define forwards(s, t)
#define backwards(s, t)
OnFwd(OUT_A, s); OnRev(OUT_C, s); Wait(t);
OnRev(OUT_A, s); OnFwd(OUT_C, s); Wait(t);
OnFwd(OUT_AC, s); Wait(t);
OnRev(OUT_AC, s); Wait(t);
task main()
{
backwards(50, 10000);
turn_left(75, 750);
forwards(50, 1000);
turn_right(75, 750);
forwards(30, 2000);
Off(OUT_AC);
}
Les Fonctions NXC
Objectifs du cours
c
robot NXT de Lego
Passage par valeur : int
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
sub foo(int x)
{
x=2;
}
task main()
{
int y = 1;
foo(y);
ClearScreen();
NumOut(0,LCD_LINE3,y,false);
Wait(2000);
}
// y est égal à 1
// y reste égal à 1
// Affichage sur l’écran du résultat
Les Fonctions NXC
Objectifs du cours
c
robot NXT de Lego
Passage par valeur constante : const int
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
sub foo(const int x)
{
int z;
z=x;
x=1;
}
// Ok
// erreur car x ne peut pas être modifiée (constante)
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
task main()
{
int y;
foo(2);
foo(4*5);
}
// ok
// ok - l’expression est une constante
Les Fonctions NXC
Objectifs du cours
c
robot NXT de Lego
Passage par référence : int &
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
sub foo(int & x)
{
x=2;
}
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
task main()
{
int y = 1;
foo(y);
foo(2);
}
// y est égal à 1
// y est maintenant égal à 2
// erreur, seules les variables ont des références
Exercice d’application (1/2)
Objectifs du cours
Objectifs :
c
robot NXT de Lego
Programmation
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
savoir déclarer et utiliser des données ;
savoir manipuler des structures algorithmiques ;
savoir utiliser des fonctions NXC
Les Données
La base
Les structures
algorithmiques
Exercices :
1. Construire un robot mobile.
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
2. Le robot avance en ligne droite pendant 4 secondes, tourne à droite, repart en
ligne droite pendant 4 secondes et s’arrête
3. Le robot décrit deux fois un carré (3 secondes par côté) et s’arrête.
Conclusion
Exercice d’application (2/2)
Objectifs du cours
c
robot NXT de Lego
Programmation
Exercices :
Programme NXC
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
Conclusion
4. Le robot part à 20% de sa puissance puis accélère par échelon de 10% par
seconde jusqu’à 80%.
5. Le robot avance en ligne droite puis au 1er appui sur le capteur contact il
tourne à 90o vers la droite. Il attend le 2nd appui sur le capteur contact pour
repartir tout droit et enfin il s’arrête au bout de 3 secondes.
6. Le robot avance en ligne droite et s’arrête suite à l’appui sur le capteur contact
ou au bout de 4 secondes si aucun signal ne provient du capteur.
7. Le robot avance tout droit lorsque l’on tape dans les mains et s’arrête lorsqu’il
rencontre une bande noire ou s’il est à moins de 10 cm d’un obstacle.
Plan du cours
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
c
Introduction à NXC
Syntaxe
Mots clés
Les Données
La base
Les structures
algorithmiques
Les Fonctions NXC
Exercice III
Programmation
Multi-tâches
3. Not eXactly C : “Pas exactement du C”
Conclusion
Tâches régulières
Objectifs du cours
Maîtrise des dates d’activation des actions
Scrutation périodique
Commande régulière
c
robot NXT de Lego
Programmation
Programme NXC
Limitation de l’occupation du CPU
Programmation
Multi-tâches
Les tâches
Partage des données
#define Attente 1000
// période d’attente d’une seconde
Mise en place de
tâches
Exercices IV
Conclusion
task readSensor()
{
while(1)
{
Wait(Attente);
int position=SENSOR_1;
...
}
}
// boucle infinie
// mise en sommeil de la tâche
// acquisition
Les tâches
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Programmation
Multi-tâches
Les tâches
Toujours une tâche principale appelée main
task main()
Exécutée au début d’application
Une autre tâche s’exécute seulement si une tâche en cours
l’appelle ou si elle est prévue dans le main
Mise en place de
tâches
Nombre de tâches limité par la plateforme (256)
Exercices IV
Définition d’une tâche
Conclusion
Pas de paramètres
Pas de retour
task LeNomDeMaTache()
{
/* séquence de commandes */
}
Gestion des tâches
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Programmation
Multi-tâches
Lancement de tâches
start taskName;
task controlRobot()
{
OnFwd(OUT_A,75);
}
Les tâches
Mise en place de
tâches
Exercices IV
Conclusion
task readSensor()
{
while(1)
{
if (SENSOR_1 == 1)
{
start controlRobot;
}
}
}
task main()
{
SetSensor(S1, SENSOR_TOUCH);
start readSensor;
}
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Programmation
Multi-tâches
Les tâches
Mise en place de
tâches
Exercices IV
Conclusion
Partage d’une valeur entière
int x;
// variable partagée entre T1 et T2
Partage par mutex (mutual exclusion)
int x; // variable partagée entre T1 et T2
mutex port_x; // mutex de protection de x
task T1()
{
...
x=a-b;
// opération non atomique
...
}
task T1()
{
...
Acquire(port_x);
x=a-b; // opération protégée
Release(port_x); ...
}
task T2()
{
...
y=x;
// la valeur de x n’est pas garantie
...
}
task T2()
{
int y; ...
Acquire(port_x);
y=x; // la valeur de x est garantie
Release(port_x); ...
}
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Programmation
Multi-tâches
Les tâches
Mise en place de
tâches
Exercices IV
Conclusion
Attention aux interférences entre les tâches
task check_sensors()
{
while (true)
{
if (SENSOR_1)
{
OnRev(OUT_AC, 75);
Wait(500);
OnFwd(OUT_A, 75);
Wait(850);
}
}
}
task submain()
{
while (true)
{
OnFwd(OUT_AC, 75); Wait(1000);
OnRev(OUT_C, 75); Wait(850);
}
}
task main()
{
Precedes(check_sensors, submain);
}
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Programmation
Multi-tâches
Les tâches
Mise en place de
tâches
Exercices IV
Conclusion
Solution en utilisant mutex (mutual exclusion))
mutex moveMutex;
task check_sensors()
{
while (true)
{
if (SENSOR_1)
{
Acquire(moveMutex);
OnRev(OUT_A, 75); Wait(1000);
Release(moveMutex);
}
}
}
task move()
{
while (true)
{
Acquire(moveMutex);
OnFwd(OUT_A, 75); Wait(5000);
Release(moveMutex);
}
}
task main()
{
Precedes(check_sensors, move);
}
Objectifs du cours
c
robot NXT de Lego
Programmation
Programme NXC
Programmation
Multi-tâches
Les tâches
Mise en place de
tâches
Exercices IV
Conclusion
Solution en utilisant des sémaphores
int sem;
task move_square()
{
while (true)
{
until (sem == 0); sem = 1;
OnFwd(OUT_AC, 75);
sem = 0;
Wait(1000);
OnRev(OUT_C, 75);
sem = 0;
Wait(850);
}
}
task submain()
{
while (true)
{
if (SENSOR_1 == 1)
{
OnRev(OUT_AC, 75); Wait(500);
OnFwd(OUT_A, 75); Wait(850);
sem = 0;
}
}
}
task main()
{
sem = 0;
Precedes(move_square, submain);
}
Ordonnancement des tâches
Objectifs du cours
int go = 0; déclenchement des moteurs
c
robot NXT de Lego
Programmation
Ordonnancement non prédictible
Comportement du moteur A
?
Programme NXC
Programmation
Multi-tâches
Les tâches
Mise en place de
tâches
Exercices IV
Conclusion
Attention à ne pas multiplier
les tâches
Partage et cohérence des données
Synchronisation des actions
task Commande();
{ if (go == 1)
{
OnFwd(OUT_A, 75);
}
}
task Arret();
{ if (go == 0)
{
Off(OUT_A);
}
}
task Go();
{ go = 1 ;
}
task main()
{ Precedes(Go, Commande, Arret); }
Mise en place de tâches
Objectifs du cours
Conception
Tâche de démarrage
c
robot NXT de Lego
Programmation
Initialisations et activations des autres tâches
Tâches de réaction à un événement externe ou programmé
Programme NXC
Programmation
Multi-tâches
Les tâches
Un nouveau message
Une nouvelle mesure
Une alarme programmée sur un dépassement de Timeout
Mise en place de
tâches
Exercices IV
Conclusion
Scrutation de capteurs
Gestion des actionneurs
Suivi du fonctionnement (monitoring)
Programmation
main
Tâches en continu
while (1) {Actions; Wait(Attente); }
while (1) {Actions;}
Tâches activées par une autre tâche
start taskName;
Exercices d’application
Objectifs du cours
Objectifs :
c
robot NXT de Lego
Programmation
Programme NXC
Programmation
Multi-tâches
Les tâches
savoir faire un programme comprenant plusieurs tâches ;
savoir partager des données entre les tâches ;
savoir être autonome en programmation NXC.
Mise en place de
tâches
Exercices IV
Conclusion
Exercices :
1. Le robot avance en ligne droite et s’arrête si l’on appuie sur le capteur de
contact ou au bout de 4 secondes (solution en utilisant deux tâches) ;
2. Le robot parcourt un dégradé du blanc au noir, affiche sur l’écran la valeur lue
par le capteur de luminosité et l’enregistre dans un fichier “Mesure.txt” ;
3. Le robot suit un parcours définit par une ligne noire sur un fond blanc.
Conclusion
Objectifs du cours
Langage de programmation haut niveau
c
robot NXT de Lego
Communications
Programmation
Capteurs : l’utilisation dépend de la configuration
Moteurs : commande en vitesse, en position (PID)
IHM : 4 boutons, 1 écran LCD, 1 générateur de son
Gestion de fichiers
Communication Bluetooth
Programme NXC
Programmation
Multi-tâches
Conclusion
Conclusion
Références
Robot
Programmation
NXC
Pas de pointeurs
Fonctions non réentrantes
Présentation du code
Commentaires, choix des noms de variables, définition des constantes
Multi-tâches
Précision du temps : 1 ms
Mise en place des tâches : main, tâches régulières et/ou
continues
Attention au partage des données et à la synchronisation
Références
Objectifs du cours
c
robot NXT de Lego
“Not eXactly C (NXC) Programmer’s Guide”
by John H ANSEN, version 1.0.1 b33, 2007
Programmation
Programme NXC
“Programming LEGO NXT Robots using NXC”
by Daniele B ENEDETTELLI with revisions by John H ANSEN, version 2.2, 2007
Programmation
Multi-tâches
Conclusion
Conclusion
Références
“Programmation NXC - Application à la commande d’un robot
c
”
NXT Lego
by Prof. Jean Philippe BABAU, diaporama de cours INSA de Lyon, 2007
c
Mindstorms NXT Power Programmins - Robotics in
“Lego
C”
by John H ANSEN Éditeur : Variant Press, 560 pages, ISBN : 978-0973864922,
2007

Cours - ISN Codelab

Transcription

Documents pareils

203 - Sitetechno.fr

De la brique au robot, un jeu moderne

Installation de Microsoft Robotics Studio

IL EST NÉ LE DIVIN ROBOT... Montage

Liste de prix balles de golf 2016 avec impression

robot nettoyeur

Programmation robot Objectifs Présentation

Liste de prix balles de golf 2015 avec impression