Optimisation du code C pour les dispositifs embarqués à commande électrique

Sur les appareils Cortex-M4F avec un FPU matériel, les flotteurs à simple précision sont rapides, mais la double précision est encore émulée dans le logiciel. Sur les carottes M0/M0+, tous les points flottants sont émulés et doivent être évités. Utilisez plutôt des entiers arithmétiques à points fixes ou à échelles. Une approche commune consiste à représenter une gamme de valeurs en entiers avec un facteur d'échelle connu, en appliquant des changements après multiplication pour maintenir la précision.

Optimisation de la boucle et prévision de la branche

Les boucles sont une source importante de consommation d'énergie parce que le processeur reste actif, récupère des instructions et évalue les conditions. Les techniques pour minimiser les frais généraux de boucle comprennent :

• Déroulement de boucle – manuellement ou avec des conseils de compilateur ([) pour réduire le nombre d'itérations et les instructions de branche. Déroulement par un facteur de 4 ou 8 donne souvent les meilleurs résultats.
• Loops de compte à rebours – typique génère moins d'instructions que de compter, car le zéro-vérification est libre sur de nombreuses architectures (par exemple, ARM définit des drapeaux).
• Ligne de pipe – réordonnée des itérations de boucle pour cacher la latence de mémoire et garder le pipeline plein.
• Éviter les appels de fonction dans les boucles – les petites fonctions en ligne manuellement ou avec mot clé pour éliminer les appels/retours en tête.

Une boucle bien optimisée peut passer jusqu'à 70% de moins de temps dans le domaine actif qu'une implémentation naïve, traduisant directement en énergie inférieure.

Modèles d'accès à la mémoire

Les lectures de mémoire Flash consomment plus de puissance que les accès SRAM, et les interfaces de mémoire externe sont encore plus coûteuses. Organisez les données pour maximiser les accès cache (si un cache existe) ou pour minimiser les états d'attente. Utilisez const[ et static const[ pour les tables de recherche afin qu'elles résident en flash, mais accédez-les séquentiellement pour éviter les décrochages d'accès aléatoires. Placez fréquemment des variables modifiées dans SRAM et les groupez en une structure pour améliorer la localisation.

Les accès Bit-field peuvent être coûteux car le compilateur doit générer des séquences read-modify-write. Lorsque plusieurs drapeaux partagent un octet, envisager d'utiliser un uint8 t et des opérations bitwise directes; le résultat est souvent plus petit et plus rapide qu'un champ C bit.

Au lieu d'avoir le CPU copie des données octet-byte (par exemple, de UART à RAM), configurer un canal DMA pour effectuer le transfert pendant que le CPU entre dans un état de faible puissance. De nombreux microcontrôleurs prennent en charge le DMA depuis le périphérique vers la mémoire et de la mémoire vers la mémoire. Le CPU n'est réveillé que lorsque le transfert se termine.

Interruptions vs sondage

Le sondage d'un drapeau dans une boucle occupée maintient le processeur actif et consommant de la puissance. Les E/S entraînés par interruption permettent au processeur de dormir ou d'effectuer d'autres travaux jusqu'à ce qu'un événement se produise. Pour les tâches périodiques, utilisez des minuteurs matériels au lieu de retards logiciels. Par exemple, plutôt qu'une boucle qui compte à 1.000.000, définissez un minuteur pour générer une interruption après l'intervalle désiré et mettez le processeur en mode veille.

Un point subtil : chaque interruption entraîne un contexte d'économie/restaurer les frais généraux. Si les interruptions se produisent à des taux très élevés (p. ex., toutes les 10 μs), les frais généraux peuvent consommer plus de puissance qu'une simple approche de sondage.

Éviter l'allocation de mémoire dynamique

En utilisant malloc[ et [free[ dans le firmware intégré, non seulement introduit un calendrier imprévisible et une fragmentation, mais consomme également de l'énergie pour la gestion du tas. Préférez les tampons et les allocataires de piscine alloués statiquement. Si l'attribution dynamique est inévitable, utilisez un pool à blocs fixes qui ne échoue jamais et qui a une complexité O(1).

Caractéristiques du matériel de levier

La plupart des microcontrôleurs modernes incluent des fonctionnalités spécifiquement conçues pour réduire la puissance. L'écriture C code qui contrôle correctement ces fonctionnalités est essentielle.

Modes à faible puissance et sources de réveil

Les fournisseurs de MCU offrent plusieurs modes de sommeil : le ralenti, le sommeil, le sommeil profond et l'hibernation. En C, ceux-ci sont généralement entrés en exécutant une instruction WFI (Wait For Interrupt) ou WFE (Wait For Event). Le développeur doit configurer les sources de réveil (p. ex. GPIO, minuteur, RTC) et sélectionner le mode de puissance approprié.

HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);

Lorsque vous utilisez plusieurs sources de réveil, assurez-vous que le système peut reprendre rapidement et de nouveau s'endormir après avoir servi l'événement. Un modèle commun est la "super boucle" avec un sommeil au bas:

while (1) {
 uint32_t next_event_time = schedule_next_event();
 enter_sleep_until(next_event_time);
 process_event();
}

Pause de l'horloge et étalonnage de tension

En C, cela se fait en écrivant pour activer les registres (p. ex. RCC->AHBENR sur STM32). Après initialisation d'un périphérique, désactiver son horloge jusqu'à ce que nécessaire. Certains appareils avancés supportent la tension dynamique et l'échelle de fréquence (DVFS). Réduire l'horloge du CPU de 48 MHz à 24 MHz peut couper la puissance active de près de 50%, mais peut prolonger la durée de la tâche. La clé est de fonctionner à la fréquence la plus basse qui respecte toujours les délais en temps réel, et d'entrer dans le sommeil immédiatement lorsque le ralenti.

Par exemple, sur un NXP LPC55S6x, vous pouvez changer l'horloge du noyau avec :

CLOCK_SetFreq(kCLOCK_Core, 24000000U);

Et ensuite revenir à 96 MHz pour des rafales de calcul intensif. Cette stratégie de « course au sommeil » est très efficace lorsqu'elle est combinée avec des états de sommeil profond.

Utilisation des périphériques sur le circuit pour le déchargement

Certains périphériques peuvent fonctionner de manière autonome depuis le CPU. Un comparateur analogique peut déclencher une interruption lorsqu'un seuil est franchi, éliminant ainsi les sondages continus. Un minuteur matériel peut générer des signaux PWM sans intervention du CPU. Un système d'événements (comme dans les périphériques Microchip AVR, Silicon Labs ou TI) peut enchaîner les périphériques directement.

Étude de cas: Un Blinker LED optimisé par puissance

L'exemple classique clignote est un bon point de départ pour illustrer l'impact de l'optimisation. Considérez un système qui fonctionne à partir de deux piles AA, avec une durée de vie cible d'un an. L'appareil écrase une LED pendant 100 ms toutes les deux secondes.

Naive implementation (polling delay):

while (1) {
 toggle_led();
 delay_loop(1000000); // busy-wait ~100 ms
 toggle_led();
 delay_loop(19000000); // busy-wait ~1900 ms
}

Ici, le CPU est actif à 100% du temps, gaspillant l'énergie en attente. Tirage courant ~5 mA, énergie moyenne ~1080 mAh/an (en supposant 3.0 V).

Implémentation de sommeil de faible puissance:

void SysTick_Handler(void) {
 static uint32_t ticks = 0;
 ticks++;
 if (ticks == 2000) {
 toggle_led();
 ticks = 0;
 }
}
int main() {
 init_systick(1); // 1 ms tick
 while (1) {
 __WFI(); // sleep until SysTick interrupt
 }
}

Maintenant le CPU dort pendant la plupart des 2 secondes période, seulement réveil pour l'interruption de 1 ms SysTick et la bascule LED. Courant moyen tombe à ~0,5 mA (y compris les fuites), donnant ~120 mAh/an—une amélioration 9x.