Université Mohammed V – Rabat
École Nationale Supérieure d’Arts et Métiers
Filière : 2ème année Energie Electrique et Industrie Numérique
COMPTE RENDU TP1 ET TP2 :
- CRÉATION DES TÂCHES SOUS UN
SYSTÈME D’EXPLOITATION
- MULTITÂCHES ET GESTION DES
PRÉEMPTIONS
Réalisé par : Encadré par :
- OULAASRI Yassine - M. A. JILBAB
- LASRI Abderrahmane
ANNÉE UNIVERSITAIRE : 2020/2021
1
INTRODUCTION
Le PICos18 est un noyau temps réel préemptif de la société PRAGMATEC basé sur la norme
automobile OSEK/VDX et destiné aux microcontrôleurs PIC18 de la société MICROCHIP
TECHNOLOGY INC.
Le noyau PICos18 possède les caractéristiques suivantes :
Event Manager Process Manager INIT Manager
Alarm Task Manager Hook
Manager Routines
Scheduler Init
• Le cœur du noyau (Init + Scheduler + Task Manager) qui a la responsabilité de
gérer les tâches de l'application et donc de déterminer la prochaine tâche active
en fonction de l'état et la priorité de chaque tâche.
• Le gestionnaire d'alarmes et de compteurs (Alarm Manager). Proche du cœur
du noyau, il répond à l'interruption du TIMER0 afin de mettre à jour
périodiquement les alarmes et compteurs associées aux tâches.
• Les Hook routines sont proches du cœur du noyau et permettent à l'utilisateur
de dérouter le déroulement normal du noyau de façon à prendre temporairement
le contrôle du système.
• Le gestionnaire de tâches (Process Manager) est un service du noyau, dont le
rôle est d'offrir à l'application les fonctions nécessaires à la gestion des états
(changer l'état d'une tâche, chaîner des tâches, activer une tâche...).
• Le gestionnaire d'évènement (Event Manager) est un service du noyau dont le
rôle est d'offrir à l'application les fonctions nécessaires à la gestion des
évènements d'une tâche (mise en attente sur un évènement, effacer un
évènement...).
• Le gestionnaire d'interruption (INT Manager) offre à l'application les fonctions
nécessaires à l’activation et la désactivation des interruptions du système.
2
OBJECTIFS
- Objectif TP1
L’objectif du TP1 est de s’initier à la création de tâches sous le système d’exploitation
embarqué PICos18. Le microcontrôleur utilisé est un PIC 18F4520 qui devra générer des
signaux PWM pour commander deux moteurs à CC.
- Objectif TP2
L’objectif du TP2 est la création de deux tâches :
• Tâche 0 : qui permet de détecter les obstacles devant le Robot.
• Tâche 1 : pour la gestion du Robot (avancer, tourner, mesurer, transmettre)
Si un obstacle est détecté par la tâche 0, celle-ci envoie un évènement pour réveiller la
tâche de gestion du robot.
TP1
TP1 1
PROGRAMME TEST
Dans PICos18, au respect de la norme OSEK, une tâche possède 4 états possibles :
- SUSPENDED : la tâche est présente dans le projet, mais n'est pas prise en
compte par le noyau.
- READY : la tâche est prête à être activée par le noyau, qui désormais la prend en
compte.
- WAITING : la tâche est en sommeil, elle est temporairement SUSPENDED et
sera READY dès qu'un évènement viendra la réveiller.
- RUNNING : parmi toutes les tâches prêtes, c'est celle-ci qui occupe le
processeur pendant un temps T.
Simulation de la tâche TASK0 en mode READY :
On ajoute un Breakpoint au niveau du while(1) et on lance la simulation.
On remarque que la simulation s’arrête immédiatement sur le Breakpoint au niveau de
la TASK0, on en déduit qu’au mode READY le Kernel peut accéder à la tâche.
TP1 2
PROGRAMME TEST
Simulation de la tâche TASK0 en mode SUSPENDED :
Pour le mode SUSPENDED, la simulation ne s’arrête plus tout en négligeant le
Breakpoint, on peut dire que le Kernel ne rentre plus dans la tâche, cette dernière n’est
pas encore prête à s’exécuter.
TP1 3
TRAVAIL DEMANDÉ
1) Réalisation de la tâche « TASK0 » pour faire clignoter une LED à
une certaine fréquence
Pour gérer les événements d’horloge, on dispose des fonctions suivantes :
• SetRelAlarm(ALARM_TSK0, T_Commence, Période);
• WaitEvent(ALARM_EVENT);
• ClearEvent(ALARM_EVENT);
Code :
TASK(TASK0)
{
TRISBbits.TRISB4 = 0;
LATBbits.LATB4 = 0;
SetRelAlarm(ALARM_TSK0, 1000, 200);
while(1)
{
WaitEvent(ALARM_EVENT);
ClearEvent(ALARM_EVENT);
LATBbits.LATB4 = ~LATBbits.LATB4;
}
}
On ajoute les (pragmas) suivantes avant les (includes) dans le fichier « tsk_task0.c » :
#pragma config WDT = OFF
#pragma config MCLRE = ON
#pragma config DEBUG = OFF
#pragma config PWRT = OFF
#pragma config LVP = OFF
#pragma config OSC = HS
#pragma config PBADEN = OFF
TP1 4
TRAVAIL DEMANDÉ
Simulation sous PICSimLab :
TP1 5
TRAVAIL DEMANDÉ
Relevé du signal RB4 :
On remarque que, après un délai de 1s, les impulsions sont générées périodiquement
toutes les 200ms comme programmé dans l’alarme de la tâche
« SetRelAlarm(ALARM_TSK0, 1000, 200); »
Simulation sous la maquette PIC TRAINER :
OFF ON
TP1 6
TRAVAIL DEMANDÉ
Relevé du signal RB4 :
2) Génération du signal PWM
Code :
TASK(TASK0)
{
short i,j,a;
TRISBbits.TRISB4 = 0;
LATBbits.LATB4 = 0;
SetRelAlarm(ALARM_TSK0, 1000, 200);
while(1)
{
WaitEvent(ALARM_EVENT);
ClearEvent(ALARM_EVENT);
LATBbits.LATB4 = ~LATBbits.LATB4;
a = 50; // l'angle alpha en %
if (LATBbits.LATB4 == 1)
{
for (j=0; j<a; j++)
for (i=0; i<965; i++);
LATBbits.LATB4 = 0;
}
}
}
TP1 7
TRAVAIL DEMANDÉ
Simulation sous PICSimLab :
- Alpha = 10%
- Alpha = 90%
TP1 8
TRAVAIL DEMANDÉ
Simulation sous la maquette PIC TRAINER :
- Alpha = 10%
- Alpha = 90%
TP1 9
TRAVAIL DEMANDÉ
3) Durée d’impulsion modifiable par potentiomètre
Utilisant le convertisseur analogique numérique du PIC18F4520, on fait la lecture des
valeurs de tension à l’aide d’un potentiomètre branché au pin RA0 du PORTA, la valeur
lue est convertie par le CAN sur 10 bits (entre 0 et 1023), cette dernière est divisée par
1023 et multiplier par 100 pour servir d’un pourcentage définissant la largeur de
l’impulsion du signal PWM généré.
Code :
TASK(TASK0)
{
short i,j,a;
TRISBbits.TRISB4 = 0;
LATBbits.LATB4 = 0;
TRISAbits.TRISA0 = 1; // RA0 Input
ADCON1 = 0x00; // RefVoltageIsVDD, AnalogPinConfigured
ADCON2 = 0x92; // RightJustifiedADResult, 4TAD, FOSC/32
ADRESH = 0; ADRESL = 0;
SetRelAlarm(ALARM_TSK0, 1000, 200);
while(1)
{
WaitEvent(ALARM_EVENT);
ClearEvent(ALARM_EVENT);
LATBbits.LATB4 = ~LATBbits.LATB4;
ADCON0 = 0b00000001; // SelectChannel0, GO=0, ADON=1
ADCON0bits.GO = 1;
while(ADCON0bits.GO == 1);
a = (short)ADRES/10.23; // l'angle alpha en %
if (LATBbits.LATB4 == 1)
{
for (j=0; j<a; j++)
for (i=0; i<965; i++);
LATBbits.LATB4 = 0;
}
}
}
TP1 10
TRAVAIL DEMANDÉ
Simulation sous ISIS :
- Alpha = 50%
TP1 11
TRAVAIL DEMANDÉ
- Alpha = 20%
- Alpha = 80%
TP1 12
TRAVAIL DEMANDÉ
4) Commande de vitesse de deux moteurs à courant continu
Code :
TASK(TASK0)
{
short i,j,a;
TRISB = 0b00000111; // RB3->RB7 Output, RB1-RB2 Input
TRISAbits.TRISA0 = 1; // RA0 Input
LATBbits.LATB3 = 0;
LATBbits.LATB4 = 1; // MCC1 Sens 1
LATBbits.LATB5 = 0;
LATBbits.LATB6 = 1; // MCC2 Sens 1
ADCON1 = 0x00; // RefVoltageIsVDD, AnalogPinConfig
ADCON2 = 0x92; // RightJustifiedADResult, 4TAD, FOSCover32
ADRESH = 0; ADRESL = 0;
SetRelAlarm(ALARM_TSK0, 1000, 200);
while(1)
{
WaitEvent(ALARM_EVENT);
ClearEvent(ALARM_EVENT);
LATBbits.LATB3 = ~LATBbits.LATB3;
if (PORTBbits.RB1 == 1)
LATBbits.LATB5 = 1;
if (PORTBbits.RB1 == 0)
LATBbits.LATB5 = 0;
ADCON0 = 0b00000001; // SelectChannel0, GO=0, ADON=1
ADCON0bits.GO = 1;
while(ADCON0bits.GO == 1);
a = (short)ADRES/10.23; // l'angle alpha en %
if (LATBbits.LATB3 == 1)
{
for (j=0; j<a; j++)
for (i=0; i<975; i++);
LATBbits.LATB3 = 0;
}
}
TP1 13
TRAVAIL DEMANDÉ
Simulation sous ISIS :
alpha = 20%
95.1 RPM
alpha = 90%
433 RPM
alpha = 50%
236 RPM
TP1 14
TRAVAIL DEMANDÉ
5) Boutons poussoirs permettant d’arrêter les moteurs
En déclarant les pins RB1 et RB2 comme entrée en ajoutant le code suivant avant le
« while » de la TASK0 :
TRISBbits.TRISB1 = 1; // RB1 Input
TRISBbits.TRISB2 = 1; // RB2 Input
Dans le « while » on fait la lecture des pins RB1 et RB2 pour arrêter successivement soit
le moteur 1 ou le moteur 2 :
if (PORTBbits.RB1 == 1)
LATBbits.LATB4 = 0; // Arret MCC1 Sens 1
if (PORTBbits.RB2 == 1)
LATBbits.LATB6 = 0; // Arret MCC2 Sens 1
OFF
ON
TP2
TP2 1
PROGRAMME TEST
Clignotement des deux LEDs suite à la détection d’un obstacle :
On utilisera deux LEDs qui joueront le rôle des moteurs. Un des switches, disponibles
sur la carte, est utilisé pour jouer le rôle du capteur d’obstacle.
Code Tache 0 :
TASK(TASK0)
{
TRISBbits.TRISB0 = 1;
SetRelAlarm(ALARM_TSK0, 1000, 1000);
while(1)
{
WaitEvent(ALARM_EVENT);
ClearEvent(ALARM_EVENT);
if (PORTBbits.RB0 == 1)
SetEvent(TASK1_ID, TASK1_EVENT);
}
}
TP2 2
PROGRAMME TEST
Code Tache 1 :
TASK(TASK1)
{
int i;
TRISBbits.TRISB4 = 0;
TRISBbits.TRISB5 = 0;
LATBbits.LATB4 = 0;
LATBbits.LATB5 = 0;
while(1)
{
WaitEvent(TASK1_EVENT);
ClearEvent(TASK1_EVENT);
LATBbits.LATB4 = ~LATBbits.LATB4;
LATBbits.LATB5 = ~LATBbits.LATB5;
}
}
Simulation sous ISIS :
Obstacle non détecté
TP2 3
PROGRAMME TEST
Obstacle détecté !
Clignotement des LEDs !
Oscillogramme du clignotement :
Presque 1s de
l’alarme de TASK 0
TP2 4
PROGRAMME TEST
Simulation sous la maquette PIC TRAINER :
RB0 : Détection de l’obstacle
RB4 : Clignotement de la LED
TP2 5
TRAVAIL DEMANDÉ
Génération des signaux PWM adapté aux moteurs à commander :
On commande les deux moteurs par un signal PWM de période 200ms.
- En absence d’obstacles, le rapport cyclique alpha du signal PWM vaut 0%.
- En présence des deux obstacles, le rapport cyclique du signal PWM vaut 0%.
- A la détection de l’obstacle 1, le alpha du signal PWM vaut 60%.
- A la détection de l’obstacle 2, le alpha du signal PWM vaut 20%.
Code Tache 0 :
TASK(TASK0)
{
TRISBbits.TRISB1 = 1;
TRISBbits.TRISB2 = 1;
SetRelAlarm(ALARM_TSK0, 1000, 200);
while(1)
{
WaitEvent(ALARM_EVENT);
ClearEvent(ALARM_EVENT);
if (PORTBbits.RB1 == 1 || PORTBbits.RB2 == 1)
SetEvent(TASK1_ID, TASK1_EVENT);
}
}
TP2 6
TRAVAIL DEMANDÉ
Code Tache 1 :
TASK(TASK1)
{
int i,j,a;
TRISBbits.TRISB1 = 1; // Obstacle 1
TRISBbits.TRISB2 = 1; // Obstacle 2
TRISBbits.TRISB3 = 0;
TRISBbits.TRISB4 = 0;
TRISBbits.TRISB6 = 0;
LATBbits.LATB3 = 0; // Signal PWM
LATBbits.LATB4 = 1; // MCC1 Sens 1
LATBbits.LATB6 = 1; // MCC2 Sens 1
while(1)
{
WaitEvent(TASK1_EVENT);
ClearEvent(TASK1_EVENT);
LATBbits.LATB3 = ~LATBbits.LATB3;
if(PORTBbits.RB2 == 1 && PORTBbits.RB1 == 1)
a = 0;
else if(PORTBbits.RB1 == 1)
a = 60;
else if(PORTBbits.RB2 == 1)
a = 20;
else
a = 0;
// a : l'angle alpha en %
if (LATBbits.LATB3 == 1)
{
for (j=0; j<a; j++)
for (i=0; i<970; i++);
LATBbits.LATB3 = 0;
}
}
}
TP2 7
TRAVAIL DEMANDÉ
Simulation sous ISIS :
Alpha = 60%
Alpha = 20%
TP2 8
TRAVAIL DEMANDÉ
Alpha = 0%
Alpha = 0%
TP2 9
CONCLUSION
Durant ce TP, on a découvert le principe d’ordonnancement avec le PIC18F4520 sous le
système d’exploitation préemptif PICos18, on a pu réaliser un code qui génère un signal
PWM pour la commande des moteurs à courant continu sur une période de 200ms.
Ainsi on a pu commander ces deux moteurs MCC suite à la détection d’obstacles du Robot
en modifiant la vitesse de rotation des moteurs agissant sur le rapport cyclique alpha du
signal PWM.
On a découvert aussi le principe d’Event consistant à réveiller une tâche à partir d’une autre
tâche en lui envoyant un évènement sur une cadence (Alarme) à définir dans la tâche
excitante.
Concernant le TP2, la maquette PIC TRAINER, on a pu réaliser le câblage des switches qui
servent d’entrée d’obstacle pour le microcontrôleur, ainsi les LEDs représentant les deux
moteurs MCC à commander en simulant le fonctionnement de détection des obstacles qui
a bien fonctionner sans avoir visualisé les signaux PWM sur l’oscilloscope, chose qu’on a
déjà fait pour le premier TP.
