Le document présente les systèmes temps réel (STR), décrivant leur fonctionnement, leur architecture et la gestion des processus et tâches. Il aborde les différences entre les exécutions séquentielles et temps réel, ainsi que la création de tâches sous Unix utilisant des threads POSIX. Des exemples pratiques de code illustrent la création et la gestion des tâches, en mettant en avant l'importance de la synchronisation pour l'accès aux ressources partagées.

1. Système Temps réel
Introduction
Smati Abir
Page 1

2. • Il fournis des actions qui dirigent les activités d’un processus à des
instants bien précis.
• Le traitement du STR s’effectue en deux opérations:
 Collecte d’informations sur des objets externes.
 Traitement de données résultant en une commande de ces objets,
le but est de les forcer à produire un résultat physique au bout
d’un temps donné.
Page 2
Systèmes Temps Réel (STR)
commande
machine
action
STR
information

3. Page 3
Architecture STR
L’architecture est
basée sur deux
parties :
Partie matériel
(Hardware)
Analogique : CNA/CAN
(DAC/ADC), , …
Numérique : processeur,
registres, multiplieurs, …
Mémoire : DRAM, SRAM,
FLASH, …
Bus : bus d’adresse, bus de
données, bus de contrôle.
Partie logiciel
(Software)
Système d’exploitation (OS:
operating system), ou
programme.
Un STR est généralement associée à un
système embarqué.

4. Elle peut être basée sur:
• Un logiciel utilisé pour un nombre réduit de taches comme affichage
sur un écran, grafcet, commande d’un moteur…
• Un système d’exploitation (OS) si le nombre de tâches devient
important ou bien s’il y a des ressources partagées.
Page 4
La partie logicielle

5. • Elle peut être basée sur:
 Un monoprocesseur: les programmes s'exécutent d’une manière
séquentielle sur un seul processeur.
 Un multiprocesseur: les programmes sont répartis sur plusieurs
processeurs partageant une mémoire commune.
 Processeurs répartis: les programmes sont répartis sur plusieurs
processeurs dépourvus de mémoire commune et d'horloge
commune reliés par un bus.
Page 5
La partie Matérielle

6. Afin d’illustrer la différence entre une exécution séquentielle et une exécution temps réel
on donne le programme suivant:
Page 6
Programmation temps réel
J1: prg1
time
Séquentiel
J1,1 J2,1 J1,2 J1,3 J1,4
Temps réel J2,4
J2: prg2
J2,2 J2,3 J2,5 J1,5
void action1 ()
{ programme 1;
}
void action2 ()
{ programme 2;
}
int main ()
{ Action1(); // exécution prg 1
Action2(); // exécution prg 2
}

7. Processus et tâches sous POSIX
Page 7

8.  Processus (Pri): s’active suite au lancement d’un programme ou un sous
programme. Il est constitué d’un ensemble de Taches à exécuter et se termine
quand la dernière tache se termine.
Exp: Pri=le maintient d’une altitude constante d’un avion.
Pri s’active suite au lancement du pilote automatique de l’avion.
 Tâche (task or Job or thread, Ji) : c’est une des actions démarrés par un
processus.
Exp: L’ensemble des taches constituant Pri={J1,J2,J3,J4,……}
J1:mesurer vitesse air, J2: détecter la direction du vent, J3: diriger aile droite,
J4:diriger aile gauche, J5: commander la vitesse du réacteur droit.
Page 8
Processus et Tâche

9. • Une tâche est identifiée par 4 attributs:
 Contexte d’exécution : c’est l’ensemble des ressources matériels utilisées
comme les registres du processeur, pile exécution, les timers,…
 Priorité. (par rapport à une autre tâche)
 Etat d’exécution: prêt, en cours, en suspend ou en attente.
 Etat de préemption (préemptible ou pas) : apte à être interrompue par une autre
tâche.
• Une tâche peut prendre
l’un de ces 4 états:
Page 9
Processus et Tâche
en
suspend suspendre
suspendre suspendre
activation
En cour
d’exécution

10. Création d’une tâche sous UNIX
• Lors de la création d’une tâche sous UNIX on utilise généralement le terme POSIX
thread ou pthread.
• La bibio. pthread (pthread.h) contient un ensemble de fonctions et des constantes
programmées en language C.
• Les procédures sous cette biblio sont précédés par le terme « pthread_ »:
 int pthread_create(pthread_t *nom_de_la_tache, const pthread_attr_t *attr,
void *(*action_de_la_tache) (void*),void *arg ) :
- Crée une tâche commençant par lui attribuer une identification.
- Exécution de la fonction action_de_la_tache avec arg comme argument.
 int pthread_join(pthread_t nom_de_la_tache, void ** val_de_retour):
- Elle suspend l’exécution du prog principale jusqu’à l’exécution de la tâche.
- Si le second argument est différent de NULL alors val_de_retour pointe à
l’emplacement de la valeur retourné par la tache.

11. Création d’une tâche sous UNIX
Structure du programme:
#include <pthread.h>
void *action_de_la_tache (void ); // déclaration de la fonction exécutant la tâche
void main ( )
{
pthread_t nom_de_la_tache; // déclaration de la tâche
programme principal
pthread_create(…….); // en mettant *attr=NULL la fonction utilisera des attributs par défauts.
continuation du prg principal; // à ce niveau le prog main et la tâche s’exécutent simultanément.
pthread_join(…..); // le prg main est suspendu, attend la fin de l’exécution de la tâche puis continu.
continuation du prg principal;
}
void *action_de_la_tache (void *arg)
{ programme de la tâche; }

12. Création d’une tâche sous UNIX
Exemple : tâche exécutant une fct sans arguments:
# include <stdio.h>
#include <pthread.h>
void *action (); // déclaration de la fct de la tâche
void main ( )
{
pthread_t tache; // déclaration du nom de la tâche
printf(’’ avant la tache n ’’);
pthread_create(&tache, NULL, action, NULL); // la fct action n’a pas d’argument.
printf( ‘’ aprés la tache’’ n); // à ce niveau le prg main et la tâche s’exécutent simultanément.
pthread_join(tache, NULL);// le résultat de la fct action ne retourne rien.
}
void *action () // la fct action n’a pas d’argument.
{ printf( ‘’ hello’’ n); }

13. Création d’une tâche sous UNIX
Remarque : changer l’emplacement de pthread_join(), qu’est ce qui se passe?
# include <stdio.h>
#include <pthread.h>
void *action ();
void main ( )
{
pthread_t tache;
printf(’’ avant la tache n ’’);
pthread_create(&tache, NULL, action, NULL);
printf( ‘’ aprés la tache’’ n);
pthread_join(tache, NULL);
}
void *action ()
{ printf( ‘’ hello’’ n); }

14. Création de plusieurs tâches.
Structure du programme: cas de tâches modifiant une même variable.
#include <pthread.h>
Type variable; // déclaration de la variable dans le prg principale.
void *action1 (void *arg)
{ programme de la tâche modifiant la variable; }
void *action2 (void *arg)
{ programme de la tâche modifiant la variable; }
void main ( )
{
pthread_t tache1, tache2, … ; // déclaration des tâches
pthread_create(tache1,…,action1,...); // création et exécution de la tache1.
pthread_create(tache2, ,…,action2,...); // création et exécution de la tache2.
…
pthread_join(tache1,…..);
pthread_join(tache2,…..);
…
}
// Comment est géré l’accès de chaque tâche à la ressource?
// l’accès à la ressource n’est pas organisé, le résultat finale est imprévisible, il faut synchroniser.

15. Fin de tâche.