SlideShare une entreprise Scribd logo
Noyau temps réel Freertos
présenté par:
m. cheriet mohammed el amine
mail:
microcheriet@gmail.com
Plan
1. Notions de base sur les systèmes temps réel
2. Le noyau temps réel FreeRTOS
3. Atelier:
ØEnvironnement de développement Arduino IDE
ØCréation de trois taches périodiques
ØSémaphore mutex
ØSémaphore binaire
ØFile d’attente
2
Notions de bases sur les systèmes temps réel
Ø le besoin de diminuer le temps de développement des systèmes embarqués,
Ø le degré élevé de complexité a imposé l’utilisation d’un système d’exploitation temps réel
(SETR ou RTOS) ou d’un noyau temps réel (NTR).
C’est pour cela qu’on peut dire que le RTOS est l’essence même d’un système embarqué.
Ø le besoin de diminuer le temps de développement des systèmes embarqués,
Ø le degré élevé de complexité a imposé l’utilisation d’un système d’exploitation temps réel
(SETR ou RTOS) ou d’un noyau temps réel (NTR).
C’est pour cela qu’on peut dire que le RTOS est l’essence même d’un système embarqué.
3
L’intérêt d’utilisation d’un noyau temps réel:L’intérêt d’utilisation d’un noyau temps réel:
Ø Un système temps réel n’est pas un système «qui va vite / rapide » mais un système qui
satisfait des contraintes temporelles
ØUn système temps réel ne repose pas que sur l'aboutissement des traitements, il remplit son
rôle lorsqu'il est en mesure de satisfaire toutes les contraintes de temps auxquelles il est
soumis.
ØUn non respect est assimilé à une sévère panne logicielle
Ø Un système temps réel n’est pas un système «qui va vite / rapide » mais un système qui
satisfait des contraintes temporelles
ØUn système temps réel ne repose pas que sur l'aboutissement des traitements, il remplit son
rôle lorsqu'il est en mesure de satisfaire toutes les contraintes de temps auxquelles il est
soumis.
ØUn non respect est assimilé à une sévère panne logicielle
““MêmeMême la bonne réponse est fausse si elle arrive trop tard”la bonne réponse est fausse si elle arrive trop tard”““MêmeMême la bonne réponse est fausse si elle arrive trop tard”la bonne réponse est fausse si elle arrive trop tard”
Notions de bases sur les systèmes temps réel
4
Système temps réelSystème temps réel
MultitâcheMultitâche permet d'effectuer à l'échelle humaine plusieurs tâches simultanément.
l'utilisateur peut alors diviser son projet en plusieurs tâches indépendantes.
Au niveau du processeur, une seule tâche est effectuée à la fois en revanche le
multitâche permet d'éliminer les temps machines inutilisés (boucle d'attente, de
scrutation...).
permet d'effectuer à l'échelle humaine plusieurs tâches simultanément.
l'utilisateur peut alors diviser son projet en plusieurs tâches indépendantes.
Au niveau du processeur, une seule tâche est effectuée à la fois en revanche le
multitâche permet d'éliminer les temps machines inutilisés (boucle d'attente, de
scrutation...).
Temps réelTemps réel Répondre à un événement dans un temps déterminé afin de satisfaire toutes
les contraintes de temps
Répondre à un événement dans un temps déterminé afin de satisfaire toutes
les contraintes de temps
- un ensemble de fonctionnalités, regroupées sous le terme de SERVICES
- Gérer l'occupation du processeur, l’accès au ressources, synchronisations et
communication entre les taches, gestion des E/S et des interruptions
- un ensemble de fonctionnalités, regroupées sous le terme de SERVICES
- Gérer l'occupation du processeur, l’accès au ressources, synchronisations et
communication entre les taches, gestion des E/S et des interruptions
NoyauNoyau
Notions de bases sur les systèmes temps réel
5
Noyau multitâches temps réel:Noyau multitâches temps réel:
Répondre à un événement dans un temps déterminé ,tout en respectant les
limites de temps autorisé
Répondre à un événement dans un temps déterminé ,tout en respectant les
limites de temps autorisé
ÉchéancesÉchéances
La latence est le temps qui peut exister entre le moment ou un événement
est survenu et celui ou il est effectivement traité.
La latence est le temps qui peut exister entre le moment ou un événement
est survenu et celui ou il est effectivement traité.
Les latencesLes latences
est la capacité d'interrompre l'exécution d'une tâche en faveur de
l'exécution d'une autre tâche.
est la capacité d'interrompre l'exécution d'une tâche en faveur de
l'exécution d'une autre tâche.
La préemptionLa préemption
Ø L‘ordonnanceur mène un arbitrage pour décider quel tâche doit
s'exécuter.
Ø le mécanisme d'ordonnancement des tâches repose sur la capacité du
système à préempté la tâche en cours.
Ø L‘ordonnanceur mène un arbitrage pour décider quel tâche doit
s'exécuter.
Ø le mécanisme d'ordonnancement des tâches repose sur la capacité du
système à préempté la tâche en cours.
L‘ordonnanceurL‘ordonnanceur
Notions de bases sur les systèmes temps réel
6
Contraintes de temps :Contraintes de temps :
le non respect des échéances peut entraîner des graves problèmes
Ex.: contrôle de trafic aérien, système de conduite de missile,… etc
le non respect des échéances peut entraîner des graves problèmes
Ex.: contrôle de trafic aérien, système de conduite de missile,… etc
Temps réel durTemps réel dur
Les échéances peuvent ne pas être respectées. Les exigences de temps se
présentent sous la forme d'un ou plusieurs intervalles
Ex.: domaines du multimédia projection vidéo
Les échéances peuvent ne pas être respectées. Les exigences de temps se
présentent sous la forme d'un ou plusieurs intervalles
Ex.: domaines du multimédia projection vidéo
Temps réel mouTemps réel mou
Notions de bases sur les systèmes temps réel
7
Contraintes Classification:Contraintes Classification:
Contraintes Classification d’un système temps réel
Notions de bases sur les systèmes temps réel
8
L'ordonnancementL'ordonnancement
Seuls les noyaux préemptifs pourront être considérés commeSeuls les noyaux préemptifs pourront être considérés comme
véritablement temps réel.véritablement temps réel.
Seuls les noyaux préemptifs pourront être considérés commeSeuls les noyaux préemptifs pourront être considérés comme
véritablement temps réel.véritablement temps réel.
Noyaux temps réel
préemptifs
Noyaux temps réel
préemptifs
Øla tâche peut à tout instant perdre le contrôle
du processeur au profit d'une tâche de
priorité supérieure.
Ø La tâche qui perd le processeur n'a aucune
possibilité de le savoir. C’est
l'ordonnanceur qui prend cette décision.
Øla tâche peut à tout instant perdre le contrôle
du processeur au profit d'une tâche de
priorité supérieure.
Ø La tâche qui perd le processeur n'a aucune
possibilité de le savoir. C’est
l'ordonnanceur qui prend cette décision.
Noyaux temps réel
coopératifs
Noyaux temps réel
coopératifs
Øla tâche est exécutée jusqu'à ce qu'elle fasse
appel à un service du noyau.
Ø Selon la situation présente, le scheduler
décide si la tâche doit se poursuivre ou
non.
Øla tâche est exécutée jusqu'à ce qu'elle fasse
appel à un service du noyau.
Ø Selon la situation présente, le scheduler
décide si la tâche doit se poursuivre ou
non.
Notions de bases sur les systèmes temps réel
9
Le noyau temps réel
FreeRTOS
L'ordonnancement
FreeRTOS
Ordonnancement
circulaire
Ordonnancement
circulaire
Ordonnancement
par priorité
Ordonnancement
par priorité
Ordonnancement par priorité
avec files multiples
Ordonnancement par priorité
avec files multiples
ØToutes les tâches ont le même niveau de priorité.
ØChaque tâche prête à l'exécution se voit attribuer le processeur pendant
une durée fixée initialement. A l'expiration de ce temps, une
commutation a lieu et ainsi de suite pour toutes les tâches prêtes.
ØToutes les tâches ont le même niveau de priorité.
ØChaque tâche prête à l'exécution se voit attribuer le processeur pendant
une durée fixée initialement. A l'expiration de ce temps, une
commutation a lieu et ainsi de suite pour toutes les tâches prêtes.
Ordonnancement
circulaire
Ordonnancement
circulaire
FreeRTOS offre trois possibilités d'ordonnancement:
Le noyau temps réel FreeRTOS
11
ØChaque tâche reçoit, lors de sa création, un niveau de priorité. L'ordonnanceur
lance la tâche prête, la plus prioritaire. Celle-ci conserve le processeur tant
qu'elle n'est pas terminée ou bloquée.
ØChaque tâche reçoit, lors de sa création, un niveau de priorité. L'ordonnanceur
lance la tâche prête, la plus prioritaire. Celle-ci conserve le processeur tant
qu'elle n'est pas terminée ou bloquée.
Ordonnancement
par priorité
Ordonnancement
par priorité
ØLe principe consiste à combiner l'ordonnancement circulaire (sans quantum) et
l'ordonnancement par priorité, plusieurs tâches peuvent coexister au même
niveau de priorité. Si plusieurs tâches sont présentes dans la file de plus forte
priorité, une de ces tâches est en exécution.
ØLe principe consiste à combiner l'ordonnancement circulaire (sans quantum) et
l'ordonnancement par priorité, plusieurs tâches peuvent coexister au même
niveau de priorité. Si plusieurs tâches sont présentes dans la file de plus forte
priorité, une de ces tâches est en exécution.
Ordonnancement
par priorité avec
files multiples
Ordonnancement
par priorité avec
files multiples
Le noyau temps réel FreeRTOS
12
Le noyau temps réel FreeRTOS
ANTR préemptif, coopératif(configuration )
 23 architectures de microcontrôleurs
 la taille du noyau (4K à 9K octets).
 Prend en charge les tâches et les co-routines.
 Pas de restriction logicielle sur le nombre de tâches qui peuvent être crées
 Pas de restriction logicielle sur le nombre de priorités qui peuvent être utilisés.
A plus d'une tâche peut être attribuée la même priorité.
 La gestion des taches :
c’est un service du noyau, dont le rôle est d'offrir à l'application les fonctions nécessaires
à la gestion des taches.
 La gestion du temps :
Il répond à l'interruption du TIMER 1 afin de mettre à jour périodiquement les alarmes et
compteurs associées aux tâches.
 La synchronisation et la communication entre taches :
Files d'attente, sémaphores binaires, sémaphores compteurs, des sémaphores récursifs
et des mutexes
 La gestion d'interruption :
-l'activation et la désactivation des interruptions du système.
-Un périphérique peut communiquer avec une tâche grâce aux ISR
13
Le noyau temps réel FreeRTOS
FreeRTOSConfig.h
#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H
#include <p18cxxx.h>
#define configUSE_PREEMPTION 1
#define configUSE_IDLE_HOOK 0
#define configUSE_TICK_HOOK 0
#define configCPU_CLOCK_HZ ( ( unsigned long ) 20000000 )
#define configTICK_RATE_HZ ( ( portTickType ) 1000 )
#define configMAX_PRIORITIES ( ( unsigned portBASE_TYPE ) 4 )
#define configMINIMAL_STACK_SIZE 128
#define configTOTAL_HEAP_SIZE ( ( size_t ) 1024 )
#define configMAX_TASK_NAME_LEN 16
#define configUSE_TRACE_FACILITY 0
#define configUSE_16_BIT_TICKS 1
#define configIDLE_SHOULD_YIELD 1
#define configUSE_MUTEXES 0
/* Co-routine definitions. */
#define configUSE_CO_ROUTINES 0
#define configMAX_CO_ROUTINE_PRIORITIES 2
/* Set the following definitions to 1 to include the API function, or
zero to exclude the API function. */
#define INCLUDE_vTaskDelete 1
#define INCLUDE_vTaskCleanUpResources 0
#define INCLUDE_vTaskSuspend 1
#define INCLUDE_vResumeFromISR 1
#define INCLUDE_vTaskDelayUntil 1
#define INCLUDE_vTaskDelay 1
#endif /* FREERTOS_CONFIG_H */
1 :le noyau préemptif,
0: le noyau coopératif.
1 :le noyau préemptif,
0: le noyau coopératif.
La fréquence de l'interruption
de Tick d’horloge.(1ms)
La fréquence de l'interruption
de Tick d’horloge.(1ms)
Inclue les services du noyau
utilisés par votre application
Inclue les services du noyau
utilisés par votre application
La quantité totale de RAM
disponible pour le noyau.
La quantité totale de RAM
disponible pour le noyau.
La priorité maximale des taches
disponibles à l’application
La priorité maximale des taches
disponibles à l’application
14
Gestion Des Tâches
Dans FreeRTOS
Gestion Des Tâches Dans FreeRTOS
Une tâche est un programme ou une partie de programme en exécution.
Tâches matérielles tâches soumises à de fortes contraintes de temps notifier par des
interruptions
Exemple: la réception de caractères d’un clavier sur la ligne RS232
Tâches logicielles programmées soit dans une boucle de scrutation(monotâche), ou de façon
indépendante (multitâche principe utilisé)
Tâches matérielles tâches soumises à de fortes contraintes de temps notifier par des
interruptions
Exemple: la réception de caractères d’un clavier sur la ligne RS232
Tâches logicielles programmées soit dans une boucle de scrutation(monotâche), ou de façon
indépendante (multitâche principe utilisé)
16
Gestion Des Tâches Dans FreeRTOS
Structures d’une TâcheStructures d’une Tâche void vATaskFunction( void *pvParameters )
{
for( ;; )
{
-- code de la tâche --
}
}
FreeRTOS gère le contrôle du processeur en attribuant ce dernier à la tâche de plus grande
priorité en attente d'exécution.
Priorité d’une tâche
Lors de la création , chaque tâche est assignée a une priorité de 0(niveau bas) à
configMAX_PRIORITIES - 1(niveau haut)
Le configMAX_PRIORITIES est défini dans le fichier header
La tâche oisive (idle task) a la priorité 0
Priorité d’une tâche
Lors de la création , chaque tâche est assignée a une priorité de 0(niveau bas) à
configMAX_PRIORITIES - 1(niveau haut)
Le configMAX_PRIORITIES est défini dans le fichier header
La tâche oisive (idle task) a la priorité 0
17
Gestion Des Tâches Dans FreeRTOS
Etat “ en exécution ” (Running)
Une tâche en exécution a le contrôle du processeur
et exécute son code.
Etat “ en exécution ” (Running)
Une tâche en exécution a le contrôle du processeur
et exécute son code.
Etat “ prête à l'exécution ”(Ready)
Une tâche prête à l'exécution est candidate à
l'attribution du processeur.
Etat “ prête à l'exécution ”(Ready)
Une tâche prête à l'exécution est candidate à
l'attribution du processeur.
Dans un environnement multitâche, les tâches peuvent être dans un des quatre états :
Etat “ Bloqué ”(Blocked)
Une tâche est dans l'état bloqué si elle attend un
événement temporel ou externe.
Etat “ Bloqué ”(Blocked)
Une tâche est dans l'état bloqué si elle attend un
événement temporel ou externe.
Etat “ Suspendu ”(Suspended)
Une tâche suspendue n'est pas candidate à
l'attribution du processeur.
Etat “ Suspendu ”(Suspended)
Une tâche suspendue n'est pas candidate à
l'attribution du processeur.
Etat d’une tache dans FreeRTOS
18
18
Gestion Des Tâches Dans FreeRTOS
• xTaskCreate créer une tâche
• vTaskDelete supprimer une tâche
• vTaskSuspend suspendre une tâche
• vTaskResume faire reprendre (suspended -> ready) une tâche suspendue par un
vTaskSuspend
• vTaskDelay suspendre une tâche pendant une durée.
• vTaskDelayUntil suspendre une tâche pendant une durée déterminée (fréquence fixe)
• vTaskPrioritySet changer la priorité d'une tâche
• uxTaskPriorityGet se renseigner sur la priorité d’une tâche
• vTaskEndScheduler invalider la “ rescheduling procedure ”
• vTaskStartScheduler valider la “ rescheduling procedure ”
• xTaskCreate créer une tâche
• vTaskDelete supprimer une tâche
• vTaskSuspend suspendre une tâche
• vTaskResume faire reprendre (suspended -> ready) une tâche suspendue par un
vTaskSuspend
• vTaskDelay suspendre une tâche pendant une durée.
• vTaskDelayUntil suspendre une tâche pendant une durée déterminée (fréquence fixe)
• vTaskPrioritySet changer la priorité d'une tâche
• uxTaskPriorityGet se renseigner sur la priorité d’une tâche
• vTaskEndScheduler invalider la “ rescheduling procedure ”
• vTaskStartScheduler valider la “ rescheduling procedure ”
Appels-système pour gestion des tâches logiciellesAppels-système pour gestion des tâches logicielles
19
Gestion Des Tâches Dans FreeRTOS
Création de tâcheCréation de tâche L'appel système xtaskcreate() permettre la création d'une nouvelle tâche
la tache créée est placée dans la file des tâches qui sont prêtes à l’exécution
portBASE_TYPE xTaskCreate(
pdTASK_CODE pvTaskCode,
const portCHAR * const pcName,
unsigned portSHORT usStackDepth,
void *pvParameters,
unsigned portBASE_TYPE uxPriority,
xTaskHandle *pvCreatedTask
);
Example
xTaskCreate( tache_ADC ,"ADC", 105,( void * ) NULL, 1 , &xHandle_ADC );
La tache return pdPASS si elle a était créée avec succès ,si non pdFALSE.
L'appel système xtaskcreate() permettre la création d'une nouvelle tâche
la tache créée est placée dans la file des tâches qui sont prêtes à l’exécution
portBASE_TYPE xTaskCreate(
pdTASK_CODE pvTaskCode,
const portCHAR * const pcName,
unsigned portSHORT usStackDepth,
void *pvParameters,
unsigned portBASE_TYPE uxPriority,
xTaskHandle *pvCreatedTask
);
Example
xTaskCreate( tache_ADC ,"ADC", 105,( void * ) NULL, 1 , &xHandle_ADC );
La tache return pdPASS si elle a était créée avec succès ,si non pdFALSE.
Exemple de création d’une tache dans FreeRTOSExemple de création d’une tache dans FreeRTOS
20
Gestion Des Tâches Dans FreeRTOS
Ø Une ISR s'exécute lorsqu'une interruption matérielle est générée.
Ø FreeRTOS fournit le moyen aux routines d'interruptions (ISR) de l'application pour
communiquer et d'influer sur l'ordonnancement des tâches critiques.
Ø Une ISR s'exécute lorsqu'une interruption matérielle est générée.
Ø FreeRTOS fournit le moyen aux routines d'interruptions (ISR) de l'application pour
communiquer et d'influer sur l'ordonnancement des tâches critiques.
Exemple:
 xQueueSendFromISR communiquer des messages aux tâches
 xQueueReceiveFromISR recevoir des messages des tâches
 xSemaphoreGiveFromISR pour libérer un sémaphore
 xTaskResumeFromISR reprendre une tâche suspendue
Exemple:
 xQueueSendFromISR communiquer des messages aux tâches
 xQueueReceiveFromISR recevoir des messages des tâches
 xSemaphoreGiveFromISR pour libérer un sémaphore
 xTaskResumeFromISR reprendre une tâche suspendue
Ø Les tâches logicielles de l'application sont gérées d’une manière synchrone par FreeRTOS,
Ø une routine d'interruption est exécutée d’une manière asynchrone et non gérée par
FreeRTOS
Ø Les tâches logicielles de l'application sont gérées d’une manière synchrone par FreeRTOS,
Ø une routine d'interruption est exécutée d’une manière asynchrone et non gérée par
FreeRTOS
Reprise d'une tâche
suspendue par ISR
Reprise d'une tâche
suspendue par ISR
portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume );portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume );
Gestion des tâches matérielles (interruptions)Gestion des tâches matérielles (interruptions)
21
Communication et
Synchronisation entre Tâches
Communication et Synchronisation entre Tâches
Ø Le mécanisme de communication disponible dans FreeRTOS est celui de la file d’attente.
Ø
Ø Le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case
par la tâche “ récepteur ”.
Ø
Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les
interruptions et les tâches.
Ø
Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication
et de synchronisation entre tâches.
-
Ø Le mécanisme de communication disponible dans FreeRTOS est celui de la file d’attente.
Ø
Ø Le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case
par la tâche “ récepteur ”.
Ø
Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les
interruptions et les tâches.
Ø
Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication
et de synchronisation entre tâches.
-
Gestion des files d’attente de message (queue)Gestion des files d’attente de message (queue)
23
Communication et Synchronisation entre Tâches
Ø Le sémaphore permet la synchronisation entre tâches et permet aussi de traiter l'exclusion
mutuelle avec accès multiples simultanés.
Ø Le sémaphore sem est constitué par une variable entière S et une file d'attente F.
Ø Dans le noyau FreeRTOS, il existe deux types de sémaphores :
§ Sémaphore Binaire (de valeur 0 ou 1)
§ Sémaphore Compteur (de valeur 0 à max)
Ø Le sémaphore permet la synchronisation entre tâches et permet aussi de traiter l'exclusion
mutuelle avec accès multiples simultanés.
Ø Le sémaphore sem est constitué par une variable entière S et une file d'attente F.
Ø Dans le noyau FreeRTOS, il existe deux types de sémaphores :
§ Sémaphore Binaire (de valeur 0 ou 1)
§ Sémaphore Compteur (de valeur 0 à max)
Les sémaphoresLes sémaphores
24
Communication et Synchronisation entre Tâches
Sémaphore BinaireSémaphore Binaire
Ø Les sémaphores binaires sont utilisés pour la synchronisation.
Ø Il est considérer comme un "drapeau" servant à signaler l'arrivée d'un événement.
Ø Penser à un sémaphore binaire comme file d'attente qui peut seulement tenir un
élément(vide ou plein -binaire).
Ø Les sémaphores binaires sont utilisés pour la synchronisation.
Ø Il est considérer comme un "drapeau" servant à signaler l'arrivée d'un événement.
Ø Penser à un sémaphore binaire comme file d'attente qui peut seulement tenir un
élément(vide ou plein -binaire).
Ø Les sémaphores compteurs sont principalement utilisés pour la gestion des ressources
Ø La valeur compteur du sémaphore indique le nombre de ressources disponibles.
Ø Les sémaphores compteurs sont principalement utilisés pour la gestion des ressources
Ø La valeur compteur du sémaphore indique le nombre de ressources disponibles.
Sémaphore compteursSémaphore compteurs
25
Communication et Synchronisation entre Tâches
Ø Les sémaphores mutex sont utilisés pour l'exclusion mutuelle(le moyen d'interdire l'accès
simultané à une ressource critique )
Ø Les sémaphores mutex sont utilisés pour l'exclusion mutuelle(le moyen d'interdire l'accès
simultané à une ressource critique )
Sémaphore d'exclusion Mutuelle (Mutexes)Sémaphore d'exclusion Mutuelle (Mutexes)
26
ATELIER FreeRTOS
Ø Environnement de développement Arduino IDE
Ø Création de trois taches périodiques
Ø Sémaphore mutex
Ø Sémaphore binaire
Ø File d’attente
Arduino IDE
Ouvrez Arduino IDE Ouvrez l’exemple Blink
28
Environnement de développement Arduino IDE
Arduino IDE
Choisissez le port COM qui correspond
à votre plateforme
Choisissez le type de plateforme Arduino
29
Environnement de développement Arduino IDE
Arduino IDE
Programme en C++
Compilez le programme
Compilation sans
erreurs
Chargez le programme dans
Arduino
Clignotement des LEDs Tx et Rx
durant le transfère du
programme
30
Environnement de développement Arduino IDE
Exemple FreeRTOS dans
Arduino
Création de trois taches
périodiques
Création de trois taches périodiques
Création de trois taches périodiques
Lancement de l'ordonnancement
vTaskStartScheduler();
Tache 1
Tache 2 Tache 3
33
void Tache_1(void * pvParameters )
{
while (1)
{
Blink_LED(13, 100);
vTaskDelay(120);
}
}
void Tache_2(void * pvParameters )
{
while (1)
{
Blink_LED(12, 200);
vTaskDelay(400);
}
}
void Tache_3(void * pvParameters )
{
while (1)
{
Blink_LED(11, 200);
vTaskDelay(200);
}
}
//--------------------Création des taches ---------------------------
xTaskCreate(Tache_1, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
xTaskCreate(Tache_2, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
xTaskCreate(Tache_3, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
//--------------------- Lancement de l'ordonnancement ---------------
vTaskStartScheduler();
Tache 1 Tache 2 Tache 3
Création des tache et lancement de l'Ordonnanceur
Création de trois taches périodique
34
Exemple : Sémaphore mutex
Sémaphore mutex
Ø Le sémaphore mutex est principalement utilisés pour la Gestion des ressources.Ø Le sémaphore mutex est principalement utilisés pour la Gestion des ressources.
36
Sémaphore MUTEX
Création des taches et du sémaphore
Mutex
Lancement de l'ordonnancement
vTaskStartScheduler();
Tache 1
Ressource partagée et non
partageable:
UART (port série)
ou
convertisseur analogique
etc.
Sémaphore Mutex
Tache 2 Tache 3
Création de sémaphore mutex dans
FreeRTOS
Création de sémaphore mutex dans
FreeRTOS
xSemaphoreHandle xSemaphoreCreateMutex( void )xSemaphoreHandle xSemaphoreCreateMutex( void )
37
Sémaphore MUTEX
la tâche prend le Sémaphore pour entrer dans la section critique en utilisant la ressource citrique.la tâche prend le Sémaphore pour entrer dans la section critique en utilisant la ressource citrique.
(xSemaphore ): La poignée du sémaphore prise.
(xBlockTime) : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se bloque
en attendant la disponibilité du sémaphore.
xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime )xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime )
Prendre le SémaphorePrendre le Sémaphore
38
Sémaphore MUTEX
xSemaphore : La poignée du sémaphore prise.
xBlockTime : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se bloque
en attendant la disponibilité du sémaphore.
xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime )xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime )
xSemaphoreGiveFromISR(xSemaphoreHandle xSemaphore, signed portBASE_TYPE *pxHigherPriorityTaskWoken )xSemaphoreGiveFromISR(xSemaphoreHandle xSemaphore, signed portBASE_TYPE *pxHigherPriorityTaskWoken )
A partir d’une routine d’interruption(ISR)A partir d’une routine d’interruption(ISR)
Libérer le SémaphoreLibérer le Sémaphore
la tâche libére le Sémaphore pour sortir de la section critique en donnant un droit d'accès
supplémentaire.
la tâche libére le Sémaphore pour sortir de la section critique en donnant un droit d'accès
supplémentaire.
39
Exemple : Sémaphore binaire
Sémaphore binaire
Ø Les sémaphores binaires sont utilisés pour la synchronisation.
Ø Il est considéré comme un "drapeau" servant à signaler l'arrivée d'un événement.
Ø un sémaphore binaire est comme file d'attente qui peut seulement tenir un élément.
Ø Les sémaphores binaires sont utilisés pour la synchronisation.
Ø Il est considéré comme un "drapeau" servant à signaler l'arrivée d'un événement.
Ø un sémaphore binaire est comme file d'attente qui peut seulement tenir un élément.
41
Sémaphore binaire
Création des taches et du sémaphore
binaire
Lancement de l'ordonnancement
vTaskStartScheduler();
Tache 1 Tache 2
Sémaphore
binaire
Création de sémaphore binaire dans
FreeRTOS
Création de sémaphore binaire dans
FreeRTOS
vSemaphoreCreateBinary(xSemaphoreHandle xSemaphore)
(xSemaphore ): La poignée (handle) du
sémaphore créé.
vSemaphoreCreateBinary(xSemaphoreHandle xSemaphore)
(xSemaphore ): La poignée (handle) du
sémaphore créé.
42
Exemple : File d’attente
File d’attente
Ø le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case par la
tâche “ récepteur ”.
Ø
Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les interruptions et
les tâches.
Ø
Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication et de
synchronisation entre tâches.
Ø le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case par la
tâche “ récepteur ”.
Ø
Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les interruptions et
les tâches.
Ø
Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication et de
synchronisation entre tâches.
44
File d’attente
Ø L’ordre dans lequel les tâches recevront les messages est par priorité ou la tâche la plus prioritaire
sera desservie.
Ø
Ø Les files d'attente peuvent contenir des « éléments » de taille fixe, la taille de chaque élément et le
nombre maximum des éléments de la file d'attente sont définis quand la file d'attente est créée.
Ø L’ordre dans lequel les tâches recevront les messages est par priorité ou la tâche la plus prioritaire
sera desservie.
Ø
Ø Les files d'attente peuvent contenir des « éléments » de taille fixe, la taille de chaque élément et le
nombre maximum des éléments de la file d'attente sont définis quand la file d'attente est créée.
45
File d’attente
xQueueHandle xQueueCreate(unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize );xQueueHandle xQueueCreate(unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize );
(uxQueueLength) : le nombre maximum de message que la file d'attente peut contenir.
(uxltemsize) : la taille en octet de l'item à stocker dans la file.
Retours : Si la file d'attente est crée avec succès, une poignée pour la file d'attente est retournée.
Ø la tâche poste le message et poursuit son code si la file d’attente est vide
Ø La tâche productrice du message peut être suspendue (timeout) si la file d’attente est pleine ;
ceci permet de réaliser un mécanisme de synchronisation
Ø Si le message à poster est très long, on peut poster un pointeur sur celui-ci.
Ø la tâche poste le message et poursuit son code si la file d’attente est vide
Ø La tâche productrice du message peut être suspendue (timeout) si la file d’attente est pleine ;
ceci permet de réaliser un mécanisme de synchronisation
Ø Si le message à poster est très long, on peut poster un pointeur sur celui-ci.
void vQueueDelete( xQueueHandle xQueue );void vQueueDelete( xQueueHandle xQueue );
Poster un messagePoster un message
Création de la fileCréation de la file
Suppression de la fileSuppression de la file
46
File d’attente
Poster un message au début de la file :Poster un message au début de la file :
portBASE_TYPE xQueueSend ( xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait);portBASE_TYPE xQueueSend ( xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait);
(xQueue) : La poignée de la file d’attente
(pvItemToQueue) :Un pointeur vers l'élément qui doit être placé dans la file d'attente.
(xTicksToWait) : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se
bloque si la file d'attente est pleine.
00 : la tâche poursuit son code(pas d’attente)
portMAX_DELAY:portMAX_DELAY: la tâche émettrice se bloquer jusqu'à la présence du message.
Poster un message à la fin de la file :Poster un message à la fin de la file :
portBASE_TYPE xQueueSendToFront(xQueueHandle xQueue ,const void *pvItemToQueue, portTickType xTicksToWait);portBASE_TYPE xQueueSendToFront(xQueueHandle xQueue ,const void *pvItemToQueue, portTickType xTicksToWait);
47
File d’attente
Poster un message à partir d’une routine d'interruption (ISR):Poster un message à partir d’une routine d'interruption (ISR):
portBASE_TYPE xQueueSendFromISR (xQueueHandle pxQueue, const void *pvItemToQueue, portBASE_TYPE
*pxHigherPriorityTaskWoken);
portBASE_TYPE xQueueSendFromISR (xQueueHandle pxQueue, const void *pvItemToQueue, portBASE_TYPE
*pxHigherPriorityTaskWoken);
Ø La tâche “ récepteur ” récupère le message si la file d’attente n’est pas vide.
Ø Si la file d’attente est vide, la tâche est suspendue, soit pour une durée précisée (timeout), soit
jusqu'à ce qu'un message soit présent dans la file.
Ø Si aucun message n'est présent après la durée d'attente précisée (timeout), la tâche reprend son
exécution et un message d'erreur est émis.
Ø plusieurs tâches peuvent attendre devant la même file d’attente . la plus prioritaire qui recevra
le message.
Ø La tâche “ récepteur ” récupère le message si la file d’attente n’est pas vide.
Ø Si la file d’attente est vide, la tâche est suspendue, soit pour une durée précisée (timeout), soit
jusqu'à ce qu'un message soit présent dans la file.
Ø Si aucun message n'est présent après la durée d'attente précisée (timeout), la tâche reprend son
exécution et un message d'erreur est émis.
Ø plusieurs tâches peuvent attendre devant la même file d’attente . la plus prioritaire qui recevra
le message.
Attendre un messageAttendre un message
48
File d’attente
portBASE_TYPE xQueueReceive(xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait );portBASE_TYPE xQueueReceive(xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait );
(pxQueue) : La poignée de la file d’attente retournée à la création.
(pvBuffer ) : Pointeur vers la mémoire dans laquelle l'élément reçu sera copié.
(xTicksToWait) : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se
bloque si la file d'attente est vide.
unsigned portBASE_TYPE uxQueueMessagesWaiting( xQueueHandle xQueue );unsigned portBASE_TYPE uxQueueMessagesWaiting( xQueueHandle xQueue );
Nombre de messages présents dans la fileNombre de messages présents dans la file
Attendre un messageAttendre un message
49
File d’attente
Création des taches et du sémaphore
binaire
Lancement de l'ordonnancement
vTaskStartScheduler();
Tache 1 Tache 2
File d’attente
Lire un message
de la file d’attente
Envoi d’un message
à la file d’attente
50
Merci pour votre AttentionMerci pour votre Attention
Références:
Ø Cours de M. Mohammed Sahari « Systèmes Temps Réel ». Département d’électronique, USTOMB.
Ø Projet de fin d’étude de mastère Abdelrahime Nabie et Smail Abasse « Application du noyau temps
réel FreeRTOS». Département d’électronique, USTOMB.

Contenu connexe

Tendances

présentation ppt du stage technicien
présentation ppt du stage technicienprésentation ppt du stage technicien
présentation ppt du stage technicien
Iheb Ben Salem
 
Présentation PFE
Présentation PFEPrésentation PFE
Présentation PFE
Semah Mhamdi
 
TP2-UML-Correction
TP2-UML-CorrectionTP2-UML-Correction
TP2-UML-Correction
Lilia Sfaxi
 
Systeme embarque
Systeme embarqueSysteme embarque
Systeme embarque
Mohammed TIGHREMT
 
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Riadh K.
 
BigData_TP1: Initiation à Hadoop et Map-Reduce
BigData_TP1: Initiation à Hadoop et Map-ReduceBigData_TP1: Initiation à Hadoop et Map-Reduce
BigData_TP1: Initiation à Hadoop et Map-Reduce
Lilia Sfaxi
 
Rapport de projet de fin d"études
Rapport de projet de fin d"étudesRapport de projet de fin d"études
Rapport de projet de fin d"études
Mohamed Boubaya
 
Rapport stage onee-be_2
Rapport stage onee-be_2Rapport stage onee-be_2
Rapport stage onee-be_2
Mounir Kaali
 
Conception et Réalisation d’une application de Gestion SCOLAIRE
Conception et Réalisation d’une application de Gestion SCOLAIREConception et Réalisation d’une application de Gestion SCOLAIRE
Conception et Réalisation d’une application de Gestion SCOLAIRE
Ghizlane ALOZADE
 
Rapport PFE Développent d'une application bancaire mobile
Rapport PFE Développent d'une application bancaire mobileRapport PFE Développent d'une application bancaire mobile
Rapport PFE Développent d'une application bancaire mobile
Nader Somrani
 
INFORMATIQUE DES GESTION : MERISE
INFORMATIQUE DES GESTION : MERISE INFORMATIQUE DES GESTION : MERISE
INFORMATIQUE DES GESTION : MERISE HINDOUSSATI
 
Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )
Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )
Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )
Saadaoui Marwen
 
Systèmes d'Exploitation - chp1-introduction
Systèmes d'Exploitation - chp1-introductionSystèmes d'Exploitation - chp1-introduction
Systèmes d'Exploitation - chp1-introduction
Lilia Sfaxi
 
Conception et réalisation d’un Système d’information des étudiants du départe...
Conception et réalisation d’un Système d’information des étudiants du départe...Conception et réalisation d’un Système d’information des étudiants du départe...
Conception et réalisation d’un Système d’information des étudiants du départe...
Ilyas CHAOUA
 
Rapport pfe isi_Big data Analytique
Rapport pfe isi_Big data AnalytiqueRapport pfe isi_Big data Analytique
Rapport pfe isi_Big data Analytique
Yosra ADDALI
 
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Riadh K.
 
Pfe conception et réalisation d'une application de gestion des processus d'ac...
Pfe conception et réalisation d'une application de gestion des processus d'ac...Pfe conception et réalisation d'une application de gestion des processus d'ac...
Pfe conception et réalisation d'une application de gestion des processus d'ac...
Ahmed Makni
 
Rapport de PFE
Rapport de PFERapport de PFE
Rapport de PFE
Ghizlane ALOZADE
 
Présentation PFE (Conception et développement d'une application web && mobile...
Présentation PFE (Conception et développement d'une application web && mobile...Présentation PFE (Conception et développement d'une application web && mobile...
Présentation PFE (Conception et développement d'une application web && mobile...
Ramzi Noumairi
 

Tendances (20)

présentation ppt du stage technicien
présentation ppt du stage technicienprésentation ppt du stage technicien
présentation ppt du stage technicien
 
Présentation PFE
Présentation PFEPrésentation PFE
Présentation PFE
 
TP2-UML-Correction
TP2-UML-CorrectionTP2-UML-Correction
TP2-UML-Correction
 
Systeme embarque
Systeme embarqueSysteme embarque
Systeme embarque
 
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
 
BigData_TP1: Initiation à Hadoop et Map-Reduce
BigData_TP1: Initiation à Hadoop et Map-ReduceBigData_TP1: Initiation à Hadoop et Map-Reduce
BigData_TP1: Initiation à Hadoop et Map-Reduce
 
Rapport de projet de fin d"études
Rapport de projet de fin d"étudesRapport de projet de fin d"études
Rapport de projet de fin d"études
 
Rapport stage onee-be_2
Rapport stage onee-be_2Rapport stage onee-be_2
Rapport stage onee-be_2
 
Conception et Réalisation d’une application de Gestion SCOLAIRE
Conception et Réalisation d’une application de Gestion SCOLAIREConception et Réalisation d’une application de Gestion SCOLAIRE
Conception et Réalisation d’une application de Gestion SCOLAIRE
 
Rapport PFE Développent d'une application bancaire mobile
Rapport PFE Développent d'une application bancaire mobileRapport PFE Développent d'une application bancaire mobile
Rapport PFE Développent d'une application bancaire mobile
 
INFORMATIQUE DES GESTION : MERISE
INFORMATIQUE DES GESTION : MERISE INFORMATIQUE DES GESTION : MERISE
INFORMATIQUE DES GESTION : MERISE
 
Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )
Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )
Rapport PFE ingénieur réseaux marwen SAADAOUI ( Juin 2018 )
 
Systèmes d'Exploitation - chp1-introduction
Systèmes d'Exploitation - chp1-introductionSystèmes d'Exploitation - chp1-introduction
Systèmes d'Exploitation - chp1-introduction
 
Conception et réalisation d’un Système d’information des étudiants du départe...
Conception et réalisation d’un Système d’information des étudiants du départe...Conception et réalisation d’un Système d’information des étudiants du départe...
Conception et réalisation d’un Système d’information des étudiants du départe...
 
Rapport pfe isi_Big data Analytique
Rapport pfe isi_Big data AnalytiqueRapport pfe isi_Big data Analytique
Rapport pfe isi_Big data Analytique
 
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
Rapport PFE : Développement D'une application de gestion des cartes de fidéli...
 
Pfe conception et réalisation d'une application de gestion des processus d'ac...
Pfe conception et réalisation d'une application de gestion des processus d'ac...Pfe conception et réalisation d'une application de gestion des processus d'ac...
Pfe conception et réalisation d'une application de gestion des processus d'ac...
 
Rapport de PFE
Rapport de PFERapport de PFE
Rapport de PFE
 
Présentation PFE (Conception et développement d'une application web && mobile...
Présentation PFE (Conception et développement d'une application web && mobile...Présentation PFE (Conception et développement d'une application web && mobile...
Présentation PFE (Conception et développement d'une application web && mobile...
 
Rapport
RapportRapport
Rapport
 

En vedette

FreeRTOS
FreeRTOSFreeRTOS
FreeRTOS
Ankita Tiwari
 
Rtos Concepts
Rtos ConceptsRtos Concepts
Rtos Concepts
Sundaresan Sundar
 
Les systèmes embarqués arduino
Les systèmes embarqués arduinoLes systèmes embarqués arduino
Les systèmes embarqués arduino
CHERIET Mohammed El Amine
 
Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...
Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...
Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...
Vincent Thavonekham-Pro
 
Devoxx4kids à HumanTalks Genève
Devoxx4kids à HumanTalks GenèveDevoxx4kids à HumanTalks Genève
Devoxx4kids à HumanTalks GenèveXavier Bourguignon
 
Rtos part2
Rtos part2Rtos part2
Rtos part2
navakishore
 
Rtos
RtosRtos
Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...
Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...
Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...
Andrea Tino
 
Rtos by shibu
Rtos by shibuRtos by shibu
Rtos by shibu
Shibu Krishnan
 
Hacker son appareil photo avec des outils libres
Hacker son appareil photo avec des outils libresHacker son appareil photo avec des outils libres
Hacker son appareil photo avec des outils libres
Robert Viseur
 
Adw objet connecté
Adw objet connectéAdw objet connecté
Adw objet connecté
Atlantic 2.0
 
Free rtos seminar
Free rtos seminarFree rtos seminar
Free rtos seminar
Cho Daniel
 
How to Measure RTOS Performance
How to Measure RTOS Performance How to Measure RTOS Performance
How to Measure RTOS Performance
mentoresd
 
Cours0 presentation carte arduino
Cours0   presentation carte arduinoCours0   presentation carte arduino
Cours0 presentation carte arduino
labsud
 
RTOS- Real Time Operating Systems
RTOS- Real Time Operating Systems RTOS- Real Time Operating Systems
RTOS- Real Time Operating Systems
Bayar shahab
 
Real time-embedded-system-lec-02
Real time-embedded-system-lec-02Real time-embedded-system-lec-02
Real time-embedded-system-lec-02
University of Computer Science and Technology
 
Intro arduino
Intro arduinoIntro arduino
Intro arduino
SOAEnsAD
 
FreeRTOS
FreeRTOSFreeRTOS
FreeRTOSquakke
 
Presentation arduino
Presentation arduinoPresentation arduino
Presentation arduino
SinGuy
 

En vedette (20)

FreeRTOS
FreeRTOSFreeRTOS
FreeRTOS
 
Rtos Concepts
Rtos ConceptsRtos Concepts
Rtos Concepts
 
Les systèmes embarqués arduino
Les systèmes embarqués arduinoLes systèmes embarqués arduino
Les systèmes embarqués arduino
 
Rtlinux
RtlinuxRtlinux
Rtlinux
 
Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...
Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...
Gab2015 christophe havard_hackaton_zone61_les_dessous_de_la_création_d_un_obj...
 
Devoxx4kids à HumanTalks Genève
Devoxx4kids à HumanTalks GenèveDevoxx4kids à HumanTalks Genève
Devoxx4kids à HumanTalks Genève
 
Rtos part2
Rtos part2Rtos part2
Rtos part2
 
Rtos
RtosRtos
Rtos
 
Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...
Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...
Improved implementation of a Deadline Monotonic algorithm for aperiodic traff...
 
Rtos by shibu
Rtos by shibuRtos by shibu
Rtos by shibu
 
Hacker son appareil photo avec des outils libres
Hacker son appareil photo avec des outils libresHacker son appareil photo avec des outils libres
Hacker son appareil photo avec des outils libres
 
Adw objet connecté
Adw objet connectéAdw objet connecté
Adw objet connecté
 
Free rtos seminar
Free rtos seminarFree rtos seminar
Free rtos seminar
 
How to Measure RTOS Performance
How to Measure RTOS Performance How to Measure RTOS Performance
How to Measure RTOS Performance
 
Cours0 presentation carte arduino
Cours0   presentation carte arduinoCours0   presentation carte arduino
Cours0 presentation carte arduino
 
RTOS- Real Time Operating Systems
RTOS- Real Time Operating Systems RTOS- Real Time Operating Systems
RTOS- Real Time Operating Systems
 
Real time-embedded-system-lec-02
Real time-embedded-system-lec-02Real time-embedded-system-lec-02
Real time-embedded-system-lec-02
 
Intro arduino
Intro arduinoIntro arduino
Intro arduino
 
FreeRTOS
FreeRTOSFreeRTOS
FreeRTOS
 
Presentation arduino
Presentation arduinoPresentation arduino
Presentation arduino
 

Similaire à Noyau temps réel freertos cheriet mohammed el amine

Linux et le temps réel - Meetup du 15 octobre 2015
Linux et le temps réel - Meetup du 15 octobre 2015Linux et le temps réel - Meetup du 15 octobre 2015
Linux et le temps réel - Meetup du 15 octobre 2015
Christian Charreyre
 
IoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdfIoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdf
NizarTOUJENI3
 
Ordinnancement des processus
Ordinnancement des processusOrdinnancement des processus
Ordinnancement des processusSelman Dridi
 
Apache Storm - Introduction au traitement temps-réel avec Storm
Apache Storm - Introduction au traitement temps-réel avec StormApache Storm - Introduction au traitement temps-réel avec Storm
Apache Storm - Introduction au traitement temps-réel avec Storm
Paris_Storm_UG
 
Paris stormusergroup intrudocution
Paris stormusergroup intrudocutionParis stormusergroup intrudocution
Paris stormusergroup intrudocutionParis_Storm_UG
 
Formation linux temps réel - Toulouse 4 novembre 2014
Formation linux temps réel - Toulouse 4 novembre 2014Formation linux temps réel - Toulouse 4 novembre 2014
Formation linux temps réel - Toulouse 4 novembre 2014
eurogicielgroup
 
Formation linux temps réel - Malakoff 7 octobre 2014
Formation linux temps réel - Malakoff 7 octobre 2014Formation linux temps réel - Malakoff 7 octobre 2014
Formation linux temps réel - Malakoff 7 octobre 2014
eurogicielgroup
 
rt-intro.pdf
rt-intro.pdfrt-intro.pdf
rt-intro.pdf
Said Ech
 
Solutions temps réel sous linux
Solutions temps réel sous linuxSolutions temps réel sous linux
Solutions temps réel sous linux
embedded-linux-bdx
 
Formation linux temps réel - Rennes 14 octobre 2014
Formation linux temps réel  - Rennes 14 octobre 2014Formation linux temps réel  - Rennes 14 octobre 2014
Formation linux temps réel - Rennes 14 octobre 2014
eurogicielgroup
 
Présentation de Apache Zookeeper
Présentation de Apache ZookeeperPrésentation de Apache Zookeeper
Présentation de Apache Zookeeper
Michaël Morello
 
Lepton : Description succincte
Lepton : Description succincteLepton : Description succincte
Lepton : Description succincteO10ée
 
TD_complet_reseau__CISCO__Packet Tracer.pdf
TD_complet_reseau__CISCO__Packet Tracer.pdfTD_complet_reseau__CISCO__Packet Tracer.pdf
TD_complet_reseau__CISCO__Packet Tracer.pdf
Ines Ben Hassine
 
Solution linux 2014 - Code réactif et persistance versionée
Solution linux 2014 - Code réactif et persistance versionéeSolution linux 2014 - Code réactif et persistance versionée
Solution linux 2014 - Code réactif et persistance versionée
OCTO Technology
 
Etat de l'art des systèmes embarqués, utilisation du logiciel libre
Etat de l'art des systèmes embarqués, utilisation du logiciel libreEtat de l'art des systèmes embarqués, utilisation du logiciel libre
Etat de l'art des systèmes embarqués, utilisation du logiciel libre
Pierre Ficheux
 
Rex docker en production meeutp-docker-nantes
Rex docker en production meeutp-docker-nantesRex docker en production meeutp-docker-nantes
Rex docker en production meeutp-docker-nantes
Christophe Furmaniak
 
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier KrantzOps@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Olivier DASINI
 
Formation Google App Engine
Formation Google App EngineFormation Google App Engine
Formation Google App Engine
Abdelhakim Rhanizar
 
Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...
Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...
Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...
Christophe Furmaniak
 
Road map to DevOps engineering - Elie Sirius
Road map to DevOps engineering -  Elie SiriusRoad map to DevOps engineering -  Elie Sirius
Road map to DevOps engineering - Elie Sirius
GDG Bujumbura
 

Similaire à Noyau temps réel freertos cheriet mohammed el amine (20)

Linux et le temps réel - Meetup du 15 octobre 2015
Linux et le temps réel - Meetup du 15 octobre 2015Linux et le temps réel - Meetup du 15 octobre 2015
Linux et le temps réel - Meetup du 15 octobre 2015
 
IoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdfIoT.Lab.5.SMTR.pdf
IoT.Lab.5.SMTR.pdf
 
Ordinnancement des processus
Ordinnancement des processusOrdinnancement des processus
Ordinnancement des processus
 
Apache Storm - Introduction au traitement temps-réel avec Storm
Apache Storm - Introduction au traitement temps-réel avec StormApache Storm - Introduction au traitement temps-réel avec Storm
Apache Storm - Introduction au traitement temps-réel avec Storm
 
Paris stormusergroup intrudocution
Paris stormusergroup intrudocutionParis stormusergroup intrudocution
Paris stormusergroup intrudocution
 
Formation linux temps réel - Toulouse 4 novembre 2014
Formation linux temps réel - Toulouse 4 novembre 2014Formation linux temps réel - Toulouse 4 novembre 2014
Formation linux temps réel - Toulouse 4 novembre 2014
 
Formation linux temps réel - Malakoff 7 octobre 2014
Formation linux temps réel - Malakoff 7 octobre 2014Formation linux temps réel - Malakoff 7 octobre 2014
Formation linux temps réel - Malakoff 7 octobre 2014
 
rt-intro.pdf
rt-intro.pdfrt-intro.pdf
rt-intro.pdf
 
Solutions temps réel sous linux
Solutions temps réel sous linuxSolutions temps réel sous linux
Solutions temps réel sous linux
 
Formation linux temps réel - Rennes 14 octobre 2014
Formation linux temps réel  - Rennes 14 octobre 2014Formation linux temps réel  - Rennes 14 octobre 2014
Formation linux temps réel - Rennes 14 octobre 2014
 
Présentation de Apache Zookeeper
Présentation de Apache ZookeeperPrésentation de Apache Zookeeper
Présentation de Apache Zookeeper
 
Lepton : Description succincte
Lepton : Description succincteLepton : Description succincte
Lepton : Description succincte
 
TD_complet_reseau__CISCO__Packet Tracer.pdf
TD_complet_reseau__CISCO__Packet Tracer.pdfTD_complet_reseau__CISCO__Packet Tracer.pdf
TD_complet_reseau__CISCO__Packet Tracer.pdf
 
Solution linux 2014 - Code réactif et persistance versionée
Solution linux 2014 - Code réactif et persistance versionéeSolution linux 2014 - Code réactif et persistance versionée
Solution linux 2014 - Code réactif et persistance versionée
 
Etat de l'art des systèmes embarqués, utilisation du logiciel libre
Etat de l'art des systèmes embarqués, utilisation du logiciel libreEtat de l'art des systèmes embarqués, utilisation du logiciel libre
Etat de l'art des systèmes embarqués, utilisation du logiciel libre
 
Rex docker en production meeutp-docker-nantes
Rex docker en production meeutp-docker-nantesRex docker en production meeutp-docker-nantes
Rex docker en production meeutp-docker-nantes
 
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier KrantzOps@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
Ops@viadeo : Puppet & Co... 6 mois après par Xavier Krantz
 
Formation Google App Engine
Formation Google App EngineFormation Google App Engine
Formation Google App Engine
 
Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...
Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...
Prez -chtijug-29032016-(micro)services, loadbalancing et gestion des erreurs ...
 
Road map to DevOps engineering - Elie Sirius
Road map to DevOps engineering -  Elie SiriusRoad map to DevOps engineering -  Elie Sirius
Road map to DevOps engineering - Elie Sirius
 

Noyau temps réel freertos cheriet mohammed el amine

  • 1. Noyau temps réel Freertos présenté par: m. cheriet mohammed el amine mail: microcheriet@gmail.com
  • 2. Plan 1. Notions de base sur les systèmes temps réel 2. Le noyau temps réel FreeRTOS 3. Atelier: ØEnvironnement de développement Arduino IDE ØCréation de trois taches périodiques ØSémaphore mutex ØSémaphore binaire ØFile d’attente 2
  • 3. Notions de bases sur les systèmes temps réel Ø le besoin de diminuer le temps de développement des systèmes embarqués, Ø le degré élevé de complexité a imposé l’utilisation d’un système d’exploitation temps réel (SETR ou RTOS) ou d’un noyau temps réel (NTR). C’est pour cela qu’on peut dire que le RTOS est l’essence même d’un système embarqué. Ø le besoin de diminuer le temps de développement des systèmes embarqués, Ø le degré élevé de complexité a imposé l’utilisation d’un système d’exploitation temps réel (SETR ou RTOS) ou d’un noyau temps réel (NTR). C’est pour cela qu’on peut dire que le RTOS est l’essence même d’un système embarqué. 3 L’intérêt d’utilisation d’un noyau temps réel:L’intérêt d’utilisation d’un noyau temps réel:
  • 4. Ø Un système temps réel n’est pas un système «qui va vite / rapide » mais un système qui satisfait des contraintes temporelles ØUn système temps réel ne repose pas que sur l'aboutissement des traitements, il remplit son rôle lorsqu'il est en mesure de satisfaire toutes les contraintes de temps auxquelles il est soumis. ØUn non respect est assimilé à une sévère panne logicielle Ø Un système temps réel n’est pas un système «qui va vite / rapide » mais un système qui satisfait des contraintes temporelles ØUn système temps réel ne repose pas que sur l'aboutissement des traitements, il remplit son rôle lorsqu'il est en mesure de satisfaire toutes les contraintes de temps auxquelles il est soumis. ØUn non respect est assimilé à une sévère panne logicielle ““MêmeMême la bonne réponse est fausse si elle arrive trop tard”la bonne réponse est fausse si elle arrive trop tard”““MêmeMême la bonne réponse est fausse si elle arrive trop tard”la bonne réponse est fausse si elle arrive trop tard” Notions de bases sur les systèmes temps réel 4 Système temps réelSystème temps réel
  • 5. MultitâcheMultitâche permet d'effectuer à l'échelle humaine plusieurs tâches simultanément. l'utilisateur peut alors diviser son projet en plusieurs tâches indépendantes. Au niveau du processeur, une seule tâche est effectuée à la fois en revanche le multitâche permet d'éliminer les temps machines inutilisés (boucle d'attente, de scrutation...). permet d'effectuer à l'échelle humaine plusieurs tâches simultanément. l'utilisateur peut alors diviser son projet en plusieurs tâches indépendantes. Au niveau du processeur, une seule tâche est effectuée à la fois en revanche le multitâche permet d'éliminer les temps machines inutilisés (boucle d'attente, de scrutation...). Temps réelTemps réel Répondre à un événement dans un temps déterminé afin de satisfaire toutes les contraintes de temps Répondre à un événement dans un temps déterminé afin de satisfaire toutes les contraintes de temps - un ensemble de fonctionnalités, regroupées sous le terme de SERVICES - Gérer l'occupation du processeur, l’accès au ressources, synchronisations et communication entre les taches, gestion des E/S et des interruptions - un ensemble de fonctionnalités, regroupées sous le terme de SERVICES - Gérer l'occupation du processeur, l’accès au ressources, synchronisations et communication entre les taches, gestion des E/S et des interruptions NoyauNoyau Notions de bases sur les systèmes temps réel 5 Noyau multitâches temps réel:Noyau multitâches temps réel:
  • 6. Répondre à un événement dans un temps déterminé ,tout en respectant les limites de temps autorisé Répondre à un événement dans un temps déterminé ,tout en respectant les limites de temps autorisé ÉchéancesÉchéances La latence est le temps qui peut exister entre le moment ou un événement est survenu et celui ou il est effectivement traité. La latence est le temps qui peut exister entre le moment ou un événement est survenu et celui ou il est effectivement traité. Les latencesLes latences est la capacité d'interrompre l'exécution d'une tâche en faveur de l'exécution d'une autre tâche. est la capacité d'interrompre l'exécution d'une tâche en faveur de l'exécution d'une autre tâche. La préemptionLa préemption Ø L‘ordonnanceur mène un arbitrage pour décider quel tâche doit s'exécuter. Ø le mécanisme d'ordonnancement des tâches repose sur la capacité du système à préempté la tâche en cours. Ø L‘ordonnanceur mène un arbitrage pour décider quel tâche doit s'exécuter. Ø le mécanisme d'ordonnancement des tâches repose sur la capacité du système à préempté la tâche en cours. L‘ordonnanceurL‘ordonnanceur Notions de bases sur les systèmes temps réel 6 Contraintes de temps :Contraintes de temps :
  • 7. le non respect des échéances peut entraîner des graves problèmes Ex.: contrôle de trafic aérien, système de conduite de missile,… etc le non respect des échéances peut entraîner des graves problèmes Ex.: contrôle de trafic aérien, système de conduite de missile,… etc Temps réel durTemps réel dur Les échéances peuvent ne pas être respectées. Les exigences de temps se présentent sous la forme d'un ou plusieurs intervalles Ex.: domaines du multimédia projection vidéo Les échéances peuvent ne pas être respectées. Les exigences de temps se présentent sous la forme d'un ou plusieurs intervalles Ex.: domaines du multimédia projection vidéo Temps réel mouTemps réel mou Notions de bases sur les systèmes temps réel 7 Contraintes Classification:Contraintes Classification:
  • 8. Contraintes Classification d’un système temps réel Notions de bases sur les systèmes temps réel 8
  • 9. L'ordonnancementL'ordonnancement Seuls les noyaux préemptifs pourront être considérés commeSeuls les noyaux préemptifs pourront être considérés comme véritablement temps réel.véritablement temps réel. Seuls les noyaux préemptifs pourront être considérés commeSeuls les noyaux préemptifs pourront être considérés comme véritablement temps réel.véritablement temps réel. Noyaux temps réel préemptifs Noyaux temps réel préemptifs Øla tâche peut à tout instant perdre le contrôle du processeur au profit d'une tâche de priorité supérieure. Ø La tâche qui perd le processeur n'a aucune possibilité de le savoir. C’est l'ordonnanceur qui prend cette décision. Øla tâche peut à tout instant perdre le contrôle du processeur au profit d'une tâche de priorité supérieure. Ø La tâche qui perd le processeur n'a aucune possibilité de le savoir. C’est l'ordonnanceur qui prend cette décision. Noyaux temps réel coopératifs Noyaux temps réel coopératifs Øla tâche est exécutée jusqu'à ce qu'elle fasse appel à un service du noyau. Ø Selon la situation présente, le scheduler décide si la tâche doit se poursuivre ou non. Øla tâche est exécutée jusqu'à ce qu'elle fasse appel à un service du noyau. Ø Selon la situation présente, le scheduler décide si la tâche doit se poursuivre ou non. Notions de bases sur les systèmes temps réel 9
  • 10. Le noyau temps réel FreeRTOS
  • 11. L'ordonnancement FreeRTOS Ordonnancement circulaire Ordonnancement circulaire Ordonnancement par priorité Ordonnancement par priorité Ordonnancement par priorité avec files multiples Ordonnancement par priorité avec files multiples ØToutes les tâches ont le même niveau de priorité. ØChaque tâche prête à l'exécution se voit attribuer le processeur pendant une durée fixée initialement. A l'expiration de ce temps, une commutation a lieu et ainsi de suite pour toutes les tâches prêtes. ØToutes les tâches ont le même niveau de priorité. ØChaque tâche prête à l'exécution se voit attribuer le processeur pendant une durée fixée initialement. A l'expiration de ce temps, une commutation a lieu et ainsi de suite pour toutes les tâches prêtes. Ordonnancement circulaire Ordonnancement circulaire FreeRTOS offre trois possibilités d'ordonnancement: Le noyau temps réel FreeRTOS 11
  • 12. ØChaque tâche reçoit, lors de sa création, un niveau de priorité. L'ordonnanceur lance la tâche prête, la plus prioritaire. Celle-ci conserve le processeur tant qu'elle n'est pas terminée ou bloquée. ØChaque tâche reçoit, lors de sa création, un niveau de priorité. L'ordonnanceur lance la tâche prête, la plus prioritaire. Celle-ci conserve le processeur tant qu'elle n'est pas terminée ou bloquée. Ordonnancement par priorité Ordonnancement par priorité ØLe principe consiste à combiner l'ordonnancement circulaire (sans quantum) et l'ordonnancement par priorité, plusieurs tâches peuvent coexister au même niveau de priorité. Si plusieurs tâches sont présentes dans la file de plus forte priorité, une de ces tâches est en exécution. ØLe principe consiste à combiner l'ordonnancement circulaire (sans quantum) et l'ordonnancement par priorité, plusieurs tâches peuvent coexister au même niveau de priorité. Si plusieurs tâches sont présentes dans la file de plus forte priorité, une de ces tâches est en exécution. Ordonnancement par priorité avec files multiples Ordonnancement par priorité avec files multiples Le noyau temps réel FreeRTOS 12
  • 13. Le noyau temps réel FreeRTOS ANTR préemptif, coopératif(configuration )  23 architectures de microcontrôleurs  la taille du noyau (4K à 9K octets).  Prend en charge les tâches et les co-routines.  Pas de restriction logicielle sur le nombre de tâches qui peuvent être crées  Pas de restriction logicielle sur le nombre de priorités qui peuvent être utilisés. A plus d'une tâche peut être attribuée la même priorité.  La gestion des taches : c’est un service du noyau, dont le rôle est d'offrir à l'application les fonctions nécessaires à la gestion des taches.  La gestion du temps : Il répond à l'interruption du TIMER 1 afin de mettre à jour périodiquement les alarmes et compteurs associées aux tâches.  La synchronisation et la communication entre taches : Files d'attente, sémaphores binaires, sémaphores compteurs, des sémaphores récursifs et des mutexes  La gestion d'interruption : -l'activation et la désactivation des interruptions du système. -Un périphérique peut communiquer avec une tâche grâce aux ISR 13
  • 14. Le noyau temps réel FreeRTOS FreeRTOSConfig.h #ifndef FREERTOS_CONFIG_H #define FREERTOS_CONFIG_H #include <p18cxxx.h> #define configUSE_PREEMPTION 1 #define configUSE_IDLE_HOOK 0 #define configUSE_TICK_HOOK 0 #define configCPU_CLOCK_HZ ( ( unsigned long ) 20000000 ) #define configTICK_RATE_HZ ( ( portTickType ) 1000 ) #define configMAX_PRIORITIES ( ( unsigned portBASE_TYPE ) 4 ) #define configMINIMAL_STACK_SIZE 128 #define configTOTAL_HEAP_SIZE ( ( size_t ) 1024 ) #define configMAX_TASK_NAME_LEN 16 #define configUSE_TRACE_FACILITY 0 #define configUSE_16_BIT_TICKS 1 #define configIDLE_SHOULD_YIELD 1 #define configUSE_MUTEXES 0 /* Co-routine definitions. */ #define configUSE_CO_ROUTINES 0 #define configMAX_CO_ROUTINE_PRIORITIES 2 /* Set the following definitions to 1 to include the API function, or zero to exclude the API function. */ #define INCLUDE_vTaskDelete 1 #define INCLUDE_vTaskCleanUpResources 0 #define INCLUDE_vTaskSuspend 1 #define INCLUDE_vResumeFromISR 1 #define INCLUDE_vTaskDelayUntil 1 #define INCLUDE_vTaskDelay 1 #endif /* FREERTOS_CONFIG_H */ 1 :le noyau préemptif, 0: le noyau coopératif. 1 :le noyau préemptif, 0: le noyau coopératif. La fréquence de l'interruption de Tick d’horloge.(1ms) La fréquence de l'interruption de Tick d’horloge.(1ms) Inclue les services du noyau utilisés par votre application Inclue les services du noyau utilisés par votre application La quantité totale de RAM disponible pour le noyau. La quantité totale de RAM disponible pour le noyau. La priorité maximale des taches disponibles à l’application La priorité maximale des taches disponibles à l’application 14
  • 16. Gestion Des Tâches Dans FreeRTOS Une tâche est un programme ou une partie de programme en exécution. Tâches matérielles tâches soumises à de fortes contraintes de temps notifier par des interruptions Exemple: la réception de caractères d’un clavier sur la ligne RS232 Tâches logicielles programmées soit dans une boucle de scrutation(monotâche), ou de façon indépendante (multitâche principe utilisé) Tâches matérielles tâches soumises à de fortes contraintes de temps notifier par des interruptions Exemple: la réception de caractères d’un clavier sur la ligne RS232 Tâches logicielles programmées soit dans une boucle de scrutation(monotâche), ou de façon indépendante (multitâche principe utilisé) 16
  • 17. Gestion Des Tâches Dans FreeRTOS Structures d’une TâcheStructures d’une Tâche void vATaskFunction( void *pvParameters ) { for( ;; ) { -- code de la tâche -- } } FreeRTOS gère le contrôle du processeur en attribuant ce dernier à la tâche de plus grande priorité en attente d'exécution. Priorité d’une tâche Lors de la création , chaque tâche est assignée a une priorité de 0(niveau bas) à configMAX_PRIORITIES - 1(niveau haut) Le configMAX_PRIORITIES est défini dans le fichier header La tâche oisive (idle task) a la priorité 0 Priorité d’une tâche Lors de la création , chaque tâche est assignée a une priorité de 0(niveau bas) à configMAX_PRIORITIES - 1(niveau haut) Le configMAX_PRIORITIES est défini dans le fichier header La tâche oisive (idle task) a la priorité 0 17
  • 18. Gestion Des Tâches Dans FreeRTOS Etat “ en exécution ” (Running) Une tâche en exécution a le contrôle du processeur et exécute son code. Etat “ en exécution ” (Running) Une tâche en exécution a le contrôle du processeur et exécute son code. Etat “ prête à l'exécution ”(Ready) Une tâche prête à l'exécution est candidate à l'attribution du processeur. Etat “ prête à l'exécution ”(Ready) Une tâche prête à l'exécution est candidate à l'attribution du processeur. Dans un environnement multitâche, les tâches peuvent être dans un des quatre états : Etat “ Bloqué ”(Blocked) Une tâche est dans l'état bloqué si elle attend un événement temporel ou externe. Etat “ Bloqué ”(Blocked) Une tâche est dans l'état bloqué si elle attend un événement temporel ou externe. Etat “ Suspendu ”(Suspended) Une tâche suspendue n'est pas candidate à l'attribution du processeur. Etat “ Suspendu ”(Suspended) Une tâche suspendue n'est pas candidate à l'attribution du processeur. Etat d’une tache dans FreeRTOS 18 18
  • 19. Gestion Des Tâches Dans FreeRTOS • xTaskCreate créer une tâche • vTaskDelete supprimer une tâche • vTaskSuspend suspendre une tâche • vTaskResume faire reprendre (suspended -> ready) une tâche suspendue par un vTaskSuspend • vTaskDelay suspendre une tâche pendant une durée. • vTaskDelayUntil suspendre une tâche pendant une durée déterminée (fréquence fixe) • vTaskPrioritySet changer la priorité d'une tâche • uxTaskPriorityGet se renseigner sur la priorité d’une tâche • vTaskEndScheduler invalider la “ rescheduling procedure ” • vTaskStartScheduler valider la “ rescheduling procedure ” • xTaskCreate créer une tâche • vTaskDelete supprimer une tâche • vTaskSuspend suspendre une tâche • vTaskResume faire reprendre (suspended -> ready) une tâche suspendue par un vTaskSuspend • vTaskDelay suspendre une tâche pendant une durée. • vTaskDelayUntil suspendre une tâche pendant une durée déterminée (fréquence fixe) • vTaskPrioritySet changer la priorité d'une tâche • uxTaskPriorityGet se renseigner sur la priorité d’une tâche • vTaskEndScheduler invalider la “ rescheduling procedure ” • vTaskStartScheduler valider la “ rescheduling procedure ” Appels-système pour gestion des tâches logiciellesAppels-système pour gestion des tâches logicielles 19
  • 20. Gestion Des Tâches Dans FreeRTOS Création de tâcheCréation de tâche L'appel système xtaskcreate() permettre la création d'une nouvelle tâche la tache créée est placée dans la file des tâches qui sont prêtes à l’exécution portBASE_TYPE xTaskCreate( pdTASK_CODE pvTaskCode, const portCHAR * const pcName, unsigned portSHORT usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pvCreatedTask ); Example xTaskCreate( tache_ADC ,"ADC", 105,( void * ) NULL, 1 , &xHandle_ADC ); La tache return pdPASS si elle a était créée avec succès ,si non pdFALSE. L'appel système xtaskcreate() permettre la création d'une nouvelle tâche la tache créée est placée dans la file des tâches qui sont prêtes à l’exécution portBASE_TYPE xTaskCreate( pdTASK_CODE pvTaskCode, const portCHAR * const pcName, unsigned portSHORT usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pvCreatedTask ); Example xTaskCreate( tache_ADC ,"ADC", 105,( void * ) NULL, 1 , &xHandle_ADC ); La tache return pdPASS si elle a était créée avec succès ,si non pdFALSE. Exemple de création d’une tache dans FreeRTOSExemple de création d’une tache dans FreeRTOS 20
  • 21. Gestion Des Tâches Dans FreeRTOS Ø Une ISR s'exécute lorsqu'une interruption matérielle est générée. Ø FreeRTOS fournit le moyen aux routines d'interruptions (ISR) de l'application pour communiquer et d'influer sur l'ordonnancement des tâches critiques. Ø Une ISR s'exécute lorsqu'une interruption matérielle est générée. Ø FreeRTOS fournit le moyen aux routines d'interruptions (ISR) de l'application pour communiquer et d'influer sur l'ordonnancement des tâches critiques. Exemple:  xQueueSendFromISR communiquer des messages aux tâches  xQueueReceiveFromISR recevoir des messages des tâches  xSemaphoreGiveFromISR pour libérer un sémaphore  xTaskResumeFromISR reprendre une tâche suspendue Exemple:  xQueueSendFromISR communiquer des messages aux tâches  xQueueReceiveFromISR recevoir des messages des tâches  xSemaphoreGiveFromISR pour libérer un sémaphore  xTaskResumeFromISR reprendre une tâche suspendue Ø Les tâches logicielles de l'application sont gérées d’une manière synchrone par FreeRTOS, Ø une routine d'interruption est exécutée d’une manière asynchrone et non gérée par FreeRTOS Ø Les tâches logicielles de l'application sont gérées d’une manière synchrone par FreeRTOS, Ø une routine d'interruption est exécutée d’une manière asynchrone et non gérée par FreeRTOS Reprise d'une tâche suspendue par ISR Reprise d'une tâche suspendue par ISR portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume );portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume ); Gestion des tâches matérielles (interruptions)Gestion des tâches matérielles (interruptions) 21
  • 23. Communication et Synchronisation entre Tâches Ø Le mécanisme de communication disponible dans FreeRTOS est celui de la file d’attente. Ø Ø Le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case par la tâche “ récepteur ”. Ø Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les interruptions et les tâches. Ø Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication et de synchronisation entre tâches. - Ø Le mécanisme de communication disponible dans FreeRTOS est celui de la file d’attente. Ø Ø Le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case par la tâche “ récepteur ”. Ø Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les interruptions et les tâches. Ø Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication et de synchronisation entre tâches. - Gestion des files d’attente de message (queue)Gestion des files d’attente de message (queue) 23
  • 24. Communication et Synchronisation entre Tâches Ø Le sémaphore permet la synchronisation entre tâches et permet aussi de traiter l'exclusion mutuelle avec accès multiples simultanés. Ø Le sémaphore sem est constitué par une variable entière S et une file d'attente F. Ø Dans le noyau FreeRTOS, il existe deux types de sémaphores : § Sémaphore Binaire (de valeur 0 ou 1) § Sémaphore Compteur (de valeur 0 à max) Ø Le sémaphore permet la synchronisation entre tâches et permet aussi de traiter l'exclusion mutuelle avec accès multiples simultanés. Ø Le sémaphore sem est constitué par une variable entière S et une file d'attente F. Ø Dans le noyau FreeRTOS, il existe deux types de sémaphores : § Sémaphore Binaire (de valeur 0 ou 1) § Sémaphore Compteur (de valeur 0 à max) Les sémaphoresLes sémaphores 24
  • 25. Communication et Synchronisation entre Tâches Sémaphore BinaireSémaphore Binaire Ø Les sémaphores binaires sont utilisés pour la synchronisation. Ø Il est considérer comme un "drapeau" servant à signaler l'arrivée d'un événement. Ø Penser à un sémaphore binaire comme file d'attente qui peut seulement tenir un élément(vide ou plein -binaire). Ø Les sémaphores binaires sont utilisés pour la synchronisation. Ø Il est considérer comme un "drapeau" servant à signaler l'arrivée d'un événement. Ø Penser à un sémaphore binaire comme file d'attente qui peut seulement tenir un élément(vide ou plein -binaire). Ø Les sémaphores compteurs sont principalement utilisés pour la gestion des ressources Ø La valeur compteur du sémaphore indique le nombre de ressources disponibles. Ø Les sémaphores compteurs sont principalement utilisés pour la gestion des ressources Ø La valeur compteur du sémaphore indique le nombre de ressources disponibles. Sémaphore compteursSémaphore compteurs 25
  • 26. Communication et Synchronisation entre Tâches Ø Les sémaphores mutex sont utilisés pour l'exclusion mutuelle(le moyen d'interdire l'accès simultané à une ressource critique ) Ø Les sémaphores mutex sont utilisés pour l'exclusion mutuelle(le moyen d'interdire l'accès simultané à une ressource critique ) Sémaphore d'exclusion Mutuelle (Mutexes)Sémaphore d'exclusion Mutuelle (Mutexes) 26
  • 27. ATELIER FreeRTOS Ø Environnement de développement Arduino IDE Ø Création de trois taches périodiques Ø Sémaphore mutex Ø Sémaphore binaire Ø File d’attente
  • 28. Arduino IDE Ouvrez Arduino IDE Ouvrez l’exemple Blink 28 Environnement de développement Arduino IDE
  • 29. Arduino IDE Choisissez le port COM qui correspond à votre plateforme Choisissez le type de plateforme Arduino 29 Environnement de développement Arduino IDE
  • 30. Arduino IDE Programme en C++ Compilez le programme Compilation sans erreurs Chargez le programme dans Arduino Clignotement des LEDs Tx et Rx durant le transfère du programme 30
  • 31. Environnement de développement Arduino IDE Exemple FreeRTOS dans Arduino
  • 32. Création de trois taches périodiques
  • 33. Création de trois taches périodiques Création de trois taches périodiques Lancement de l'ordonnancement vTaskStartScheduler(); Tache 1 Tache 2 Tache 3 33
  • 34. void Tache_1(void * pvParameters ) { while (1) { Blink_LED(13, 100); vTaskDelay(120); } } void Tache_2(void * pvParameters ) { while (1) { Blink_LED(12, 200); vTaskDelay(400); } } void Tache_3(void * pvParameters ) { while (1) { Blink_LED(11, 200); vTaskDelay(200); } } //--------------------Création des taches --------------------------- xTaskCreate(Tache_1, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL); xTaskCreate(Tache_2, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL); xTaskCreate(Tache_3, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL); //--------------------- Lancement de l'ordonnancement --------------- vTaskStartScheduler(); Tache 1 Tache 2 Tache 3 Création des tache et lancement de l'Ordonnanceur Création de trois taches périodique 34
  • 36. Sémaphore mutex Ø Le sémaphore mutex est principalement utilisés pour la Gestion des ressources.Ø Le sémaphore mutex est principalement utilisés pour la Gestion des ressources. 36
  • 37. Sémaphore MUTEX Création des taches et du sémaphore Mutex Lancement de l'ordonnancement vTaskStartScheduler(); Tache 1 Ressource partagée et non partageable: UART (port série) ou convertisseur analogique etc. Sémaphore Mutex Tache 2 Tache 3 Création de sémaphore mutex dans FreeRTOS Création de sémaphore mutex dans FreeRTOS xSemaphoreHandle xSemaphoreCreateMutex( void )xSemaphoreHandle xSemaphoreCreateMutex( void ) 37
  • 38. Sémaphore MUTEX la tâche prend le Sémaphore pour entrer dans la section critique en utilisant la ressource citrique.la tâche prend le Sémaphore pour entrer dans la section critique en utilisant la ressource citrique. (xSemaphore ): La poignée du sémaphore prise. (xBlockTime) : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se bloque en attendant la disponibilité du sémaphore. xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime )xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime ) Prendre le SémaphorePrendre le Sémaphore 38
  • 39. Sémaphore MUTEX xSemaphore : La poignée du sémaphore prise. xBlockTime : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se bloque en attendant la disponibilité du sémaphore. xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime )xSemaphoreTake(xSemaphoreHandle xSemaphore, portTickType xBlockTime ) xSemaphoreGiveFromISR(xSemaphoreHandle xSemaphore, signed portBASE_TYPE *pxHigherPriorityTaskWoken )xSemaphoreGiveFromISR(xSemaphoreHandle xSemaphore, signed portBASE_TYPE *pxHigherPriorityTaskWoken ) A partir d’une routine d’interruption(ISR)A partir d’une routine d’interruption(ISR) Libérer le SémaphoreLibérer le Sémaphore la tâche libére le Sémaphore pour sortir de la section critique en donnant un droit d'accès supplémentaire. la tâche libére le Sémaphore pour sortir de la section critique en donnant un droit d'accès supplémentaire. 39
  • 41. Sémaphore binaire Ø Les sémaphores binaires sont utilisés pour la synchronisation. Ø Il est considéré comme un "drapeau" servant à signaler l'arrivée d'un événement. Ø un sémaphore binaire est comme file d'attente qui peut seulement tenir un élément. Ø Les sémaphores binaires sont utilisés pour la synchronisation. Ø Il est considéré comme un "drapeau" servant à signaler l'arrivée d'un événement. Ø un sémaphore binaire est comme file d'attente qui peut seulement tenir un élément. 41
  • 42. Sémaphore binaire Création des taches et du sémaphore binaire Lancement de l'ordonnancement vTaskStartScheduler(); Tache 1 Tache 2 Sémaphore binaire Création de sémaphore binaire dans FreeRTOS Création de sémaphore binaire dans FreeRTOS vSemaphoreCreateBinary(xSemaphoreHandle xSemaphore) (xSemaphore ): La poignée (handle) du sémaphore créé. vSemaphoreCreateBinary(xSemaphoreHandle xSemaphore) (xSemaphore ): La poignée (handle) du sémaphore créé. 42
  • 43. Exemple : File d’attente
  • 44. File d’attente Ø le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case par la tâche “ récepteur ”. Ø Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les interruptions et les tâches. Ø Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication et de synchronisation entre tâches. Ø le message est placé en mémoire par la tâche“ émetteur ” et il est récupéré dans cette case par la tâche “ récepteur ”. Ø Ø Elles peuvent être utilisées pour envoyer des messages entre les tâches, et entre les interruptions et les tâches. Ø Ø Elles permettent de résoudre facilement un grand nombre de problèmes de communication et de synchronisation entre tâches. 44
  • 45. File d’attente Ø L’ordre dans lequel les tâches recevront les messages est par priorité ou la tâche la plus prioritaire sera desservie. Ø Ø Les files d'attente peuvent contenir des « éléments » de taille fixe, la taille de chaque élément et le nombre maximum des éléments de la file d'attente sont définis quand la file d'attente est créée. Ø L’ordre dans lequel les tâches recevront les messages est par priorité ou la tâche la plus prioritaire sera desservie. Ø Ø Les files d'attente peuvent contenir des « éléments » de taille fixe, la taille de chaque élément et le nombre maximum des éléments de la file d'attente sont définis quand la file d'attente est créée. 45
  • 46. File d’attente xQueueHandle xQueueCreate(unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize );xQueueHandle xQueueCreate(unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize ); (uxQueueLength) : le nombre maximum de message que la file d'attente peut contenir. (uxltemsize) : la taille en octet de l'item à stocker dans la file. Retours : Si la file d'attente est crée avec succès, une poignée pour la file d'attente est retournée. Ø la tâche poste le message et poursuit son code si la file d’attente est vide Ø La tâche productrice du message peut être suspendue (timeout) si la file d’attente est pleine ; ceci permet de réaliser un mécanisme de synchronisation Ø Si le message à poster est très long, on peut poster un pointeur sur celui-ci. Ø la tâche poste le message et poursuit son code si la file d’attente est vide Ø La tâche productrice du message peut être suspendue (timeout) si la file d’attente est pleine ; ceci permet de réaliser un mécanisme de synchronisation Ø Si le message à poster est très long, on peut poster un pointeur sur celui-ci. void vQueueDelete( xQueueHandle xQueue );void vQueueDelete( xQueueHandle xQueue ); Poster un messagePoster un message Création de la fileCréation de la file Suppression de la fileSuppression de la file 46
  • 47. File d’attente Poster un message au début de la file :Poster un message au début de la file : portBASE_TYPE xQueueSend ( xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait);portBASE_TYPE xQueueSend ( xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait); (xQueue) : La poignée de la file d’attente (pvItemToQueue) :Un pointeur vers l'élément qui doit être placé dans la file d'attente. (xTicksToWait) : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se bloque si la file d'attente est pleine. 00 : la tâche poursuit son code(pas d’attente) portMAX_DELAY:portMAX_DELAY: la tâche émettrice se bloquer jusqu'à la présence du message. Poster un message à la fin de la file :Poster un message à la fin de la file : portBASE_TYPE xQueueSendToFront(xQueueHandle xQueue ,const void *pvItemToQueue, portTickType xTicksToWait);portBASE_TYPE xQueueSendToFront(xQueueHandle xQueue ,const void *pvItemToQueue, portTickType xTicksToWait); 47
  • 48. File d’attente Poster un message à partir d’une routine d'interruption (ISR):Poster un message à partir d’une routine d'interruption (ISR): portBASE_TYPE xQueueSendFromISR (xQueueHandle pxQueue, const void *pvItemToQueue, portBASE_TYPE *pxHigherPriorityTaskWoken); portBASE_TYPE xQueueSendFromISR (xQueueHandle pxQueue, const void *pvItemToQueue, portBASE_TYPE *pxHigherPriorityTaskWoken); Ø La tâche “ récepteur ” récupère le message si la file d’attente n’est pas vide. Ø Si la file d’attente est vide, la tâche est suspendue, soit pour une durée précisée (timeout), soit jusqu'à ce qu'un message soit présent dans la file. Ø Si aucun message n'est présent après la durée d'attente précisée (timeout), la tâche reprend son exécution et un message d'erreur est émis. Ø plusieurs tâches peuvent attendre devant la même file d’attente . la plus prioritaire qui recevra le message. Ø La tâche “ récepteur ” récupère le message si la file d’attente n’est pas vide. Ø Si la file d’attente est vide, la tâche est suspendue, soit pour une durée précisée (timeout), soit jusqu'à ce qu'un message soit présent dans la file. Ø Si aucun message n'est présent après la durée d'attente précisée (timeout), la tâche reprend son exécution et un message d'erreur est émis. Ø plusieurs tâches peuvent attendre devant la même file d’attente . la plus prioritaire qui recevra le message. Attendre un messageAttendre un message 48
  • 49. File d’attente portBASE_TYPE xQueueReceive(xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait );portBASE_TYPE xQueueReceive(xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait ); (pxQueue) : La poignée de la file d’attente retournée à la création. (pvBuffer ) : Pointeur vers la mémoire dans laquelle l'élément reçu sera copié. (xTicksToWait) : Le timeout indique le nombre de ticks d’horloge pendant lequel la tâche se bloque si la file d'attente est vide. unsigned portBASE_TYPE uxQueueMessagesWaiting( xQueueHandle xQueue );unsigned portBASE_TYPE uxQueueMessagesWaiting( xQueueHandle xQueue ); Nombre de messages présents dans la fileNombre de messages présents dans la file Attendre un messageAttendre un message 49
  • 50. File d’attente Création des taches et du sémaphore binaire Lancement de l'ordonnancement vTaskStartScheduler(); Tache 1 Tache 2 File d’attente Lire un message de la file d’attente Envoi d’un message à la file d’attente 50
  • 51. Merci pour votre AttentionMerci pour votre Attention Références: Ø Cours de M. Mohammed Sahari « Systèmes Temps Réel ». Département d’électronique, USTOMB. Ø Projet de fin d’étude de mastère Abdelrahime Nabie et Smail Abasse « Application du noyau temps réel FreeRTOS». Département d’électronique, USTOMB.