Introduction à la transplantation de FreeRTOS sur STM32

Cet article détaile la procédure d'intégration du système d'exploitation temps réel FreeRTOS sur des microcontrôleurs STM32, en utilisant l'environnement de développement MDK2020 (Keil uVision). Il couvre les concepts fondamentaux de FreeRTOS, la configuration matérielle du STM32, les étapes de transplantation, ainsi que les techniques de débogage et d'optimisation.

Fondamentaux de FreeRTOS

Vue d'ensemble du noyau

FreeRTOS est un système d'exploitation temps réel léger conçu pour les systèmes embarqués. Il fournit des mécanismes de gestion des tâches, de synchronisation et de communication inter-tâches. Le noyau comprend un ordonnanceur, des temporisateurs, des sémaphores, des files de messages et des mutex, permettant une réponse déterministe aux événements externes.

Gestion des tâches

Les tâches sont les unités d'exécution de base dans FreeRTOS. La créasion d'une tâche s'effectue via l'API vTaskCreate(), tandis que la suppression se fait avec vTaskDelete(). Les niveaux de priorité des tâches dictent l'ordre d'exécution, avec un ordonnanceur préemptif qui permet aux tâches de haute priorité d'interrompre celles de basse priorité.

Mécanismes de synchronisation et de communication

Pour la coordination entre tâches, FreeRTOS offre des sémaphores, des mutex, des files de messages et des groupes d'événements. Les sémaphores gèrent l'accès exclusif aux ressources partagées, tandis que les files de messages facilitent l'échange de données. Les groupes d'événements permettent à plusieurs tâches d'attendre des événements multiples.

Gestion de la mémoire

La gestion de la mémoire dans FreeRTOS inclut des stratégies dynamiques et statiques. Des blocs de mémoire pré-alloués réduisent la fragmentation, et des implémentations telles que heap_1.c, heap_2.c, heap_3.c et heap_4.c offrent différentes options d'allocation. La détection des fuites mémoire peut être activée via des fonctions de rappel.

Microcontrôleurs STM32

Présentation des séries

Les microcontrôleurs STM32 de STMicroelectronics utilisent des cœurs ARM Cortex-M, offrant une gamme variée de performances et de fonctionnalités. Les séries comme STM32F0, STM32F1, STM32F4 et STM32L1 ciblent des applications allant de l'économie d'énergie au traitement de signaux avancé. Par exemple, les STM32F4 atteignent des fréquences jusqu'à 180 MHz avec support du point flottant.

Architecture matérielle

L'architecture du STM32 comprend un processeur Cortex-M, des interfaces de périphériques telles que GPIO, ADC, USART, SPI et I2C, ainsi qu'une structure de mémoire flexible avec Flash interne et RAM. La gestion de l'alimentation offre des modes basse consommation comme le mode veille et le mode arrêt, avec des mécanismes de réveil par interrruption.

Environnement de développement

MDK2020 (Keil uVision) est un IDE populaire pour le développement STM32, avec des outils graphiques pour la configuration des périphériques et le débogage. Les cartes de développement et les débogueurs comme ST-Link accélèrent le prototypage, permettant le pas-à-pas, la surveillance des registres et l'analyse mémoire.

Procédure de transplantation de FreeRTOS

Préparation

Avant la transplantation, une analyse des besoins est requise : sélection du modèle STM32, version de FreeRTOS, limites de mémoire et exigences de performance en temps réel. L'environnement doit être configuré avec l'installation de MDK2020, STM32CubeMX pour la génération de code d'initialisation, et les pilotes de débogage appropriés.

Obtention et compilation du code source

Le code source de FreeRTOS peut être téléchargé depuis des dépôts open source. Après extraction, le fichier FreeRTOSConfig.h doit être configuré pour ajuster les paramètres tels que le nombre de tâches, la taille de la pile et les politiques d'ordonnancement. Le code source est ensuite ajouté au projet MDK2020, avec des instructions de compilation pour spécifier les répertoires d'inclusion.

Étapes de transplantation

La transplantation utilise des modèles fournis par FreeRTOS, adaptés à l'architecture ARM Cortex-M. Pour un STM32F1 basé sur Cortex-M3, on sélectionne le modèle dans portable/GCC/ARM_CM3. Les fonctions liées au matériel, comme la gestion des interruptions et l'initialisation de l'horloge, doivent être implémentées. La configuration de l'horloge système et des vecteurs d'interruption est cruciale, avec la définition des priorités d'interruption dans le NVIC pour supporter l'ordonnancement préemptif.

Initialisation et création de tâches

L'initialisation du noyau se fait en appelant vTaskStartScheduler() dans la fonction principale. La première tâche est créée avec vTaskCreate(), en allouant une pile dynamiquement ou statiquement. Exemple de code pour la création de tâche :

#define TASK_STACK_SIZE 256
TaskHandle_t taskHandle;
void TaskFunction(void *params) {
    while (1) {
        // Code de la tâche
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}
void main() {
    xTaskCreate(TaskFunction, "Task1", TASK_STACK_SIZE, NULL, 1, &taskHandle);
    vTaskStartScheduler();
}

Configuration du système

Allocation et gestion de la pile

La taille de la pile pour chaque tâche doit être estimée en fonction de la profondeur d'appel et des variables locales. Des outils comme STM32CubeMX aident à analyser l'utilisation maximale de la pile. Pour prévenir les débordements, des mécanismes de détection peuvent être activés via des fonctions de rappel :

#define STACK_WARNING_THRESHOLD 128
void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName) {
    // Gestion du débordement de pile
}

Configuration de l'horloge

La configuration de l'horloge système STM32 implique la sélection de la source d'horloge, les diviseurs et les multiplicateurs PLL. Par exemple, en utilisant HAL :

void SystemClock_Config(void) {
    RCC_OscInitTypeDef osc_config = {0};
    osc_config.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    osc_config.HSEState = RCC_HSE_ON;
    osc_config.PLL.PLLState = RCC_PLL_ON;
    osc_config.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    osc_config.PLL.PLLMUL = RCC_PLL_MUL9;
    HAL_RCC_OscConfig(&osc_config);
    RCC_ClkInitTypeDef clk_config = {0};
    clk_config.ClockType = RCC_CLOCKTYPE_SYSCLK;
    clk_config.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    clk_config.AHBCLKDivider = RCC_SYSCLK_DIV1;
    HAL_RCC_ClockConfig(&clk_config, FLASH_LATENCY_2);
}

Vecteurs d'interruption

La table des vecteurs d'interruption définit les fonctions de service d'interruption (FSI). Les priorités d'interruption sont configurées via le NVIC pour garantir une réponse rapide aux événements temps réel. Les FSI doivent être optimisées pour minimiser le temps d'exécution.

Personnalisation de FreeRTOSConfig.h

Le fichier FreeRTOSConfig.h permet de configurer le noyau FreeRTOS pour le STM32. Des paramètres clés incluent :

#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H
#define configMAX_PRIORITIES 5
#define configMINIMAL_STACK_SIZE ( (unsigned portBASE_TYPE) 192 )
#define configTICK_RATE_HZ ( (portTickType) 1000 )
#define configSUPPORT_STATIC_ALLOCATION 1
#define configUSE_TIMERS 1
#define configCHECK_FOR_STACK_OVERFLOW 2
#endif

Les optimisations de performance impliquent l'ajustement des priorités des tâches, des stratégies de gestion de la mémoire et la réduction des surcharges de changement de contexte. Les problèmes courants comme les blocages de tâches ou les fuites mémoire peuvent être diagnostiqués en ajustant ces configurations.

Utilisation avancée de MDK2020

Fonctionnalités de l'IDE

MDK2020 offre un éditeur avec coloration syntaxique, auto-complétion et des outils de débogage tels que des points d'arrêt, des vues de registre et des analyseurs de performance. Les options de compilation permettent de contrôler l'optimisation du code et la mise en mémoire.

Débogage et analyse

Pour le débogage, l'utilisation de points d'arrêt conditionnels et l'inspection de la mémoire en temps réel sont essentielles. L'analyse de performance identifie les goulets d'étranglement, tandis que la couverture de code assure que tous les chemins sont testés. La surveillance de l'utilisation de la pile aide à éviter les débordements :

// Exemple d'analyse de pile
void monitorStackUsage() {
    UBaseType_t stackHighWaterMark = uxTaskGetStackHighWaterMark(NULL);
    // Journaliser la valeur pour le débogage
}