FreeRTOS (STM32CubeMX)

Présentation de FreeRTOS

FreeRTOS (Real-Time Operating System) est un noyau de système d'exploitation en temps réel open source conçu pour les systèmes embarqués et les microcontrôleurs. Il a été développé par Richard Barry et initialement publié en 2003. FreeRTOS fournit un ensemble de mécanismes de planification et de gestion des tâches en temps réel riches en fonctionnalités qui peuvent être utilisés pour implémenter le multitâche dans les systèmes embarqués.

L'objectif principal de FreeRTOS est de fournir un système d'exploitation en temps réel léger, efficace et portable pour les applications embarquées. Il est largement utilisé dans divers dispositifs embarqués et domaines d'application, tels que l'automatisation industrielle, les dispositifs IoT, l'électronique grand public, les systèmes de contrôle automobile, les équipements médicaux, etc.

Fonctionnalités principales de FreeRTOS

1. Planification en temps réel : permet aux développeurs de créer plusieurs tâches et d'implémenter une planification en temps réel en fonction de la priorité des tâches pour garantir que les tâches hautement prioritaires sont exécutées avant les tâches peu prioritaires.

2. Gestion des tâches : prise en charge de la création, de la suppression et de la suspension des tâches, ainsi que de la communication et de la synchronisation entre les tâches, via des primitives de synchronisation telles que des sémaphores, des files d'attente, des mutex et des groupes d'indicateurs d'événement.

3. Gestion de la mémoire : fournit des fonctions de gestion de la mémoire et peut choisir une allocation de mémoire statique ou une allocation de mémoire dynamique en fonction des exigences de l'application.

4. Minuterie logicielle : contient des minuteries logicielles qui permettent aux applications d'implémenter des fonctions de synchronisation périodiques ou ponctuelles.

5. Prise en charge de la faible consommation d'énergie : prend en charge le mode veille Hit-Tick, qui permet au microcontrôleur d'entrer dans un état de faible consommation lorsqu'il est inactif pour économiser de l'énergie.

6. Portabilité : FreeRTOS est conçu pour être hautement portable, prenant en charge plusieurs architectures de processeur et chaînes d'outils de développement.

À l'aide de FreeRTOS, les développeurs peuvent implémenter un traitement de tâches complexe en temps réel, permettant aux systèmes embarqués d'effectuer plusieurs tâches de manière efficace et fiable. Sa simplicité, sa portabilité et sa nature open source font de FreeRTOS l'un des noyaux de système d'exploitation en temps réel les plus populaires pour le développement embarqué.

Quand utiliser FreeRTOS

1. Multitâche : si l'application STM32 doit effectuer plusieurs tâches en même temps et doit planifier et gérer ces tâches en temps réel, l'utilisation de FreeRTOS est un bon choix. FreeRTOS permet de créer plusieurs tâches sur un seul microcontrôleur STM32, et la planification en temps réel est effectuée en fonction de la priorité des tâches pour garantir que les tâches hautement prioritaires peuvent être exécutées à temps.

2. Communication et synchronisation inter-tâches : si différentes tâches de l'application doivent communiquer et se synchroniser entre elles, par exemple via la transmission de messages ou le partage de données, les primitives de synchronisation fournies par FreeRTOS (telles que les files d'attente, les sémaphores, les mutex, etc.) peuvent être facilement mis en œuvre ces fonctions.

3. Exigences en temps réel : Certains scénarios d'application ont des exigences élevées en temps réel et les tâches doivent être exécutées sous des contraintes de temps strictes. FreeRTOS est un système d'exploitation en temps réel qui peut fournir des mécanismes fiables de planification des tâches et de réponse pour répondre à ces exigences en temps réel.

4. Économie d'énergie et faible consommation d'énergie : FreeRTOS prend en charge le mode Hit-Tick Sleep, qui permet au microcontrôleur d'entrer dans un état de faible consommation lorsqu'il est inactif pour économiser de l'énergie. Si votre application doit s'exécuter en mode basse consommation, FreeRTOS peut vous aider à le faire.

5. Traitement des tâches complexes : pour les applications impliquant le traitement de tâches complexes, le contrôle multithread ou les machines d'état, l'utilisation de FreeRTOS peut mieux organiser la structure du code et améliorer la lisibilité et la maintenabilité du code.

6. Portabilité multiplateforme : si l'application doit s'exécuter sur différentes plates-formes matérielles, FreeRTOS fournit une fonctionnalité hautement portable, ce qui facilite le portage et la réutilisation du code de l'application.

Lorsque les applications STM32 nécessitent le multitâche, la communication et la synchronisation inter-tâches, des garanties en temps réel ou des fonctions d'économie d'énergie et de faible puissance, FreeRTOS est un choix très approprié à considérer. Mais veuillez noter que les exigences de chaque application sont différentes.Pour les applications simples ou les scénarios à ressources limitées, vous pouvez également choisir d'autres solutions légères de gestion des tâches ou écrire un code d'interrogation simple pour implémenter des fonctions.

Comment utiliser FreeRTOS dans STM32CubeMX

L'utilisation de FreeRTOS avec STM32CubeMX est très simple. STM32CubeMX est un outil de configuration graphique fourni par STMicroelectronics, qui est utilisé pour générer rapidement le code d'initialisation et la configuration des microcontrôleurs STM32. Il prend en charge l'intégration de FreeRTOS dans les projets STM32, ce qui facilite la création et la gestion des tâches FreeRTOS et tire parti de ses capacités de planification en temps réel.

Voici les étapes de base pour utiliser FreeRTOS dans STM32CubeMX :

1. Ouvrez STM32CubeMX : Tout d'abord, ouvrez l'outil STM32CubeMX et sélectionnez le modèle de microcontrôleur STM32.
   

2. Configurer l'horloge système et les périphériques : Selon les besoins du projet, configurez l'horloge système et les périphériques dans l'onglet "Configuration". Cela inclut la configuration des sources d'horloge, des fréquences d'horloge, des broches GPIO, des modules périphériques, etc.
   
   
   
   

3. Configurez FreeRTOS : dans l'onglet "Middleware", sélectionnez "FreeRTOS" et activez-le. Vous pouvez choisir de configurer des paramètres tels que la taille de la pile et la priorité des tâches de FreeRTOS.
   
   

4. Ajout de tâches : une fois FreeRTOS configuré, des tâches peuvent être ajoutées dans l'onglet "Tâches". Cliquez sur le bouton "Ajouter une tâche" pour entrer le nom de la tâche, la taille de la pile, la priorité et d'autres informations.
   
   

5. Configurer la tâche : après avoir sélectionné la tâche ajoutée, vous pouvez configurer les propriétés de la tâche sur la droite. La priorité de la tâche, la taille de la pile et la fonction d'exécution de la tâche (fonction de tâche) peuvent être spécifiées.

6. Générer le code : après avoir terminé la configuration, cliquez sur le bouton "Projet" de la barre d'outils STM32CubeMX et sélectionnez "Générer le code" pour générer le code du projet STM32 intégré à FreeRTOS.

7. Fonction d'écriture de tâche : selon la fonction de tâche configurée dans STM32CubeMX, recherchez la fonction de la tâche correspondante dans le code généré et écrivez l'implémentation spécifique de la tâche.

8. Compiler et graver : ouvrez le projet de code généré avec votre IDE préféré (STM32CubeIDE, Keil, IAR, etc.), compilez le code et gravez-le sur le microcontrôleur STM32.

Éclairage FreeRTOS pour STM32

1. Ouvrez STM32CubeMX et sélectionnez le modèle de microcontrôleur de la série STM32F4 (par exemple, STM32F407VG).
   

2. Configurer l'horloge système et le GPIO : dans l'onglet "Configuration", configurez l'horloge système et les broches GPIO à utiliser pour contrôler les LED. Supposons que nous connections une LED à la broche 3 du GPIOB.
   

3. Configurez FreeRTOS : dans l'onglet "Middleware", sélectionnez "FreeRTOS" et activez-le. Vous pouvez ajouter des tâches dans l'onglet "Tâches", ici ajouter une tâche pour contrôler la LED.
   

4. Ajouter une tâche : Dans l'onglet "Tâches", cliquez sur le bouton "Ajouter une tâche". Nommez la tâche "LEDTask".
   

5. Configurez la tâche : faites un clic droit sur la "LEDTask" ajoutée, sélectionnez "Open Code Generation", puis entrez le nom de la fonction de la tâche dans "Task Function". Nommez la fonction de tâche "vLEDTask".
   

6. Générer du code : cliquez sur le bouton "Projet" de la barre d'outils STM32CubeMX et sélectionnez "Générer du code" pour générer du code.
   

7. Écrivez la fonction de tâche : recherchez la fonction "vLEDTask" dans le code généré et écrivez l'implémentation spécifique de la tâche.

Exemple de code (basé sur la bibliothèque HAL STM32CubeF4) :
Ajoutez le code suivant dans le fichier main.c :

//提示：包含了就不用写
#include "main.h"
#include "cmsis_os.h"

// Function prototypes
void vLEDTask(void *argument);

int main(void)
{
    
    
  xTaskCreate(vLEDTask, "LEDTask", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
  vTaskStartScheduler();
  while (1);
}

void vLEDTask(void *argument)
{
    
    
  for (;;)
  {
    
    
    HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3);
    vTaskDelay(pdMS_TO_TICKS(500));
  }
}