Réaliser des projets intensifs en calcul avec le ShieldBuddy

De nombreux amateurs, makers et bricoleurs utilisent les cartes de développement de micro-ordinateurs Arduino pour surveiller et contrôler leurs projets. Il en va de même pour un nombre croissant d'ingénieurs professionnels qui peuvent utiliser ces cartes comme plateformes d'évaluation et de prototypage pour accélérer le développement et réduire les coûts associés à l'évaluation des circuits intégrés, des capteurs et des périphériques. Comme nous l'avons vu dans l'article Utiliser des cartes Breakout d'Arduino pour évaluer rapidement des capteurs et des périphériques, ces ingénieurs peuvent travailler en petites équipes avec des contraintes de délais de commercialisation plus strictes. À ce titre, ils doivent couvrir de multiples domaines et tâches d'ingénierie, tout en trouvant des moyens d'accélérer l'évaluation des composants et de réduire les coûts.

Une solution consiste à utiliser Arduino avec du matériel open-source sous la forme de cartes Breakout (BOB) de capteurs et de périphériques, en combinaison avec des logiciels open-source avec des bibliothèques et des programmes d'exemple associés. Bien qu'il existe une grande variété de cartes Arduino pour répondre à un large éventail d'exigences en matière de traitement et de mémoire, certains calculs sont néanmoins mieux effectués en utilisant une unité en virgule flottante (FPU) pour éviter de ralentir le processeur principal. Ce problème a été résolu dans l'écosystème Arduino par le ShieldBuddy.

Cet article décrit les différentes options de la plateforme de traitement Arduino et explique pourquoi les capacités d'une unité en virgule flottante sont si importantes pour de nombreuses applications. Il présente ensuite le ShieldBuddy, une carte qui conserve une empreinte physique similaire à celle des cartes Arduino, mais qui est équipée de trois cœurs de traitement 32 bits indépendants, chacun fonctionnant à 200 MHz et doté de sa propre unité FPU. L'article décrit son modèle de programmation et montre comment son environnement de programmation basé sur Eclipse et sa prise en charge de l'environnement de développement intégré (IDE) Arduino permettent aux bricoleurs et aux concepteurs de se lancer rapidement.

Arduino pour les débutants et les professionnels

Les nouveaux venus dans l'univers Arduino commencent généralement avec la carte Arduino Uno Rev3 (Figure 1), basée sur le microcontrôleur 8 bits ATmega328P s'exécutant à 16 mégahertz (MHz). Cette carte n'est dotée que de 32 kilo-octets (Ko) de mémoire (programme) Flash, 2 Ko de SRAM, 14 broches entrée/sortie (E/S) numériques et 6 broches d'entrée analogiques. Six des broches numériques peuvent fournir des sorties à modulation de largeur d'impulsion (PWM), et les broches analogiques peuvent également être utilisées comme broches E/S numériques, si nécessaire.

Figure 1 : La carte de développement Arduino Uno Rev3 est basée sur le microcontrôleur ATmega328P 8 bits fonctionnant à 16 MHz. (Source de l'image : Arduino.cc).

L'empreinte des embases de l'Arduino Uno Rev3, avec 14 broches entrée/sortie numériques, 6 broches d'entrée analogiques et diverses broches d'alimentation, de masse et de référence, est à la base d'un important écosystème de cartes filles appelées « shields ».

De nombreux utilisateurs de l'Uno Rev3 passent ensuite à la carte Arduino Mega 2560 Rev3 (Figure 2), qui est basée sur le microcontrôleur 8 bits ATmega2560 fonctionnant à 16 MHz. Cette carte est dotée de 256 Ko de mémoire Flash et de 8 Ko de SRAM. L'empreinte de ses embases lui permet de prendre en charge les mêmes shields que l'Uno, cependant, des embases supplémentaires lui permettent d'accueillir 54 broches E/S numériques et 16 broches d'entrée analogiques. Dans ce cas, 15 des broches numériques peuvent fournir des sorties PWM et, une fois de plus, les broches analogiques peuvent également être utilisées comme broches E/S numériques, si nécessaire.

Figure 2 : La carte de développement Arduino Mega 2560 Rev3 est basée sur le microcontrôleur 8 bits ATmega2560 fonctionnant à 16 MHz. L'empreinte de ses embases lui permet de supporter les mêmes shields que l'Arduino Uno, mais elle est également dotée d'embases supplémentaires, fournissant au total 54 broches E/S numériques et 16 broches d'entrée analogiques. (Source de l'image : Arduino)

En plus des limitations imposées par un chemin de données 8 bits et une horloge 16 MHz, ni les microcontrôleurs Arduino Uno ni les microcontrôleurs Arduino Mega ne sont équipés d'une unité FPU, ce qui signifie que tout calcul impliquant des valeurs en virgule flottante ralentit considérablement ces processeurs.

Pour les utilisateurs qui souhaitent une puissance de traitement encore plus élevée, l'étape suivante est la carte Arduino Due (Figure 3), qui a une empreinte physique similaire à celle de l'Arduino Mega, mais qui est basée sur le processeur Arm® Cortex®-M3 s'exécutant à 84 MHz SAM3X8E 32 bits d'Atmel/Microchip Technology. Cette carte offre 512 Ko de mémoire Flash, 96 Ko de SRAM, 54 broches E/S numériques, 12 broches d'entrée analogiques, et 2 broches de sortie analogiques qui sont commandées par des convertisseurs numérique-analogique (CNA). Dans ce cas, seules 12 des broches numériques peuvent fournir des sorties PWM et, une fois encore, les broches analogiques peuvent également être utilisées comme broches E/S numériques si nécessaire. Malheureusement, tout comme pour les cartes Arduino Uno et Mega, le processeur de l'Arduino Due n'inclut pas d'unité FPU.

Figure 3 : La carte de développement Arduino Due est basée sur le processeur Arm Cortex-M3 32 bits Atmel SAM3X8E fonctionnant à 84 MHz. L'empreinte de ses embases est identique à celle de l'Arduino Mega. (Source de l'image : Arduino.cc)

De nombreux utilisateurs — amateurs et professionnels — apprécient le nombre de broches élevé des cartes de développement Arduino Mega et Arduino Due. Mais, même le processeur 32 bits de l'Arduino Due fonctionnant à 84 MHz peut être insuffisant pour certaines tâches de calcul intensives. De même, les 512 Ko de mémoire Flash et les 96 Ko de SRAM de la carte Due peuvent être insuffisants pour des programmes plus importants travaillant avec de grandes quantités de données.

Si les microcontrôleurs sont capables de traiter des quantités de données de plus en plus importantes, certains calculs sont mieux effectués en utilisant des unités FPU pour un meilleur rendement et une latence plus faible.

Présentation et utilité des unités en virgule flottante

L'utilité des unités FPU tient à la manière dont les ordinateurs gèrent les chiffres. La façon la plus simple de représenter les nombres dans les ordinateurs est d'utiliser des nombres entiers. De plus, il est pratique de faire des calculs en utilisant des nombres entiers. Cependant, les nombres entiers sont par nature finis et ne peuvent pas exprimer une large plage dynamique.

Cela pose un problème aux ingénieurs et aux scientifiques car ils doivent souvent utiliser des valeurs extrêmement grandes et petites dans un même calcul. Par exemple, les physiciens peuvent avoir des calculs qui utilisent les valeurs numériques de la vitesse de la lumière (300 000 000) et de la constante de gravitation de Newton (0,00000000006674). De même, les ingénieurs ont besoin de valeurs avec une large plage dynamique pour des tâches telles que le traitement des signaux numériques (DSP) et pour une utilisation dans les applications d'intelligence artificielle (IA) et d'apprentissage automatique (ML).

La solution consiste à utiliser une représentation numérique en virgule flottante, où la virgule peut « flotter » par rapport à chaque chiffre individuel du nombre, ce qui permet d'obtenir un degré plus fin de résolution numérique. Le problème est que, bien qu'une valeur en virgule flottante de 32 bits consomme la même quantité de mémoire qu'un nombre entier de 32 bits en virgule fixe, effectuer des calculs en utilisant des valeurs en virgule flottante requiert beaucoup plus de ressources de calcul.

Si le processeur est obligé d'effectuer des calculs en virgule flottante en utilisant du matériel en virgule fixe standard, cela aura un impact considérable sur les performances de ce processeur. La solution consiste à équiper le processeur d'une unité FPU spéciale. Cela permet d'exécuter des opérations sophistiquées en virgule flottante en utilisant très peu de cycles d'horloge.

C'est là que le ShieldBuddy entre en jeu.

ShieldBuddy apporte des unités FPU et de hautes performances à l'écosystème Arduino

Acteur relativement nouveau dans l'espace compatible Arduino, le KITAURIXTC275ARDSBTOBO1 ou ShieldBuddy d'Infineon Technologies (Figure 4) est une carte d'évaluation embarquée pour le microcontrôleur 32 bits TC275T64F200WDCKXUMA1 TC275 AURIX TC2xx TriCore d'Infineon.

Figure 4 : Le ShieldBuddy TC275 est équipé du processeur multicœur 32 bits TC275 d'Infineon sur une carte de même empreinte que l'Arduino Mega et l'Arduino Due, ce qui le rend compatible avec de nombreux shields d'application disponibles. (Source de l'image : Hitex.com)

Maintenant une empreinte physique similaire à celle de l'Arduino Mega et de l'Arduino Due, le ShieldBuddy est compatible avec de nombreux shields d'application, mais il se distingue par son utilisation du TC275 avec ses trois cœurs 32 bits indépendants, chacun fonctionnant à 200 MHz et doté de sa propre unité FPU. De plus, le ShieldBuddy est doté de 4 méga-octets (Mo) de mémoire Flash (8 fois celle de l'Arduino Due et 16 fois celle de l'Arduino Mega) et de 500 Ko de RAM (5 fois celle de l'Arduino Due et 62 fois celle de l'Arduino Mega).

On peut considérer que le cœur de l'Arduino Mega ne gère qu'environ seize instructions 8 bits par microseconde (µs). En comparaison, chacun des cœurs du TC275 a un temps de cycle de 5 nanosecondes (ns), ce qui signifie que chaque cœur peut typiquement exécuter environ 150 à 200 instructions de 32 bits/µs. Comme chacun des cœurs de processeur du ShieldBuddy est doté de sa propre unité FPU, la carte peut effectuer des calculs en virgule flottante avec peu ou pas de dégradation des performances.

Développer avec le ShieldBuddy

Lorsqu'ils travaillent avec le ShieldBuddy, les développeurs de logiciels professionnels peuvent vouloir utiliser un IDE Eclipse, tandis que les amateurs et les makers peuvent préférer l'IDE Arduino, qui leur est familier. Les deux options sont prises en charge.

Les utilisateurs Arduino savent que chaque sketch (programme) doit avoir deux fonctions standard : setup(), qui est exécuté une seule fois, et loop(), qui est exécuté en boucle. Les utilisateurs peuvent également créer leurs propres fonctions.

Les trois cœurs du ShieldBuddy sont appelés cœur 0, cœur 1 et cœur 2. Dans le cas de l'IDE Arduino, la plupart des programmes existants peuvent être compilés pour être utilisés sur le ShieldBuddy sans modification. Par défaut, les fonctions setup() et loop(), ainsi que toutes les fonctions créées par l'utilisateur qu'elles appellent, seront compilées pour fonctionner sur le cœur 0.

Lors de la création d'un nouveau programme, l'utilisateur peut obtenir le même effet en nommant ces fonctions setup0() et loop0(). L'utilisateur peut également créer des fonctions setup1() et loop1(), qui, avec toutes les fonctions créées par l'utilisateur qu'elles appellent, seront automatiquement compilées pour fonctionner sur le cœur 1. De même, les fonctions setup2() et loop2(), ainsi que toutes les fonctions qu'elles appellent, seront automatiquement compilées pour fonctionner sur le cœur 2.

Par défaut, chaque cœur fonctionne de manière indépendante, ce qui signifie qu'il est possible d'avoir trois programmes totalement séparés fonctionnant simultanément sur le ShieldBuddy. Cela dit, les cœurs peuvent également communiquer entre eux en utilisant des techniques comme la mémoire partagée. De plus, chaque cœur peut déclencher des interruptions logicielles dans les autres cœurs.

Conclusion

Le concept open-source Arduino s'est révélé être un énorme succès, et les écosystèmes matériels et logiciels qui en découlent se sont développés pour englober des centaines de shields et des milliers de bibliothèques et d'applications.

Bien que les premières cartes de développement Arduino, comme l'Arduino Mega et l'Arduino Uno 8 bits, 16 MHz, aient été quelque peu limitées, les implémentations plus récentes comme l'Arduino Due 32 bits, 84 MHz sont nettement plus puissantes. Malgré cela, de nombreux utilisateurs ont besoin de plus d'espace programme (Flash), de plus d'espace de données (SRAM) et de plus de puissance de traitement que tout ce qu'Arduino traditionnel peut offrir.

Avec 4 Mo de mémoire Flash, 500 Ko de SRAM et trois cœurs de processeur 32 bits indépendants fonctionnant à 200 MHz, chacun avec sa propre unité FPU, le ShieldBuddy élève le concept Arduino à un tout nouveau niveau, ce qui le rend intéressant pour les bricoleurs de l'extrême et les ingénieurs professionnels.

Lectures recommandées :

1. Enseigner l'électronique aux grands débutants
2. Appliquer rapidement et facilement les FPGA avec l'Arduino MKR Vidor 4000
3. Intégrer le monde des makers grâce au kit de démarrage convivial Arduino