Gestion des Interruptions en Programmation C

Noyaux Temps-Réel : Les Sémaphores

• Les sémaphores sont des mécanismes utilisés dans les systèmes temps réel pour gérer l'accès aux ressources partagées entre les tâches.
• Un sémaphore binaire est une variable d'état qui peut prendre les valeurs 0 ou 1.
• La valeur 1 indique que la ressource est disponible, tandis que 0 indique qu'elle est en cours d'utilisation.
• Les sémaphores permettent de synchroniser l'accès aux ressources partagées, en évitant les conflits d'accès et les incohérences de données.
• Les sémaphores sont cruciaux pour la gestion des interruptions dans les systèmes temps réel, garantissant l'accès unique à une ressource à tout moment.

Sémaphores Binaires

• Les sémaphores binaires sont utilisés pour gérer l'accès à une ressource unique, vérifiant que seule une tâche accède à la ressource à la fois.
• Un exemple de code est fourni, démontrant l'utilisation d'interruptions pour signaler la disponibilité d'un caractère sur un port série.
• Ceci permet de gérer les événements sans bloquer le reste du programme.
• Le code montre également l'utilisation de temporisations (TIM1_IRQHandler).
• Le code inclut une discussion sur la gestion de traitements longs.

Traitements dans une Superboucle

• Un exemple est donné de la façon dont les traitements peuvent être délégués dans une superboucle en utilisant des indicateurs pour éviter des blocages et des conflits.
• Ce principe permet la gestion de plusieurs événements sans perdre l'exécution de la tâche principale, avec des exemples de codes et commentaires.
• Une variable supplémentaire est utilisée pour signaler que des données sont disponibles sur le port série.
• Ceci assure l'appel à la fonction de traitement appropriée lorsque les données sont disponibles, sans interrompre le reste de l'exécution.
• Des exemples de codes sont montrés pour illustrer ces concepts.

Traitements dans des Tâches

• Un exemple est fourni qui illustre comment déléguer ces traitements aux tâches, maximisant la réactivité, sans perdre les priorités et la flexibilité du programme.
• Il illustre la création de tâches dédiées pour chaque type d'événement.
• Le code est explicitement annoté pour souligner les nouvelles additions et les changements clés.
• Des fonctions, comme les fonctions de création de tâches (xTaskCreate), sont présentées pour la gestion des tâches.
• La création de tâches via xTaskCreate est mise en avant comme un moyen efficace pour gérer les traitements avec des priorités.
• Il aborde également la question du problème rencontré lorsque les traitements sont trop longs.

La Bonne Méthode avec les Sémaphores

• L'approche utilisant des sémaphores, avec des exemples de codes, est décrite comme la meilleure pratique pour la gestion des interruptions dans les systèmes temps réel.
• L'utilisation de sémaphores fournit des mécanismes pour gérer l'accès concurrentiel aux ressources, empêchant les conflits.
• L'emploi des sémaphores est expliqué et illustre le fonctionnement en détails.

Syntaxe et Création d'un Sémaphore

• La syntaxe pour créer un sémaphore binaire est illustrée avec des exemples de code.
• La façon de détruire un sémaphore est expliquée, assurant la libération des ressources mémoire associées.
• On en déduit la manière dont on initialise et gère les sémaphores.

Manipulation d'un Sémaphore

• La syntaxe pour manipuler un sémaphore lors de l'obtention et de la libération est exposée.
• La syntaxe utilise des fonctions comme xSemaphoreTake et xSemaphoreGive.
• L'utilisation de temps limite (xTicksToWait) pour éviter les blocages potentiels.

Manipulation d'un Sémaphore en Interruption

• La manipulation d'un sémaphore dans le contexte d'une interruption est détaillée.
• Elle porte sur la création et l'utilisation de sémaphores, soulignant l'importance et la manière correcte de gérer les priorités.
• Il précise l'utilisation de cette fonction.

Sémaphores Mutex

• Les sémaphores mutex sont utilisés pour la protection de ressources partagées, garantissant un accès exclusif à la ressources.
• On en tire que les sémaphores mutex sont extrêmement importants pour éviter les problèmes d'interblocage.

Cas d'Utilisation : Mémoire Partagée

• Les cas d'utilisation démontrent l'utilité des sémaphores dans les scénarios de mémoire partagée.
• Les sémaphores mutex sont expliqués par un schémas pour illustrer des exemples avec différents cas et tâches.

Ressource et Section Critique

• La notion de ressource critique et de section critique est définie, expliquant la nécessité de protéger les données partagées d'un accès concurrent.

Protection par Blocage des Interruptions

• Cette méthode de protection des parties critiques d'un code bloque toutes les interruptions pendant le temps critique.
• L'utilisation de cette méthode est déconseillée dans les systèmes temps réel à cause des inconvénients.
• Cette méthode est expliquée avec un diagramme d'étapes et quelques lignes de code en exemple.

Protection en Bloquant la Préemption

• Cette approche bloque la préemption des tâches pendant un accès concurrentiel à une ressource critique.
• Elle décrit la manière dont l'interruption est gérée, ainsi que les conséquences du blocage de la préemption.

Protection en Utilisant un Sémaphore Mutex

• L'utilisation d'un sémaphore mutex pour protéger une section critique est décrite.
• Il souligne qu'un mutex assure un accès exclusif à une ressource critique lors d'une requête.

Sémaphore d'Exclusion Mutuelle (Sémaphore Mutex)

• Le sémaphore mutex est une variante du sémaphore binaire, conçu pour l'exclusion mutuelle.
• Ceci garantit qu'aucune tâche ne partage la ressource en même temps
• Explication des caractéristiques et différences associées à ce sémaphore.

L'Inversion de Priorité

• Le problème de l'inversion de priorité est décrit.
• Ceci explique les difficultés liées à l'exécution des tâches à cause des priorités et inter-dépendances des tâches.

Le Problème d'Interblocage (Deadlock)

• Le problème de deadlock est expliqué.
• Explique les conditions qui provoquent ce problème et la manière de l'éviter en utilisant des sémaphores mutex.

Gestion de la File d'Attente des Tâches

• Il est expliqué comment les tâches en attente sur le mutex sont gérées.
• Décrit un système dans lequel la tâche prioritaire est libérée en premier.

Implémentation d'un Sémaphore

• Une implémentation simple d'un sémaphore en utilisant un indicateur est fournie.
• Ce cas particulier est montré comme une mauvaise approche en temps réel.

Sémaphore à Comptes

• La gestion des sémaphores à comptes est détaillée.
• Il dépeint un mécanisme utile pour gérer un nombre limité d'utilisations d'une ressource, comme un compteur de ressources.

Ce quiz évalue vos connaissances sur le rôle et le fonctionnement des interruptions dans le code en C, notamment dans le contexte des fonctions UART et Timer. Vous allez explorer les fonctions spécifiques telles que HAL_UART_Receive_IT et HAL_TIM_Base_Start_IT, ainsi que l'impact de traitements longs après une interruption.