Transcript Les OS temps réel embarqués

Les systèmes temps-réel
hard embarqués
Département informatique
DUT orientation Systèmes Informatisés
Année 2013-2014
Philippe Kauffmann
Temps réel embarqué
IUT C.F., dép. Informatique
1
Temps réel embarqué
IUT C.F., dép. Informatique
2
Les systèmes temps réel hard embarqués
• Concepts généraux
– Synchronisation et dialogue entre les tâches
• Les sémaphores, les mutex
• Les files de données
• Les mailbox, les files de messages
– Définition du temps réel
– Mono-tâche versus multitâche
– Codage sans et avec OS
– Analyse d'une application tps réel
– Fonctions secondaires de ITRON/4
• RTOS embarqué ITRON/4
– Fonctionnement de l’ordonnanceur
• installation et init. du noyau ITRON/4
• paramétrage du noyau ITRON/4
– Les tâches
• principe et déclaration
• contexte et paramétrage
• création, destruction, priorité
Temps réel embarqué
– Le handler périodique
– Le handler d'alarme
– Fonctions particulières
• Fonctions et handlers d'interruption
• Contrôle de l’ordonnanceur
• Etude du TCB
• Gestion des piles avec Call walker
• Gestion des données dynamique
IUT C.F., dép. Informatique
3
Les systèmes temps réel embarqués
• Définition de la notion de temps réel
– Capacité de réponse à un événement externe asynchrone
– Temps de réponse à un événement asynchrone borné
– Exemples de temps de réponse admis typiques
• Court-circuit électrique : 100 ns
• Réception port série : 10 µs
• Lecture d’un clavier : 0,1s
• Affichage de données : 1/15 s ≈ 0,067 s
• Système électromécanique asservi : 0,02 s
• Régulation de température d'un local : 10 mn
Temps réel embarqué
IUT C.F., dép. Informatique
4
Les systèmes temps réel embarqués
• Divers types de systèmes
– Non temps réel
• à cause du système d'exploitation,
• à cause du langage (ramasse miettes, etc.).
– Temps réel soft
• Linux embarqué avec ordonnanceur spécifique
– Temps réel hard
• Pas de mémoire cache ni partage d'interruption
• Eventuellement dispositif d'interruption rapide
Temps réel embarqué
IUT C.F., dép. Informatique
5
Les systèmes temps réel embarqués
• Concept monotâche
– Programme séquentiel linéaire
– Programme séquentiel en boucle infinie (avec boucles et blocage sur les E/S)
• Concept multitâche avec ordonnanceur
– Multi-utilisateurs ou Mono-utilisateur (PC)
• Contrôle par ordonnanceur d'applications indépendantes (sans communication entre
applications).
• Contrôle par ordonnanceur de programmes communicant
– Modèles de code pour le multitâches
• Notion de processus
• Notion de thread
• Notion de tâche
Temps réel embarqué
IUT C.F., dép. Informatique
6
Les systèmes temps réel embarqués
Structure sans OS avec tâche de fond en boucle (+ interruptions)
Tâches de fond
T1
Tâches d'interruptions
Priorité faible
Priorité forte
T2
T1
T3
T4
T5
T6
T5
T4
Temps
Temps réel embarqué
IUT C.F., dép. Informatique
7
Les systèmes temps réel embarqués
Structure avec OS non préemptif (coopératif)
Ord.
Interruptions
T2
Ord.
Tâche
Ord.
Temps
Temps réel embarqué
IUT C.F., dép. Informatique
8
Les systèmes temps réel embarqués
Structure avec OS préemptif
Tâche d'attente
Priorité 0
Priorité 1
Priorité 2
Interruptions
Tics
T1
T2
Fin
T1
Repos
T3
T4
Fin
T3
Repos
Temps
Temps réel embarqué
IUT C.F., dép. Informatique
9
Les OS temps réel embarqués (RTOS)
L’ordonnanceur
• Sélection de la tâche active
• Action
- L’ordonnanceur parcours la liste des
tâches prêtes.
- Il identifie celle qui doit être activée.
- Si ce n’est pas la tâche courante, il l’arrête,
sauvegarde son contexte et sa pile.
- Il active ensuite la nouvelle tâche la où
elle s’était arrêté la fois précédente.
•
Activation de l’ordonnanceur
•
•
L’ordonnanceur est activé à chaque
appel système.
Si le système est préemptif, aussi à
chaque tic d’horloge.
Temps réel embarqué
– Le critère de sélection de la tâche
active dépend de l'OS.
– Pour Linux ou Windows, c’est la tâche
qui attend depuis le plus longtemps qui
est activée, à moins qu’il y ait des
tâches avec des priorités spéciales.
– Dans le cas des OS temps réel on se
base en général sur la priorité.
– Certains RTOS acceptent que plusieurs
tâches aient la même priorité. Dans ce
cas, la tâche prête de plus forte priorité
attendant depuis le plus longtemps est
activée.
IUT C.F., dép. Informatique
10
Les OS temps réel embarqués
Caractéristiques du RTOS ITRON/4
• Caractéristiques générales
– RTOS hard basé sur les priorités (chaque priorité pouvant être partagée par
plusieurs tâches).
– Communication et échange de données par fanions, sémaphores, files de
données et boite aux lettres et files de message.
• Fonctionnement de l’ordonnanceur
– Si un appel noyau ou un tic d'horloge déclenche l’ordonnanceur, celui-ci
cherche la tâche prête ayant le plus haut niveau de priorité ayant le plus attendu
et lui donne la main.
• Limitations
– Il ne fonctionne pas sur plusieurs cœurs en parallèle.
– Il ne supporte pas le fonctionnement réparti en réseau.oite
Temps réel embarqué
IUT C.F., dép. Informatique
11
Les OS temps réel embarqués
Installation et démarrage de ITRON/4
Principe
– Le noyau temps réel INTRON/4 est fourni sous forme d'une bibliothèque
(ordonnanceur + fonctions d'appel système) à insérer dans l'application, un
préprocesseur de configuration, un outil de configuration et un outil de calcul
des piles.
– Le projet doit donc inclure la bibliothèque du RTOS ri600lit.lib. Un fichier de
configuration (<nom_projet.cfg>) doit être ajouté.
– Le programme principal (fonction main) n’existe plus. Le module de
démarrage doit appeler l'initialisateur de l'OS vsta_knl().
– L’ordonnanceur ensuite lance une tâche de démarrage qui initialise de
contrôleur et active les autres tâches.
Temps réel embarqué
IUT C.F., dép. Informatique
12
Les OS temps réel embarqués
•
Installation et démarrage
Exemple de code
#include "kernel.h"
#include "kernel_id.h"
/*
Starting task
void start(VP_INT stacd)
{
systemInit(30);
act_tsk(ID_mesure);
ext_tsk() ;
}
Temps réel embarqué
*/
system{
stack_size
priority
system_IPL
};
clock{
timer_clock
timer
IPL
};
task[]{
entry_address
name
stack_size
priority
initial_start
};
IUT C.F., dép. Informatique
= 1024;
= 5;
= 7;
= 48MHz;
= CMT0;
= 7;
= start();
= ID_start;
= 512;
= 1;
= ON;
13
Les OS temps réel embarqués
Installation et démarrage du RTOS ITRON/4
•
Configuration du compilateur et du RTOS
Temps réel embarqué
IUT C.F., dép. Informatique
14
Les OS temps réel embarqués
Tâches et notions associées
• Définition d'une tâche
- Une tâche est un programme élémentaire qui est lancé par l'OS ou une autre tâche.
- Une tâche contient des fonctions système qui rendent la main à l'OS.
- Une tâche est un morceau de programme qui se répète en général indéfiniment ou
se supprime.
- Une tâche possède des propriétés et éléments spécifiques :
- propriétés : priorité, état,...
- données associées : bloc de contrôle de tâche, pile de tâche
Temps réel embarqué
IUT C.F., dép. Informatique
15
Les OS temps réel embarqués
• Divers états d'une tâche
En attente
ter_tsk()
wai_flg()
wai_sem()
rcv_dtq()
rcv_mbx()
wup_tsk()
rsm_tsk()
tic d’horloge
sta_tsk()
act_tsk()
Endormie
set_flg(), clr_flg()
sig_sem()
snd_dtq()
snd_mbx()
slp_tsk()
sus_tsk()
dly_tsk()
tâche sélectionnée
Prête
ter_tsk()
interruption
Active
tâche préemptée
Interrompue
fin interruption
ext_tsk()
Temps réel embarqué
IUT C.F., dép. Informatique
16
Les OS temps réel embarqués
Tâches et notions associées
• Données associées
• Données associées
– Task Stack
- TCB : Task Control Block
Structure de contrôle de tâche qui contient :
– État de la tâche
– Priorité
– Tics à attendre
– Adresse courante du compteur de
programme de la tâche
– Adresse de la pile de données
– Pointeur dans la pile de données
– Pointeurs bidirectionnels vers les TCB
des autres tâches
– Données secondaires
Temps réel embarqué
Pile propre de la tâche qui contient :
- Les données passées en paramètre
- Les variables automatiques de la tâche
- L’adresse de retour
- Le registre dess bits d’état
Les mêmes données des fonctions
appelées en cascade par la tâche sont
aussi sauvegardées sur la pile de tâche.
IUT C.F., dép. Informatique
17
Les noyaux temps réel embarqués
Séquencement des tâches
• Gestion des priorités
– Priorités statiques
• La priorité est définie une fois pour toute à la création de la tâche.
– Priorités dynamiques
• La priorité de la tâche peut être modifiée dynamiquement au cours de l'exécution pour
s'adapter aux circonstances et surtout pour éviter les inversions de priorité.
– Inversion de priorité
• Phénomène parasite qui peut être observé lorsqu'une tâche de forte priorité partage de
façon exclusive une ressource avec une tâche de priorité faible. Dans certains cas, la
priorité effective de la tâche de priorité forte devient celle de la tâche de priorité faible.
– Héritage de priorité
• Mécanisme qui donne automatiquement à une tâche de priorité faible celle d'une tâche
de priorité forte, pour éviter le phénomène d'inversion de priorité.
Temps réel embarqué
IUT C.F., dép. Informatique
18
Inversion de priorité
Inversion de priorité
Tâche 1 (H)
Tâche 2 (M)
Tâche 3 (F)
Inversion de priorité
Inversion
Tâche 1 (H)
de priorité
Tâche 2 (M)
Tâche 3 (F)
(1)
Temps réel embarqué
(2)
(3)
(4)
(5)
IUT C.F., dép. Informatique
(6) (7)
(8)
19
Les OS temps réel embarqués
La gestion des tâches
• Structure d'une tâche
void MaTache(VP_INT stacd)
{
/* code de demarrage */
while (1)
{
/* code de la tache */
dly_tsk(n); /* fonction d'appel OS */
/* code de la tache */
.
.
}
}
Temps réel embarqué
IUT C.F., dép. Informatique
20
Les OS temps réel embarqués
La gestion des tâches
• Structure d'une tâche : exemple
void chargeCPU(VP_INT exinf)
{
uint8_t i = 0;
while (1) {
if (i++ > 200) {
// 2.5 times a second
i = 0;
// green led 0 and red led led 3 blinking
R_IO_PORT_Modify(PDL_IO_PORT_3_4, PDL_IO_PORT_XOR, 1);
R_IO_PORT_Modify(PDL_IO_PORT_0_2, PDL_IO_PORT_XOR, 1);
}
dly_tsk(1);
}
}
Temps réel embarqué
IUT C.F., dép. Informatique
21
Les OS temps réel embarqués
La gestion des tâches
• Création
La tâche doit d'abord être déclarée au configurateur afin que le bloc de contrôle de
tâche et la pile de la tâche soient définis, créés et initialisés.
task[]{
entry_address
name
stack_size
priority
initial_start
};
= nom();
= ID_nom;
= 256;
= 4;
= OFF;
La tâche doit ensuite être crée par l’un des appel noyau ci-après afin d'obtenir
l'insertion du bloc de contrôle dans la liste chaînée des tâches en attente :
sta_tsk(ID_nom, parametre);
Temps réel embarqué
ou
act_tsk(ID_nom);
IUT C.F., dép. Informatique
22
Les OS temps réel embarqués
La gestion des tâches
• Création
– Le fichier de configuration peut être généré par l'outil de configuration
Temps réel embarqué
IUT C.F., dép. Informatique
23
Les OS temps réel embarqués
La gestion des tâches
• Destruction
– Une tâche est supprimée par l'appel de la fonction :
ter_tsk(ID_tache);
– Ou la fonction qui demande à une tâche de se tuer elle-même :
ext_tsk();
– Une tâche supprimée (ou tuée) libère son TCB et les autres ressources qu'elle
possède ; elle devient "dormante".
– Une tâche tuée peut être crée à nouveau de façon dynamique.
Temps réel embarqué
IUT C.F., dép. Informatique
24
Les OS temps réel embarqués
La gestion des tâches
• Arrêt et réactivation
– Une tâche peut être désactivée par l'appel d’une des fonctions :
sus_tsk(ID_tache) ; ou slp_tsk();
– Elle peut être réactivée par l'appel de la fonction
rsm(ID_tache) ; ou wup_tsk(ID_tache);
– Une tâche désactivée (ou suspendue) conserve toutes ses ressources ; elle
devient "en attente".
Temps réel embarqué
IUT C.F., dép. Informatique
25
Les OS temps réel embarqués
La gestion des tâches
• Changement de priorité
– On change la priorité d'une tâche par l'appel de la fonction :
chg_pri(ID_tache, priority);
• La tâche d'attente
– Elle s'appelle « Idle Task », elle a la priorité la plus faible de toutes les tâches et
elle est exécutée lorsqu'aucune autre tâche n'est prête car le processeur ne peut
pas s’arrêter. C’est une boucle infinie qui ne fait rien.
Temps réel embarqué
IUT C.F., dép. Informatique
26
Les OS temps réel embarqués
Communication entres tâches
• Principe
– ITRON/4 supporte les principes de communication suivants :
•
•
•
•
Les fanions binaires sur 16 bits (flags).
Les sémaphores et les mutex.
Les files de données 16 bits (short data queue) ou 32 bits (data queue).
Les messages de taille et structure quelconque (mailbox & message queue).
– L'ensemble de ces mécanismes de communication sert aussi à la
synchronisation des tâches entre elles.
Temps réel embarqué
IUT C.F., dép. Informatique
27
Les sémaphores
• Présentation des sémaphores
– Mécanisme destiné à indiquer qu'une
ressource est en cours d'utilisation.
– Un sémaphore peut être binaire (=mutex)
ou à comptage.
– Un sémaphore est créé et exploité par des
fonctions spécifiques.
Tâche 1
Tâche 2
• Sémaphores de synchronisation
– servent à créer des "rendez vous".
• Sémaphores d'exclusion
Tâche 1
– pour protéger une ressource partagée.
• L'interblocage (baiser de la mort)
– Une tâche 1 qui dispose d'une ressource 1
dont la tâche 2 à besoin, bloque le
système si la tâche 2 dispose d'une
ressource 2 dont la tâche 1 a aussi besoin.
Temps réel embarqué
imprimante
Tâche 2
IUT C.F., dép. Informatique
28
Les sémaphores
Fonctions associées :
Tâche 1
sig_sem()
(t)wai_sem()
pol_sem()
ref_sem()
ou
interruption
Temps réel embarqué
Tâche 2
isig_sem()
ipol_sem()
iref_sem()
IUT C.F., dép. Informatique
29
Les sémaphores
• Définition des sémaphores avec l'outil de configuration
Temps réel embarqué
IUT C.F., dép. Informatique
30
Les sémaphores
• Exemple : sémaphore d'accès exclusif à une fonction non réentrante
Création
Exploitation
wai_sem(ID_sem1);
-> fonction non réentrante
sig_sem(ID_sem1);
Temps réel embarqué
/* prise du semaphore sans "timeout" */
/* restitution du semaphore */
IUT C.F., dép. Informatique
31
Les sémaphores
• Exemple : sémaphore d'accès exclusif à sprintf
Tâche 1
wai_sem(ID_affiche);
/* prise du semaphore affiche sans "timeout" */
sprintf(chaine," %03d:%02d:%02d", heure[2], heure[1], heure[0]);
sig_sem(ID_affiche);
/* restitution du semaphore */
Tâche 2
wai_sem(ID_affiche);
/* prise du semaphore affiche sans "timeout" */
sprintf(chaine," %6.2fV ", (float)((unsigned int)mesure/200.0));
sig_sem(ID_affiche);
/* restitution du semaphore */
Temps réel embarqué
IUT C.F., dép. Informatique
32
Les files de données
• Les messages sont un moyen pour transmettre simplement des données
de 32 bits maximum d'une tâche à une autre.
• Ils sont une alternative à l'utilisation de mémoire partagée.
• Chaque donnée est un mot de 32 bits exploité en partie (8 ou 16 bits) ou
totalement
Temps réel embarqué
IUT C.F., dép. Informatique
33
Les files de données
Fonctions associées :
Tâche 1
(t)snd_dtq()
psnd_dtq()
fsnd_dtq()
N
(t)rcv_dtq()
prcv_dtq()
ref_dtq()
Tâche 2
File d'attente
interruption
Temps réel embarqué
Donnée
ipsnd_dtq()
ifsnd_dtq()
iprcv_dtq()
iref_dtq()
IUT C.F., dép. Informatique
34
Les files de données
• Exemple : donnée transmise entre deux tâches
Déclaration
dataqueue[1]{
name
buffer_size
wait_queue
};
= ID_commandePC;
= 1;
= TA_TFIFO;
/* emission non bloquante de la donnee dans une interruption*/
static VP_INT mesure];
ipsnd_dtq(ID_commandePC, mesure);
.
.
/* attente de la donnee dans une tache avec "timeout" */
static VP_INT mesure_rec;
// command received
if (trcv_dtq(ID_commandePC, &mesure_rec, 15000) == E_OK)
{
// reception de la donnee
}
else {
// gestion du timeout
}
Temps réel embarqué
IUT C.F., dép. Informatique
35
Les files de données
• Configuration de files de données
.
.
Temps réel embarqué
IUT C.F., dép. Informatique
36
Les mailbox et message queue
• Les mailbox et « messsage queue » sont un moyen pour transmettre des
données (messages) de nature forme et taille quelconque.
• Ils sont comme les dataqueue une alternative à l'utilisation de la mémoire
partagée.
• Le message proprement dit est une structure de donnée dont le début
appartient au noyau et la fin est de forme libre choisie par l'utilisateur.
• Le message n'est pas transmis dans une mailbox, seule son adresse est
transmise.
• Le message est transmis dans une « message queue », ce qui permet de
s’abstenir de le sauvegarder immédiatement à réception.
Temps réel embarqué
IUT C.F., dép. Informatique
37
Les mailbox
Fonctions associées :
Tâche 1
interruption
Temps réel embarqué
snd_mbx()
isnd_mbx()
iprcv_mbx()
iref_mbx()
(t)rcv_mbx()
prcv_mbx()
ref_mbx()
File d'attente
(1 élément
par émetteur)
IUT C.F., dép. Informatique
Tâche 2
Message
38
Les mailbox
• Configuration de messages
Temps réel embarqué
IUT C.F., dép. Informatique
39
Les mailbox
• Exemple : chaîne de caractères transmise entre deux tâches
Déclaration
/* émission du message dans une tache */
typedef struct {
T_MSG header ; // zone reservee au noyau
unsigned char commande[32] ; // zone utilisateur
} FIFO_MSG ;
FIFO_MSG reception_RS;
snd_mbx(ID_commandePC, (T_MSG *)&reception_RS);
Temps réel embarqué
IUT C.F., dép. Informatique
40
Les mailbox
• Exemple : chaîne de caractères transmise entre deux tâches
Gestion de la réception
unsigned char error = 0 ;
// déclaration du pointeur vers la structure du message
FIFO_MSG *com_rec;
// command received
/* attente du message dans une tache avec "timeout" */
error = trcv_mbx(ID_commandePC, (T_MSG **)&com_rec, 15000);
if (error == E_TMOUT)
{ // gestion du timeout }
if (error == E_RLWAI)
{ // gestion de la sortie forcee }
if (error == E_OK)
{ // gestion de la reception du message }
Temps réel embarqué
IUT C.F., dép. Informatique
41
Analyse d'une application temps réel
Temps réel embarqué
IUT C.F., dép. Informatique
42
Les OS temps réel embarqués
Les handlers périodiques
• Principe : le handler périodique est une fonction exécutée à fréquence fixe et
activée au moment de l'exécution de l'interruption de l'ordonnanceur.
•
Particularités : le code est une interruption faisant partie de l'ordonnanceur, il n'a
donc pas de priorité de tâche mais a la priorité d'interruption de l'ordonnanceur et
utilise la pile de l'ordonnanceur (pile système). Exemple :
// CYCLIC HANDLER startConv
// Description : starts analog/digital conversion
// Argument : none
// Return value : none
void startConv(VP_INT exinf)
{
// start analog/digital converter
S12AD.ADCSR.BIT.ADST = true;
}
Temps réel embarqué
IUT C.F., dép. Informatique
43
Les OS temps réel embarqués
Les handlers d'alarme
• Principe : le handler d'alarme est une fonction exécutée lorsqu'un temps maximum
d'attente (timeout) est dépassé. Elle est activée au moment de l'exécution de
l'interruption de l'ordonnanceur.
•
Particularités : le code est une interruption faisant partie de l'ordonnanceur, il n'a
donc pas de priorité de tâche mais a la priorité d'interruption de l'ordonnanceur et
utilise la pile de l'ordonnanceur (pile système)
Temps réel embarqué
IUT C.F., dép. Informatique
44
Les OS temps réel embarqués
Rappel du principe général des interruptions
•
Les interruptions sont des événements asynchrones déclenchés par des périphériques :
• Temporisateurs
• Convertisseurs A/N
• Périphériques de communication
• Broches d’interruption du contrôleur
•
L’interruption force l’arrêt momentané de l’exécution du code en cours qui est remplacé
temporairement par le code de l’interruption. L’interruption « vole » du temps processeur à
l’insu du code interrompu.
• Le programme d’interruption reçoit en général des données d’un périphérique et les
retourne après un traitement minimal vers l’extérieur via une zone de mémoire partagée si on
n'a pas d'OS temps-réel, ou via des files de données ou messages si on dispose d'un OS tempsréel.
Temps réel embarqué
IUT C.F., dép. Informatique
45
Les OS temps réel embarqués
Notions liées aux interruptions
•
•
Une interruption est un mécanisme
électronique qui permet d'interrompre
l'exécution du programme en cours suite à un
événement externe (source d'interruption)
pour exécuter le programme lié à cette
événement et destiné à le traiter.
Données et
fanions
Programme
d'interruption
Préparation
de données
Fonctionnement d'une interruption :
– achèvement de l'exécution de
l'instruction en cours,
– sauvegarde de l'adresse de retour
– sauvegarde du contexte
– exécution du code
– retour et réinitialisation du fanion
d'interruption.
•
Programme principal
Événement
externe
Récupération
de données
L'interruption est quasi instantanée,
donc temps réel par essence si le processeur
ne tire pas ses données d’un cache.
Temps réel embarqué
IUT C.F., dép. Informatique
46
Les OS temps réel embarqués
Notions liées aux interruptions sous ITRON/4
• Notions C/C++ associées
–
variables volatiles, statiques et registres déclarées : volatile,
static, register
–
déclaration et gestion automatique par le noyau (ne pas utiliser
#pragma interrupt)
–
activation des interruptions gérée par le noyau
–
réalisation d'opérations atomiques par inhibition temporaire des
interruptions
–
utilisation de façon exclusive de fonctions réentrantes dans les
interruptions (fonctions n'utilisant pas de données temporaires
statiques ou globales)
Temps réel embarqué
IUT C.F., dép. Informatique
47
Les OS temps réel embarqués
Les fonctions particulières
• Gestion des interruptions
– Le noyau contient deux éléments indépendants
• L’ordonnanceur qui est une interruption liée au générateur de "tics" associée à une
fonction de sélection de tâche
• l'ensemble des fonctions OS qui appellent (en général) l’ordonnanceur.
– Les interruptions autres que celle du générateur de "tics" peuvent être
considérées comme indépendantes et s'exécuter à l'insu du noyau.
• Fonctions et handlers d'interruption
– Fonctions d'interruption : plus prioritaires que l'OS. Elles ne peuvent pas utiliser d’appel
système, mais peuvent être très rapides (périodicité de moins d'une µs).
– Handlers d'interruption : moins prioritaires que l'OS. Celles-là peuvent utiliser les
fonctions noyaux non bloquantes (il est exclu de bloquer une interruption) comme :
•
•
•
•
isnd_mbx()
isnd_dtq()
iset_flg()
isig_sem()
Temps réel embarqué
IUT C.F., dép. Informatique
48
Les OS temps réel embarqués
Les fonctions particulières
• Déclaration des interruptions dans l'interface de configuration
Temps réel embarqué
IUT C.F., dép. Informatique
49
Les OS temps réel embarqués
Les fonctions particulières
• Déclaration des interruptions dans le configurateur
• Déclaration des interruptions dans le code C
Les fonctions d’interruption doivent être déclarées comme des fonctions classiques car le noyau se
charge automatiquement de les faire gérer en tant qu’interruptions.
Temps réel embarqué
IUT C.F., dép. Informatique
50
Contrôle de l'ordonnanceur et des interruptions
• Problème de l'accès à une ressource unique partagée
– L'accès à la ressource doit être fait de façon atomique.
– Exemples :
• partage d'une variable lue et écrite en plusieurs étapes,
• partage d'un périphérique
• partage d'une fonction non réentrante
• Méthodes de réservation de l'accès
– Inhibition des interruptions
• Garantit l'atomicité mais augmente le temps de réponse aux interruptions.
– Utilisation d'un fanion, sémaphore ou mutex
• Un fanion, sémaphore ou mutex symbolise la ressource
• Le fanion, sémaphore ou mutex est géré avant et après l'utilisation de la ressource.
– Blocage de l'ordonnanceur
• Inhibe la préemption durant l'accès à la ressource.
Temps réel embarqué
IUT C.F., dép. Informatique
51
Les OS temps réel embarqués
Les fonctions particulières
• Contrôle de l'ordonnanceur
– L'ordonnanceur est déclenché soit par un événement externe (message,
sémaphore, création de tâche, changement de priorité d'une tâche, achèvement
d'un temps d'attente), soit par l'événement interne "tic" déclenché à périodicité
fixe définie au moment de l'initialisation.
– Les temps d'attente peuvent être générés par l’appel de dly_tsk(temps)
– Il est possible d'achever prématurément un temps d'attente par l'appel à la fonction
rel_wai(ID_tache)
– Il est possible d'inhiber l'ordonnanceur par loc_cpu(void) et de le déverrouiller par
unl_cpu(void).
N. B. : ces deux fonctions sont dangereuses !
Temps réel embarqué
IUT C.F., dép. Informatique
52
Les noyaux temps réel embarqués
Les fonctions particulières
• Obtenir des informations sur une tâche
– La fonction ref_tsk(ID_tache, T_RTSK *pk_rtsk) retourne les principaux éléments
de la structure de contrôle de la tâche désignée.
– Les informations contenues (exemple simplifié) sont les suivantes :
Temps réel embarqué
IUT C.F., dép. Informatique
53
Les OS temps réel embarqués
Les fonctions particulières
• Calcul des piles de tâches et système
– Dans les systèmes à microcontrôleur, la mémoire est très limitée. Pour en faire le
meilleur usage il convient de ne donner que le stricte nécessaire de pile à chaque
tâche. Pour cela il faut pouvoir mesurer l'utilisation de la pile.
– Il est possible de calculer l'utilisation de la pile de chaque tâche grâce à l’outil
Call Walker.
– Une fois l’utilisation de la pile de chaque tâche bien connu, il est possible
d’affecter ce qui est strictement nécessaire à chaque, tâche. En tout état de cause
le total de mémoire utilisé devra rester en-dessous de 96 ko dans le cas du
RX62N.
Temps réel embarqué
IUT C.F., dép. Informatique
54
Les OS temps réel embarqués
Les fonctions particulières
Calcul des piles de tâches et système dans le cas de ITRON/4
avec l'utilisation de l'utilitaire Call walker
Temps réel embarqué
IUT C.F., dép. Informatique
55
Les OS temps réel embarqués
Les fonctions particulières
Calcul des piles de tâches et système dans le cas de ITRON/4

La taille de la pile d'une tâche doit être la taille de la pile de chaque tâche + les
octets indiqués dans le tableau ci-après :
Temps réel embarqué
IUT C.F., dép. Informatique
56
Les OS temps réel embarqués
Les fonctions particulières
Calcul des piles de tâches et système dans le cas de ITRON/4
la taille de la pile système répond à la formule :
pile = appels_systèmes + somme_interruptions + arrêt_système, avec :









appels_systèmes = maxi des fonctions appelées (voir tableau transparents suivants)
somme_interruptions :
prendre le maximum de pile de chaque niveau d'interruption
pour l'interruption système prendre le maximum de :
196
maximum des handlers cycliques + 104
maximum des handlers d'alarme + 104
additionner les maximums de chaque niveau d'interruption
arrêt_système = 40 octets + pile de RI_sys_dwn()
Temps réel embarqué
IUT C.F., dép. Informatique
57
Les OS temps réel embarqués
Les fonctions particulières
Calcul de la pile système dans le cas de ITRON/4 : appels système
Appels
taille de pile système requise
vsta_knl
act_tsk, iact_tsk, sta_tsk, ista_tsk
ext_tsk
ter_tsk
sta_cyc, ista_cyc, stp_cyc, istp_cyc, (i)ref_cyc
chg_pri
ichg_pri
get_pri, iget_pri, ref_tst, iref_tst
slp_tsk, sus_tsk, isus_tsk, rsm_tsk, irsm_tsk
wu_tsk
dly_tsk
52
24
64
132
24
36
52
sig_sem
isig_sem
44
60
Temps réel embarqué
24
24
40
24
IUT C.F., dép. Informatique
58
Les OS temps réel embarqués
Les fonctions particulières
Calcul de la pile système dans le cas de ITRON/4 : appels système
Appels
taille de pile système requise
wai_sem
pol_sem, ipol_sem, ref_sem, iref_sem
32
snd_dtq
psnd_dtq, rcv_dtq, prcv_dtq
ipsnd_dtq, iprcv_dtq
ref_dtq, iref_dtq
36
32
snd_mbx
isnd_mbx
rcv_mbx
prcv_mbx , iprcv_mbx
ref_mbx, iref_mbx
40
Temps réel embarqué
24
52
24
56
32
28
24
IUT C.F., dép. Informatique
59
Les OS temps réel embarqués
Les fonctions particulières

Gestion des données dynamiques => gestion de la mémoire
– Etant donné la faiblesse des ressources en mémoire des microcontrôleurs, il est
indispensable de gérer la mémoire de façon dynamique dès que l’utilisation de
données statiques génère une pénurie, de façon efficace et sans ramasse miettes.
– Les fonctions C malloc() et free() ou directives C++ new et delete ne sont pas
adaptées dans le contexte d’un OS temps réel embarqué.
– Le dispositif est typiquement un arbre binaire nommé « buddy memory system »
qui tente l'allocation par dichotomie de blocs de plus en plus petits.
• L'allocation de petits espaces est impossible (< 64 octets).
• La recherche d'un espace libre peut prendre beaucoup de temps (parcours de
l'ensemble de l'arbre).
• Il peut être impossible d'obtenir un espace libre sur un tas à 90 % vide.
Temps réel embarqué
IUT C.F., dép. Informatique
60
Les OS temps réel embarqués
Les fonctions particulières
• Gestion des données dynamiques => gestion de la mémoire
– ITRON/4 propose d'anticiper sur le besoin de mémoire dynamique et de déclarer
les espaces que seront nécessaires en tant que ressource définie lors de la
configuration du système.
– On peut créer deux types de zones :
• « pool » : blocs de taille fixe (nombre et taille au choix du programmeur)
• « heap » : blocs de taille variable (nombre et taille maximale au choix)
– Lorsqu'on a besoin de mémoire dynamique, il suffit de demander un des blocs
(fixe ou de taille variable) préexistant, et s'il en reste un de libre, il est très
rapidement affecté à condition qu'on ait correctement configuré la mémoire
dynamique au départ.
Temps réel embarqué
IUT C.F., dép. Informatique
61