Blog
Comment utiliser un ESP32 double cœur avec l'IDE Arduino
La plupart des projets utilisant des microcontrôleurs commencent de manière très basique, en lisant des capteurs, en allumant et éteignant des LED, ou en transmettant des données en série. Cependant, avec l'augmentation de la taille des projets, des activités dites "overhead" telles que les communications sans fil, la détection en temps réel, les interfaces utilisateur et le traitement des données commencent à concurrencer le temps du processeur. C'est là que l'architecture double cœur de l'ESP32 constitue un avantage considérable.
L'ESP32 dispose de deux cœurs de traitement indépendants (par rapport aux microcontrôleurs courants à cœur unique), permettant l'exécution simultanée de deux tâches. Cela devrait permettre aux développeurs de créer des systèmes plus réactifs, stables et évolutifs sans avoir à changer d'environnement de développement, lorsqu'il est correctement utilisé dans la configuration Arduino.
Cet article traite du double cœur ESP32 sous l'IDE Arduino, en accordant une attention particulière aux perspectives pratiques, aux plans de mise en œuvre concrets et aux écueils, sans transformer le sujet en un manuel de code de bas niveau RTOS.
Comprendre l'architecture double cœur de l'ESP32
Le processeur ESP32 dispose de deux cœurs processeur Tensilica indépendants, mais partageables en mémoire et en périphériques. Le système possède une gestion interne du multitâche, de l'ordonnancement et de la coordination inter-cœurs à l'aide de FreeRTOS.
Dans la plupart des configurations de l'ESP32 :
- Le cœur 0 gère principalement les opérations de niveau système telles que le Wi-Fi, le Bluetooth et les services en arrière-plan.
- Le cœur 1 est généralement utilisé pour la logique applicative utilisateur.
Avec le framework Arduino appliqué à l'ESP32, une grande partie de cette complexité est supprimée. Les fonctions standard `setup` et `loop` sont déjà utilisées dans le cadre des tâches FreeRTOS. Néanmoins, les développeurs peuvent ajouter des tâches supplémentaires et les attacher à un cœur particulier lorsqu'il est nécessaire d'avoir un contrôle de réglage fin.
Quand utiliser le double cœur (et quand ne pas l'utiliser)
Le traitement dual core est puissant, mais il n'est pas toujours nécessaire. Comprendre quand l'utiliser permet d'éviter une complexité inutile.
Les cas d'utilisation appropriés incluent :
- Exécuter l'acquisition des capteurs indépendamment de la communication Wi-Fi
- Gérer le contrôle en temps réel tout en mettant à jour un affichage
- Séparation des tâches critiques en temps réel de la journalisation d'arrière-plan
- Améliorer la réactivité dans les applications IoT
Cas où un double cœur peut ne pas être nécessaire :
- Projets simples de lecture de capteurs
- Enregistrement de données à basse fréquence
- Applications avec des contraintes de temporisation minimales
L'utilisation d'un double cœur devrait être une décision de conception, et non un choix par défaut. Une utilisation excessive de celui-ci peut introduire des problèmes de synchronisation qui n'existent pas dans les conceptions à boucle unique.
Configuration du double cœur ESP32 dans l'IDE Arduino
Tout d'abord, il faut installer le package "ESP32 board" dans l'environnement Arduino. L'ESP32 est compatible avec Arduino car l'utilisateur peut l'utiliser d'une manière similaire à une carte Arduino.
L'IDE Arduino est un programme exécuté automatiquement dans l'ESP32 avec le système FreeRTOS. Le support dual-core ne nécessite aucune configuration spéciale pour être activé.
Les considérations importantes relatives à la configuration comprennent :
- Sélectionner la variante de carte ESP32 appropriée
- Utiliser les paramètres par défaut de flash et de partition, sauf si une utilisation avancée de la mémoire est requise
- Activation de la sortie série pour le débogage précoce
À ce stade, le système est déjà capable de multitâche, même si le croquis semble simple.
Tâches, Cœurs et la Boucle Arduino
Dans le sketch Arduino classique, toute la logique est exécutée dans loop (). Et sur l'ESP32, loop est en soi une tâche FreeRTOS liée à un cœur.
Afin d'exploiter pleinement la capacité bicœur, les développeurs élaborent davantage de tâches qui :
- Exécuter indépendamment de loop()
- Peut être assigné au Cœur 0 ou au Cœur 1
- Opérer à différentes priorités
Il existe une pile et un contexte d'exécution pour chaque tâche, et il est possible de les utiliser de manière réellement parallèle. Il est désormais possible d'exécuter des lectures de capteurs en continu pendant que les communications ou les mises à jour de l'interface utilisateur s'exécutent sans blocage.
Implémentation étape par étape d'une tâche double cœur (exemple de bricolage)
À titre d'exemple de pratique concrète, on peut utiliser un projet DIY basé sur l'ESP32 qui permet de lire des capteurs et de transmettre des données via le réseau Wi-Fi.
Définition des tâches indépendantes
L'application est divisée en responsabilités logiques :
- Tâche A : Lit les données des capteurs à intervalles fixes
- Tâche B : Gère la communication Wi-Fi et la transmission de données
Cet isolement empêche les opérations réseau lentes d'interrompre la détection sensible au temps.
Assignation de tâches à des cœurs spécifiques
La lecture du capteur est normalement placée sur le Cœur 1, tandis que la communication peut être placée sur le Cœur 0 ou le Cœur 1 en fonction de la charge du système. La sélection de la taille de la pile et de la priorité est effectuée pour éviter les plantages ou la famine.
Une telle stratégie rend le système réactif même en présence d'un trafic de communication important.
Gestion des ressources partagées entre les cœurs
La capacité d'utiliser des ressources partagées en toute sécurité est l'un des éléments les plus cruciaux en programmation dual-core. Comme les deux cœurs sont autorisés à accéder à la mémoire, une conception irresponsable peut entraîner un comportement imprévisible.
Les considérations clés incluent :
- Protection des variables partagées
- Éviter l'accès simultané aux périphériques matériels
- Gestion de la sortie série pour prévenir la corruption des messages
Les conditions de concurrence peuvent être supprimées et la cohérence des données garantie sans surcharge excessive grâce à de simples méthodes de synchronisation.
Problèmes courants avec les processeurs Dual Core et conseils de débogage
Les développeurs débutant sur des projets ESP32 dual-core rencontrent souvent des problèmes similaires :
- Réinitialisations aléatoires dues à une taille de pile insuffisante
- Le chien de garde se déclenche en raison d'un code bloquant
- Tâches aux priorités incorrectes affamant les autres
- Instabilité de puissance pendant la transmission Wi-Fi
Ces problèmes sont isolés à l'aide d'un débogage systématique. La journalisation série, l'isolation des tâches et les tests incrémentaux peuvent particulièrement être fructueux avec plusieurs cœurs.
Bonnes pratiques d'optimisation des performances
Pour tirer le meilleur parti du double cœur de l'ESP32 :
- Attribuer les tâches critiques en temps à leur propre cœur.
- Éviter les longs retards bloquants
- Utilisez le multitâche plutôt que les interruptions lorsque cela est approprié.
- Surveiller la consommation d'énergie sous charge
L'utilisation du double cœur devrait également améliorer la réactivité, plutôt que d'ajouter seulement de la complexité.
Stratégie de tests et de validation
Les systèmes bi-cœurs doivent être testés au-delà de la fonctionnalité de base. La validation comprend :
- Tests d'exécution de longue durée
- Tests de stress avec trafic Wi-Fi continu
- Mesure de la précision temporelle des capteurs
- Vérification de la récupération du système après des interruptions réseau
Ces tests confirment que les tâches restent stables et synchronisées dans le temps.
Considérations lors de la transition vers la conception de circuits imprimés
Dans le cas d'un projet ESP32 dual-core migrant vers un PCB, la conception matérielle est directement influencée par les décisions du micrologiciel. Le multitâche doit être pris en compte en termes d'allocation des GPIO, de routage de l'alimentation et d'accès au débogage.
Les considérations importantes relatives aux circuits imprimés (PCB) comprennent :
- Conception d'une alimentation stable
- Découplage adéquat près de l'ESP32
- Points de test pour le débogage
- Séparation nette des signaux sensibles
Les applications double cœur sont plus susceptibles d'être exigeantes en matière d'intégrité de l'alimentation, et par conséquent, la qualité du circuit imprimé est très significative pour elles.
Pensées finales
L'utilisation réussie du double cœur ESP32 s'effectue dans l'environnement Arduino, ce qui permet aux développeurs de créer des systèmes embarqués plus fiables, réactifs et évolutifs. Grâce à la connaissance de l'allocation des tâches aux cœurs, les ressources partagées peuvent être utilisées efficacement, et des tests approfondis peuvent garantir que le traitement à double cœur n'est pas un outil complexe.
Le double cœur de l'ESP32, disponible pour les utilisateurs d'Arduino désireux de s'éloigner des conceptions à boucle unique pour des conceptions plus puissantes et plus performantes, constitue une étape logique avec une organisation logicielle appropriée et de bonnes pratiques de conception de circuits imprimés.
Foire Aux Questions (FAQ)
Oui. La boucle Arduino s'exécute déjà en tant que tâche FreeRTOS, ce qui permet le multitâche sur un seul cœur. Le double cœur permet simplement une meilleure isolation des tâches critiques en temps réel et des tâches de fond.
Utilisez la fonction xTaskCreatePinnedToCore(). Elle vous permet d'épingler une tâche FreeRTOS au Cœur 0 ou au Cœur 1, contrôlant ainsi la localité d'exécution et évitant les conflits inutiles.
Légèrement. L'exécution concurrente des tâches peut consommer plus d'énergie, mais une conception soignée avec des modes de veille, des boucles efficaces et la priorisation des tâches permet de maintenir la consommation à un niveau gérable.
Utiliser la journalisation série, les mutex et les notifications de tâche pour suivre l'exécution des tâches. Éviter les conflits de ressources partagées, et tester une tâche à la fois avant de les combiner.
Certaines bibliothèques comportant des opérations bloquantes ou un accès matériel direct peuvent entraîner des conditions de concurrence. Vérifiez toujours la documentation de la bibliothèque et envisagez d'encapsuler l'accès dans des tâches protégées par des mutex.
Le cœur 0 gère généralement les services système tels que le Wi-Fi et le Bluetooth. L'exécution des tâches utilisateur sur le cœur 1 permet d'éviter les interruptions et assure une communication sans fil stable, même en cas de forte charge.
Paul R est un ingénieur en mécatronique spécialisé en électronique, conception de circuits imprimés (PCB) et systèmes embarqués. Il possède une expérience avec KiCad, Altium Designer, EasyEDA et Eagle, ainsi que des connaissances pratiques en programmation Arduino, prototypage IoT et intégration matériel-logiciel.
