Noyau FreeRTOS
Manuel du développeur

À propos du noyau FreeRTOS

Le noyau FreeRTOS est un logiciel open source géré par Amazon.

Le noyau FreeRTOS convient parfaitement aux applications en temps réel profondément intégrées qui utilisent des microcontrôleurs ou de petits microprocesseurs. Ce type d'application inclut généralement une association de ces exigences en temps réel pour le matériel et le logiciel.

Les exigences en temps réel pour les logiciels sont celles qui indiquent l'échéance de temps, mais le non-respect de l'échéance ne rend pas le système inutile. Par exemple, une réaction trop lente aux frappes peut donner l'impression qu'un système ne réagit pas sans le rendre réellement inutilisable.

Les exigences en temps réel pour le matériel sont celles qui indiquent l'échéance de temps, et le non-respect de l'échéance entraîne une panne du système. Par exemple, l'airbag d'un conducteur est susceptible de faire plus de mal que de bien s'il répond trop lentement aux informations des capteurs d'impact.

Le noyau FreeRTOS est un noyau en temps réel (ou un programmeur en temps réel) sur lequel les applications intégrées peuvent être construites pour répondre à des exigences en temps réel du matériel. Il permet aux applications d'être organisées comme un ensemble de threads indépendants d'exécution. Sur un processeur qui n'a qu'un seul cœur, un seul thread peut être exécuté à la fois. Le noyau décide quels threads doivent être exécutés en examinant la priorité attribuée à chaque thread par le concepteur d'application. Dans le cas le plus simple, le concepteur d'application pourrait affecter les priorités plus élevées aux threads qui implémentent les exigences en temps réel du matériel et réduire les priorités aux threads qui implémentent les exigences en temps réel des logiciels. Cela permettrait de s'assurer que les threads de matériel en temps réel sont toujours exécutés avant les threads de logiciel en temps réel, mais les décisions en matière d'affectation des priorités ne sont pas toujours aussi simples.

Ne vous inquiétez pas si vous ne comprenez pas encore totalement les concepts du paragraphe précédent. Ce guide les aborde en détail et fournit de nombreux exemples pour vous aider à comprendre comment utiliser un noyau en temps réel, et plus particulièrement le noyau FreeRTOS.

Proposition de valeur

La réussite globale sans précédent du noyau FreeRTOS est due à sa proposition de valeur exceptionnelle. Le noyau FreeRTOS est développé professionnellement, sa qualité fait l'objet d'un contrôle rigoureux, il est solide, pris en charge et ne contient aucune ambiguïté de propriété intellectuelle. De plus, il peut vraiment être utilisé librement dans les applications commerciales sans aucune exigence d'exposition de votre propre code source. Vous pouvez prendre un produit sur le marché à l'aide du noyau FreeRTOS sans avoir à payer de frais, et des milliers de personnes le font. Si, à tout moment, vous souhaitez recevoir de sauvegardes supplémentaires, ou si votre équipe juridique a besoin de garanties ou dédommagements écrits, il existe un chemin de mise à niveau commercial simple à faible coût. Vous aurez l'esprit tranquille sachant que vous pouvez choisir la route commerciale à n'importe quel moment.

Remarque sur la terminologie

Dans le noyau FreeRTOS, chaque thread d'exécution est qualifié de tâche. Bien qu'il n'existe pas de consensus sur la terminologie dans la communauté intégrée, thread peut avoir une signification plus spécifique dans certains champs d'application.

Pourquoi utiliser un noyau en temps réel ?

Il existe de nombreuses techniques bien établies pour écrire un bon logiciel intégré sans utiliser de noyau, et si le système développé est simple, ces techniques peuvent fournir la solution la plus appropriée. Dans des cas plus complexes, l'utilisation d'un noyau est préférable, mais le point de croisement est toujours subjectif.

La hiérarchisation des tâches peut vous aider à vous assurer qu'une application répond à ses délais de traitement, mais un noyau peut également offrir d'autres avantages moins évidents :

  • Retrait des informations relatives à la durée

Le noyau est responsable de la durée d'exécution et fournit une API temporelle à l'application. Cela permet à la structure du code d'application d'être plus simple et à la taille globale du code d'être plus petite.

  • Possibilité de gestion/d'extension

Le retrait des détails temporels entraîne moins d'interdépendances entre les modules et permet au logiciel d'évoluer de manière contrôlée et prévisible. En outre, le noyau est responsable de l'espace temporel, c'est pourquoi les performances des applications sont moins sensibles aux changements de matériel sous-jacent.

  • Modularité

Les tâches sont des modules indépendants, chacun d'entre ayant un objectif bien défini.

  • Développement en équipe

Les tâches doivent également disposer d'interfaces bien définies, ce qui simplifie le développement par les équipes.

  • Tests simplifiés

Si les tâches sont des modules indépendants bien définis avec des interfaces propres, elles peuvent être testées isolément.

  • Réutilisation du code

Une modularité supérieure et moins d'interdépendances permettent de réutiliser le code avec moins d'effort.

  • Efficacité améliorée

L'utilisation d'un noyau permet aux logiciels d'être entièrement basés sur les événements, ce qui signifie qu'aucun temps de traitement n'est perdu en interrogeant des événements qui n'ont pas eu lieu. Le code est exécuté uniquement lorsque quelque chose doit être effectué.

Le gain en efficacité est contrebalancé par la nécessité de traiter les interruptions de tics RTOS et de faire passer l'exécution d'une tâche à l'autre. Toutefois, les applications qui n'utilisent pas RTOS incluent normalement une forme ou une autre d'interruption de tics.

  • Délai d'inactivité

La tâche inactive est créée automatiquement lorsque le planificateur est démarré. Elle est exécutée chaque fois qu'il n'y a pas de tâches d'application à exécuter. La tâche inactive peut être utilisée pour mesurer la capacité de traitement de secours, pour effectuer des vérifications d'antécédents ou simplement pour placer le processeur en mode de faible consommation.

  • Gestion de la consommation

Les gains en efficacité liés à l'utilisation d'un RTOS permettent au processeur de passer plus de temps en mode de faible consommation.

La consommation d'énergie peut être réduite de manière significative en plaçant le processeur dans un état de faible consommation chaque fois que la tâche inactive est exécutée. Le noyau FreeRTOS possède également un mode sans tics qui permet au processeur de passer au mode de faible consommation et d'y rester plus longtemps.

  • Gestion flexible des interruptions

Les gestionnaires d'interruptions peuvent être très courts si le traitement est attribué à une tâche créée par le créateur de l'application ou la tâche démon FreeRTOS.

  • Exigences de traitement mixtes

Les modèles de conception simples peuvent atteindre un mélange de traitement périodique, en continu et basé sur les événements au sein d'une application. En outre, les exigences en temps réel pour les logiciels et le matériel peuvent être satisfaites en sélectionnant les priorités de tâches et d'interruptions appropriées.

Fonctionnalités de noyau FreeRTOS

Le noyau FreeRTOS a plusieurs fonctionnalités standard :

  • Opération préventive ou coopérative

  • Affectation de priorités de tâches très flexible

  • Mécanisme de notification de tâches flexible, rapide et léger

  • Files d'attente

  • Sémaphores binaires

  • Sémaphores de comptabilisation

  • Mutex

  • Mutex récursifs

  • Minuteurs de logiciels

  • Groupes d'événements

  • Fonctions de crochet de tics

  • Fonctions de crochet des tâches inactives

  • Vérification du dépassement de capacité de la pile

  • Enregistrement des traces

  • Collecte des statistiques d'exécution de tâche

  • Licences commerciales et support facultatifs

  • Modèle d'imbrication d'interruption complète (pour certaines architectures)

  • Capacité sans tic-tac pour les applications à alimentation faible

  • Pile d'interruption gérée par le logiciel lorsque cela s'avère approprié (cela peut vous aider à économiser de la RAM)

Licences

Le noyau FreeRTOS est disponible pour les utilisateurs selon les conditions de la licence MIT.

Projets et fichiers source inclus

Le code source, des fichiers de projet préconfigurés et les instructions complètes de création pour tous les exemples présentés sont fournis dans un fichier zip. Vous pouvez télécharger le fichier zip depuis http://www.FreeRTOS.org/Documentation/code si vous n'avez pas reçu une copie avec le livre. Le fichier zip n'inclut pas nécessairement la version la plus récente du noyau FreeRTOS.

Les captures d'écran incluses dans ce manuel ont été prises pendant l'exécution des exemples dans un environnement Microsoft Windows, à l'aide du port Windows FreeRTOS. Le projet qui utilise le port Windows FreeRTOS est préconfiguré pour créer à l'aide de l'édition Express gratuite de Visual Studio, qui peut être téléchargée sur https://www.visualstudio.com/vs/community/. Bien que le port Windows FreeRTOS dispose d'une plateforme pratique d'évaluation, de développement et de test, il ne fournit pas de véritable comportement en temps réel.