II2 – Informatique embarquée

Mise en œuvre d’un système

d’exploitation temps réel :
FreeRTOS – Services
Anthony Juton – mars 2023

Ce troisième TP sur FreeRTOS amène à mettre en œuvre différents services offerts par le noyau
FreeRTOS.
Commencer par vérifier l’ensemble de la chaîne de développement, à l’aide du programme de
base fourni sur moodle ou d’un programme du TP précédent.

Pour commencer un nouveau projet à partir d’un projet existant, depuis le volet Project Explorer,
copier le projet puis coller le projet. Renommer ensuite le fichier .ioc avec le même nom,
exactement, que le projet. Supprimer le dossier debug et le fichier .launch. Compiler.

1. Partage de ressources

On décide d’afficher avec une couleur différente les temps de chaque tâche.
La tâche d’affichage 1 dure 4 ms environ (on ajoute du calcul, voir TP2), avec une période de
100 ms. Elle affiche « tache1 » et les secondes et millisecondes d’une couleur sur la gauche de
l’écran, à chaque fois une ligne plus bas, comme dans l’exemple du cours. Elle est peu
prioritaire.
La tâche d’affichage 2 n’a pas de calculs et une période de 7 ms. Elle affiche « tache2 » et les
secondes et millisecondes d’une autre couleur sur la droite de l’écran, à chaque fois une ligne
plus bas, comme dans l’exemple du cours.
La tâche par défaut continue de faire clignoter une led de manière périodique.

Figure 1: Configuration des tâches pour la mise en évidence des problèmes de partage de
ressource.
Q1.1 Que constate-t-on ? Expliquer les raisons du problème.
Pour résoudre ce problème, il est possible d’utiliser un MUTEX ou sémaphore binaire (mutex)
pour bloquer l’usage de la ressource. CubeMx assiste à la création du MUTEX. Le guide de
FreeRTOS donne des éléments sur son usage. ( https://www.freertos.org/CreateMutex.html ),
tout comme le cours.

Mise en œuvre d’un système d’exploitation temps réel : FreeRTOS – Les services 1/7
 II2 – Informatique embarquée

Créer un Mutex dans CubeMX et le mettre en œuvre pour protéger la partie du code concernant
l’afficheur lcd.

Figure 2: Création d'un Mutex dans CubeMX

Q1.2. Présenter le code commenté.

Q1.3. Le problème est-il résolu ? Pourquoi ?
Q1.4. Mettre un point d’arrêt dans la section protégée de la tâche de moindre priorité, à un
moment où elle bloque la tâche prioritaire (il est possible de diminuer la période de la tâche
prioritaire pour que ce blocage soit plus fréquent). Ajouter au compte-rendu une copie d’écran
de la vue FreeRTOS Task List mettant en évidence l’héritage de priorité.

2. Gestion de la messagerie par files d’attente

Les files d’attente, de type FIFO, permettent le traitement de tous les messages dans leur ordre
d’apparition. Cela sera utile notamment pour la réception des lettres envoyées par la liaison
série (partie suivante).
Pour les messageries entre tâches, créer les files d’attente (Queues) sous CubeMx
(https://www.freertos.org/a00018.html )  :

Figure 3: Configuration des files d'attente (Queues)

Ensuite, il est possible :

Mise en œuvre d’un système d’exploitation temps réel : FreeRTOS – Les services 2/7
 II2 – Informatique embarquée

• d’envoyer des messages depuis une tâche :

uint16_t Message;
...
xQueueSend(myQueueP2VHandle, &Message, 0);

• d’envoyer des messages depuis une fonction d’interruption :

uint16_t Message;
...
xQueueSendFromISR(myQueueU2HHandle, &Message, 0);

• D’attendre la réception d’un message dans une tâche. La tâche est alors bloquée en
attente du message (il est possible de mettre un Timeout à la place de portMAX_DELAY) :
uint16_t Message;
...
xQueueReceive(myQueueP2VHandle, &Message, portMAX_DELAY);

Q2.1. A l’aide de la documentation en ligne de FreeRTOS

(https://www.freertos.org/a00117.html), expliquer à quoi sert le 3 ème paramètre de la fonction
xQueueSend(). Quelle valeur choisir ? Que renvoie la fonction ? Que signifie pdPASS dans
l’exemple en ligne ?

Q2.2. A l’aide de la documentation en ligne de FreeRTOS

(https://www.freertos.org/a00119.html), expliquer à quoi sert le 3 ème paramètre de la fonction
xQueueSendFromISR(). Pourquoi est-ce différent de la fonction xQueueSend() ? Quelle valeur
choisir ? Que renvoie la fonction ?

Q2.3. A l’aide de la documentation en ligne de FreeRTOS

(https://www.freertos.org/a00118.html), expliquer à quoi sert le 3 ème
paramètre de la fonction
xQueueReceive(). Quelle valeur choisir ? Que renvoie la fonction ?

Q2.4. Modifier le code pour que la tâche de clignotement de la led utilise comme durée de
sommeil la valeur millisecond1 issue de la lecture de l’horloge RTC envoyée par la tâche 1.

Q2.5. Expliquer le code, en prenant soin de détailler le type de variable utilisé, les rôles des
paramètres des fonctions utilisées, ce qui est transmis, si des valeurs sont stockées et où, ce
qu’il se passe lorsque la file d’attente est pleine.

3. Gestion des interruptions

On se propose de récupérer les informations envoyées par l’ordinateur via la liaison série pour
allumer/éteindre la LED16 et de les afficher sur l’écran.

Mise en œuvre d’un système d’exploitation temps réel : FreeRTOS – Les services 3/7
 II2 – Informatique embarquée

Créer une tâche Affichage_texte peu prioritaire affichant du texte sur la dernière ligne de l’écran.
Les tâches 1 et 2 seront configurées pour ne pas écrire sur cette ligne.
Activer l’interruption dans CubeMx > Connectivity > Usart1

Choisir la priorité dans CubeMx > System Core

Dans la zone de code PV du fichier main.c, dédiée aux variables globales, ajouter une variable
pour recevoir les caractères, un à un, en réception de l’uart.
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
uint8_t caractere_recu;
/* USER CODE END PV */

Dans la zone de code 2 du main, dédiée aux initialisations, après les initialisations de base des
périphériques, ajouter l’activation de l’interruption de réception d’un caractère.
/* USER CODE BEGIN 2 */
// init de l’afficheur notamment
HAL_UART_Receive_IT(&huart1,&caractere_recu,1);
/* USER CODE END 2 */

Dans la zone de code 4, créer la fonction Callback qui sera exécutée à chaque réception du
nombre de caractères indiqué dans HAL_UART_Receive_IT(...).
Le contrôle de la Led16 permet de valider le bon fonctionnement de l’interruption.
/* USER CODE BEGIN 4 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(caractere_recu=='a') HAL_GPIO_WritePin(LED16_GPIO_Port, LED16_Pin,1);
if(caractere_recu=='e') HAL_GPIO_WritePin(LED16_GPIO_Port, LED16_Pin,0);
HAL_UART_Receive_IT(&huart1,&caractere_recu,1);
}
/* USER CODE END 4 */

Mise en œuvre d’un système d’exploitation temps réel : FreeRTOS – Les services 4/7
 II2 – Informatique embarquée

Valider le contrôle de la LED16 par le PC (via un terminal, minicom ou cutecom sur Linux,
Teraterm sur Windows...)
Q3.1. Ajouter au compte-rendu une copie d’écran des priorités des différentes interruptions.
Quelle est la priorité proposée par défaut par CubeMX pour la liaison série ? Quelle est la priorité
de l’ordonnanceur ? Que peut-on en conclure ?

La variable caractère_recu est remplie par la fonction d’interruption. Il est possible de l’utiliser
pour afficher le texte reçu via la tâche AffichageText peu prioritaire et de période 100 ms :
/* USER CODE END Header_Fonction_AffichageText */
void Fonction_AffichageText(void const * argument)
{
/* USER CODE BEGIN Fonction_AffichageText */
extern uint8_t caractere_recu;
uint16_t index = 0;
uint8_t text[2];
/* Infinite loop */
for(;;)
{
if(caractere_recu != 0)
{
sprintf(text,"%c",caractere_recu);
caractere_recu=0;
BSP_LCD_SetFont(&Font12);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(index,260,(uint8_t*) text,LEFT_MODE);
index = (index + 12)%480;
}
osDelay(100);
}
/* USER CODE END Fonction_AffichageText */
}

Q3.2. Comment appelle-t-on ce passage d’information de la fonction d’interruption vers la tâche

AffichageText ? Mettre en évidence les limites de cette méthode en tapant vite sur le clavier.

Ajouter alors la messagerie nécessaire (avec xQueueSendFromISR(..) ) pour déposer les

caractères dans la file d’attente dès leur arrivée. Ajouter la réception dans la tâche
AffichageText. La file d’attente étant déclarée dans freertos.c, on rappelle son existence dans
main.c par extern osMessageQId QueueUARTHandle.

Mise en œuvre d’un système d’exploitation temps réel : FreeRTOS – Les services 5/7
 II2 – Informatique embarquée

/* USER CODE BEGIN 4 */

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
extern osMessageQId QueueUARTHandle;
...

void Fonction_AffichageText(void const * argument)

{
/* USER CODE BEGIN Fonction_AffichageText */
uint8_t caractere_a_afficher;
uint16_t index = 0;
uint8_t text[2];
/* Infinite loop */
for(;;)
{
while(xQueueReceive(QueueUARTHandle,&caractere_a_afficher,0))
...

Q3.3. Présenter le code commenté.

Q3.4. Est-ce fonctionnel ? Justifier pourquoi.
Q3.5. Pourquoi l’affichage ne se fait-il pas dans la tâche interruption ?
Q3.6. Expliquer ce qu’est une section critique :
(https://www.freertos.org/taskENTER_CRITICAL_taskEXIT_CRITICAL.html). Pourquoi n’est-elle pas
nécessaire ici ?

4. Bibliographie

Mastering the FreeRTOS™Real Time Kernel sur le site https://freertos.org/

UM1907, User manual, Discovery kit for STM32F7 Series with STM32F746NG MCU sur le site
ST.com

Mise en œuvre d’un système d’exploitation temps réel : FreeRTOS – Les services 6/7
 II2 – Informatique embarquée

5. Evaluation

Q1.1 Partage de Ressource. Constat ? Raisons du problème ?

Q1.2. Mutex : code commenté.
Q1.3. Le problème est-il résolu ? Pourquoi ?
Q1.4. Copie d’écran mettant en évidence héritage de priorité.
Q2.1. Expliquer 3ème paramètre de la fonction xQueueSend(). Quelle valeur choisir ? Que renvoie
la fonction ? Que signifie pdPASS dans l’exemple en ligne ?
Q2.2. Expliquer 3ème paramètre de la fonction xQueueSendFromISR(). Pourquoi est-ce différent
de la fonction xQueueSend() ? Quelle valeur choisir ? Que renvoie la fonction ?
Q2.3. Expliquer 3ème paramètre de la fonction xQueueReceive(). Quelle valeur choisir ? Que
renvoie la fonction ?
Q2.4. Code tâche de clignotement utilise la valeur millisecond1 de la tâche 1.
Q2.5. Expliquer le code (type de variable, rôles des paramètres, ce qui est transmis, valeurs
stockées et où, que se passe-t-il si file d’attente est pleine)
Q3.1. Copie d’écran des priorités. Priorité pour la liaison série ? Priorité de l’ordonnanceur ? Que
peut-on en conclure ?
Q3.2. Comment appelle-t-on ce passage d’information ? Mettre en évidence les limites.
Q3.3. File d’attente. Présenter le code commenté.
Q3.4. Est-ce fonctionnel ? Justifier pourquoi.
Q3.5. Pourquoi l’affichage ne se fait-il pas dans la tâche interruption ?
Q3.6. Expliquer ce qu’est une section critique. Pourquoi n’est-elle pas nécessaire ici ?

Mise en œuvre d’un système d’exploitation temps réel : FreeRTOS – Les services 7/7