Débogage avancé des systèmes embarqués : SEGGER RTT et SystemView pour FreeRTOS
Le débogage efficace et l'analyse des performances des systèmes embarqués sont des piliers du développement de microcontrôleurs. Les technologies SEGGER RTT (Real-Time Transfer) et SystemView offrent des outils puissants pour ces tâches, permettant aux développeurs d'obtenir des informations de débogage détaillées et de surveiller en profondeur un système d'exploitation temps réel (RTOS), tel que FreeRTOS, sans interrompre le fonctionnement du dispositif cible. Cet article explorera les principes de fonctionnement et les aspects pratiques de la configuration de RTT Viewer pour la sortie de journaux et de SystemView pour la visualisation des événements RTOS, ce qui est d'une importance capitale pour diagnostiquer des comportements complexes dans les logiciels embarqués.
Fondamentaux du débogage des systèmes embarqués et le rôle de SEGGER RTT
Le débogage des systèmes embarqués exige des approches spécialisées qui minimisent l'impact sur le comportement du dispositif cible. Les méthodes traditionnelles, comme le débogage JTAG/SWD avec des points d'arrêt, peuvent introduire des retards indésirables. C'est là que des mécanismes tels que DAP (Debug Access Port), ITM (Instrumentation Trace Macrocell) et RTT (Real-Time Transfer) entrent en jeu.
- DAP (Debug Access Port) : Un bloc matériel qui fournit un accès aux bus et au cœur du microcontrôleur pour le débogage.
- ITM (Instrumentation Trace Macrocell) : Un bloc spécialisé dans les cœurs Cortex-M (à partir de M3), conçu pour la sortie à haute vitesse de messages de débogage avec un surcoût temporel minimal.
- RTT (Real-Time Transfer) : Une technologie propriétaire de SEGGER qui utilise un tampon circulaire dans la RAM du microcontrôleur pour un échange de données bidirectionnel avec l'ordinateur hôte. L'avantage clé de RTT est sa non-intrusivité : le CPU du microcontrôleur n'est pas arrêté, et les informations de débogage sont transmises à très haute vitesse, ce qui le rend idéal pour la sortie de journaux en temps réel (
printf).
Pour intégrer RTT dans un projet, vous devez ajouter les fichiers source de la bibliothèque SEGGER RTT. Le processus n'est pas lié à un environnement de développement intégré (IDE) spécifique, qu'il s'agisse de Keil uVision ou d'un autre. Après la compilation et l'exécution, le débogueur J-Link recherche automatiquement la structure RTT Control Block (CB) dans la RAM du microcontrôleur. Ce bloc contient un identifiant, le nombre de canaux et une description des tampons circulaires pour la lecture et l'écriture, fournissant un point d'entrée pour l'échange de données. Dans la plupart des cas, la recherche est automatisée, mais une configuration manuelle de l'adresse est également possible.
Exemple de connexion et d'utilisation de RTT :
Inclusion des fichiers d'en-tête :
#include <stdio.h>
#include "SEGGER_RTT.h"Wrappers pour les messages typés (facultatif, pour plus de commodité) :
#define LOG_INFO(msg, ...) { SEGGER_RTT_TerminalOut(0, "INFO: "); SEGGER_RTT_printf(0, msg, ##__VA_ARGS__); }
#define LOG_ERR(msg, ...) { SEGGER_RTT_TerminalOut(0, "ERROR: "); SEGGER_RTT_printf(0, msg, ##__VA_ARGS__); }
void LOG_FLOAT(const char* prefix, float value, const char* suffix) {
char buf[64];
snprintf(buf, sizeof(buf), "%s%.2f%s", prefix, value, suffix);
SEGGER_RTT_TerminalOut(0, buf);
}Initialisation du bloc de contrôle et sortie des journaux :
SEGGER_RTT_Init();
// ...
LOG_INFO("Chauffage central : %s\r\n", Boiler.isCentralHeatingActive(response) ? "activé" : "désactivé");
LOG_ERR("Erreur : OpenTherm n'est pas initialisé");L'utilitaire RTT Viewer, inclus dans le package de pilotes J-Link, permet de visualiser ces journaux. Il prend en charge l'affichage d'informations sur diverses onglets (terminaux) et l'utilisation de plusieurs canaux RTT pour un transfert de données personnalisé plus avancé. Les avantages de RTT incluent la capacité de sortir printf via SWD sans utiliser de broches de microcontrôleur supplémentaires (par exemple, SWO), la compatibilité avec Cortex-M0/M0+, la facilité de configuration et une vitesse de fonctionnement très élevée par rapport à d'autres méthodes.
SystemView : Analyse approfondie des performances RTOS en temps réel
SystemView est un outil SEGGER puissant pour analyser et visualiser le fonctionnement des systèmes embarqués en temps réel, en utilisant RTT comme couche de transport. Il permet aux développeurs d'acquérir une compréhension plus profonde du comportement de FreeRTOS en suivant les changements de tâches, la gestion des interruptions et d'autres événements système. La configuration de SystemView est plus complexe que celle de RTT et implique plusieurs étapes clés :
- Inclure les fichiers source : Ajoutez les fichiers SystemView nécessaires à votre projet.
- Configuration de FreeRTOS : SystemView fonctionne en interceptant les macros de trace FreeRTOS, qui sont situées à des points clés du noyau (par exemple, lors de la création de tâches ou du changement de contexte). Pour activer ce mécanisme dans le fichier
FreeRTOSConfig.h, vous devez :
* Définir #define configUSE_TRACE_FACILITY 1.
* Pour FreeRTOS V10+, ajouter #define INCLUDE_xTaskGetIdleTaskHandle 1.
* À la toute fin du fichier FreeRTOSConfig.h, inclure SEGGER_SYSVIEW_FreeRTOS.h.
Exemple de macros de trace :
```c
#define traceTASK_SWITCHED_IN() SEGGER_SYSVIEW_OnTaskStartExec((U32)pxCurrentTCB)
#define traceTASK_SWITCHED_OUT() SEGGER_SYSVIEW_OnTaskStopExec()
#define traceISR_ENTER() SEGGER_SYSVIEW_RecordEnterISR()
// etc.
```
- Utilisation de DWT_CYCCNT pour un horodatage précis : Les cœurs Cortex-M3/M4 contiennent un module DWT (Data Watchpoint and Trace) intégré avec un compteur de cycles 32 bits (CYCCNT). SystemView l'utilise comme référence temporelle de haute précision. Dans la fonction
SEGGER_SYSVIEW_Conf(), vous devez activer ce compteur :
```c
void SEGGER_SYSVIEW_Conf(void) {
// ---- Configuration DWT (pour Cortex-M3/M4) ----
#define DEMCR ((volatile U32)0xE000EDFCu)
#define DWT_CTRL ((volatile U32)0xE0001000u)
#define DWT_CYCCNT ((volatile U32)0xE0001004u)
#define DEMCR_TRCENA (1u << 24)
#define DWT_CTRL_CYCCNTENA (1u << 0)
DEMCR |= DEMCR_TRCENA; // Activer l'accès à TRCENA
DWT_CYCCNT = 0; // Effacer le compteur
DWT_CTRL |= DWT_CTRL_CYCCNTENA; // Démarrer le comptage DWT
SEGGER_SYSVIEW_Init(SYSVIEW_TIMESTAMP_FREQ, SYSVIEW_CPU_FREQ,
&SYSVIEW_X_OS_TraceAPI, _cbSendSystemDesc);
SEGGER_SYSVIEW_SetRAMBase(SYSVIEW_RAM_BASE);
}
```
Assurez-vous également que la macro SYSVIEW_RAM_BASE correspond à l'adresse RAM de votre microcontrôleur.
- Gestion des routines de service d'interruption (ISR) : Contrairement aux changements de tâches, que SystemView intercepte via les macros FreeRTOS, les interruptions nécessitent des appels explicites. Vous devez ajouter les fonctions
SEGGER_SYSVIEW_RecordEnterISR()etSEGGER_SYSVIEW_RecordExitISR()à vos gestionnaires d'interruptions :
```c
void EINT15_10_IRQHandler()
{
SEGGER_SYSVIEW_RecordEnterISR();
if(EINT->IPEND & EINT_IPEND_11) {
// Votre code
}
SEGGER_SYSVIEW_RecordExitISR();
}
```
- Nommer les interruptions : Pour plus de clarté dans SystemView, vous devez informer l'outil des noms d'interruption en étendant la fonction
_cbSendSystemDesc()(trouvée dansSEGGER_SYSVIEW_Config_FreeRTOS.c) :
```c
static void _cbSendSystemDesc(void) {
SEGGER_SYSVIEW_SendSysDesc("N="SYSVIEW_APP_NAME",D="SYSVIEW_DEVICE_NAME",O=FreeRTOS");
SEGGER_SYSVIEW_SendSysDesc("I#15=SysTickIRQ");
SEGGER_SYSVIEW_SendSysDesc("I#46=ModbusIRQ");
//...
}
```
- Fonctions pour obtenir l'ID d'interruption et l'horodatage : Ajoutez deux fonctions requises pour le bon fonctionnement de SystemView dans
main(ou un autre emplacement pratique) :
```c
// Une fonction pour obtenir le numéro de l'interruption active actuelle (ISR)
U32 SEGGER_SYSVIEW_X_GetInterruptId(void) {
// Dans le cœur Cortex-M, le numéro d'interruption est stocké dans les 9 bits inférieurs du registre IPSR.
return (((volatile U32)(0xE000ED04u)) & 0x1FFu);
}
// Dans Cortex-M3/M4, nous utilisons le registre de compteur d'horloge de cœur DWT_CYCCNT
U32 SEGGER_SYSVIEW_X_GetTimestamp(void) {
return ((volatile U32)(0xE0001004u));
}
```
- Initialisation finale : Après avoir initialisé le matériel et les périphériques dans la fonction
main, appelezSEGGER_SYSVIEW_Conf(), puis démarrez l'ordonnanceur de tâchesvTaskStartScheduler():
```c
InitPhy();
SEGGER_SYSVIEW_Conf(); // Initialisation de Segger SystemView
CreateDeviceTasks();
vTaskStartScheduler(); // Démarrer l'ordonnanceur temps réel
```
Après une configuration réussie, l'utilitaire SystemView fournira une visualisation détaillée du comportement du système. L'un des avantages les plus précieux de SystemView est sa capacité à fonctionner même lorsque le microcontrôleur cible n'est pas en mode débogage. Cela permet une surveillance dans des conditions de fonctionnement réelles, en connectant J-Link au besoin pour le diagnostic, ce qui simplifie considérablement l'identification d'erreurs complexes et dépendantes du temps.
Intégration et sélection des outils : RTT Viewer vs. SystemView
SEGGER RTT Viewer et SystemView sont des outils complémentaires, chacun répondant à des tâches spécifiques dans le développement de logiciels embarqués. RTT Viewer est idéal pour la sortie de journaux textuels et d'informations de débogage, remplaçant le printf traditionnel tout en offrant des performances et une non-intrusivité significativement plus élevées. SystemView, à son tour, élève l'analyse à un nouveau niveau en fournissant une représentation graphique des événements FreeRTOS tels que les changements de contexte, l'exécution des tâches et la gestion des interruptions, ce qui est d'une importance capitale pour l'optimisation des performances et l'identification des problèmes d'ordonnancement.
Le choix entre SEGGER_RTT_printf et SEGGER_SYSVIEW_Print (s'il est utilisé pour les messages textuels dans SystemView) dépend du contexte : SEGGER_RTT_printf est destiné aux journaux généraux, tandis que les fonctions SystemView sont pour les événements qui doivent être intégrés dans la chronologie de l'analyse. Il est important de noter que SystemView utilise son propre canal RTT interne pour la transmission des données de trace, qui n'est généralement pas destiné à une interaction directe de l'utilisateur. Bien que SystemView puisse fonctionner sans RTOS, ses fonctionnalités seront sévèrement limitées, car bon nombre de ses capacités reposent sur les hooks du système d'exploitation.
L'utilisation de DWT_CYCCNT au lieu de SysTick pour les horodatages dans SystemView est due à plusieurs facteurs. DWT_CYCCNT est un compteur de cycles de processeur matériel dédié qui offre la plus haute précision possible et est indépendant des paramètres du timer système utilisés par le RTOS. Cela garantit que les horodatages dans SystemView sont aussi fiables que possible et ne sont pas sujets à des distorsions dues au fonctionnement propre du système d'exploitation.
D'autres outils pour le traçage et l'analyse de RTOS existent, tels que Tracealyzer de Percepio, qui offrent également des fonctionnalités riches pour la visualisation et l'analyse du comportement des systèmes embarqués. Cependant, SEGGER RTT et SystemView se distinguent par leur intégration profonde avec l'écosystème J-Link et leurs hautes performances, ce qui en fait des solutions privilégiées pour les développeurs travaillant avec des microcontrôleurs Cortex-M.
Ce qui est important :
- SEGGER RTT fournit une sortie rapide et non intrusive de journaux de débogage (
printf) via un tampon circulaire en RAM. - SystemView est un outil puissant pour la visualisation et l'analyse en temps réel de FreeRTOS, utilisant RTT comme transport.
- Pour une chronologie précise, SystemView s'appuie sur le compteur matériel DWT_CYCCNT (Cortex-M3/M4).
- Les deux outils simplifient considérablement le diagnostic de problèmes complexes en permettant la surveillance du système sans arrêter le CPU.
- SystemView permet l'analyse du comportement du système même en dehors du mode débogage, en connectant J-Link à la demande.
— Editorial Team
Aucun commentaire pour le moment.