Cours FreeRTOS et atelier avec arduino

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

15. Gestion Des Tâches
Dans FreeRTOS

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

22. Communication et
Synchronisation entre Tâches

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

35. Exemple : Sémaphore mutex

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

40. Exemple : Sémaphore binaire

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.