Dans la première partie de cette série d'articles, nous avons abordé comment entraîner un réseau de neurones convolutifs (CNN) afin de reconnaître des mots-clés exprimés vocalement, sur un PC doté de Linux. Le résultat obtenu comporte plusieurs fichiers qui contiennent le CNN et ses fonctions. Dans cet article, nous allons commencer à développer avec le SDK Maxim Micro et à mettre en œuvre le code pour commander notre démo de machine à café. Pour vous permettre de démarrer en douceur avec le MAX78000, nous allons montrer non seulement comment le code a été créé et fonctionne, mais aussi comment configurer l'IDE ainsi que quelques astuces pour vos propres projets.

Le SDK Maxim Micro est basé sur l'IDE Eclipse, environnement de développement intégré bien connu et largement répandu. De nombreux fournisseurs utilisent cet IDE. En raison de sa personnalisation, il peut bénéficier de modules complémentaires et de présentations d'interfaces extrêmement personnalisées. Maxim utilise une version non modifiée de l'IDE Eclipse, avec seulement quelques ajouts, pour que votre projet à base de microcontrôleur offre un peu plus de confort. La maintenance en est facilitée et donne à l'utilisateur la possibilité de personnaliser l'IDE, s'il le souhaite.

À ce stade, le SDK Maxim Micro ne prend en charge que Windows. Nous nous en tiendrons donc à Windows 10 pour ce projet. De plus, le chemin par défaut pour l'installation du SDK (figure 1) reste inchangé, car les caractères vides ou les autres caractères spéciaux et les chemins Windows peuvent poser des problèmes.
 

Figure 1 : Chemin d'accès par défaut.

Une fois l'installateur téléchargé depuis le site web de Maxim, l'installation peut être exécutée et un assistant s'affiche. Si vous choisissez les options d'installation (voir la figure 2), sélectionnez seulement le MAX78000 comme dispositif de microcontrôleur pris en charge. La taille de l'installation sera réduite et copiera moins de fichiers superflus sur le disque. L'installation peut prendre un certain temps et nécessite une connexion Internet active pour télécharger les dépendances supplémentaires.

Figure 2 : Sélectionnez le MAX78000 comme seul microcontrôleur pris en charge.

Une fois l'installation terminée, il est possible de lancer le SDK Maxim Micro. Pour cela, il suffit de parcourir votre menu de démarrage, de chercher Maxim Integrated SDK et de choisir Eclipse MaximSDK (figure 3).

Figure 3 : Lancez l'accès au menu.

L'IDE Eclipse, comme indiqué dans la figure 4, s'affiche.

Figure 4 : IDE Eclipse au premier démarrage.

 

En cours de construction

Le MAX78000 est un nouveau microcontrôleur Maxim. Le matériel est assemblé et expédié, mais l'entreprise continue à améliorer et à mettre à jour la documentation. Visitez la page GitHub du MAX78000 pour obtenir les derniers documents et logiciels, mais aussi pour signaler tout problème que vous rencontrez. Ceci n'est pas seulement vrai pour la documentation mais aussi pour le code impliqué dans le SDK lui-même. Cela s'applique également au manuel de l'utilisateur MAX78000 ; tous les chapitres ne sont pas finalisés. La section RISC-V, par exemple, est toujours en cours de rédaction. Ainsi, vous pouvez vous attendre à ce que d'autres éléments soient ajoutés dans le futur pour approfondir cette partie. Considérez les documents et le SDK comme une évolution vers la version 1.0, car ils seront améliorés avec le temps. S'il vous manque encore des informations, pensez à demander de l'aide à Maxim ou plongez un peu plus profondément dans le code.

Un nouveau projet, des Makefiles et quelques astuces

Nous allons commencer par un nouveau projet HelloWorld pour présenter les bases ainsi que certains éléments cachés du SDK Maxim. Ce n'est pas un secret que les Makefiles ne font pas l'unanimité. Selon vos pratiques précédentes, la plupart des outils automatiseront la génération du code pour vous. Il s'agit également de la vérification automatique des dépendances et de la génération de Makefiles. Ces outils utilisent aussi d'autres systèmes comme Cmake ou SCons pour produire des exécutables. Comme nous aurons des projets basés sur Makefile, un certain nombre de conseils seront donnés pour que les projets démarrent plus confortablement.

Pour commencer un nouveau projet, ouvrez Eclipse MaximSDK, si ce n'est pas déjà fait. La page de bienvenue s'affiche (figure 5).

Figure 5 : Eclipse avec l'assistant de projet Maxim.

Pour démarrer un nouveau projet, nous utilisons l'assistant fourni, comme le montre la figure 6.

Figure 6 : Paramètres de l'assistant pour le nom du projet.

Pour le projet, choisissez un nom et dans la boîte de dialogue suivante, utilisez les mêmes paramètres que ceux de la figure 7.

Figure 7 : Paramètres du projet.

L'exemple de projet HelloWorld est ainsi copié dans notre propre espace de travail. Si vous avancez dans la liste sans les projets et les échantillons pour l'accélérateur d'IA, nous y reviendrons plus tard. À ce stade, nous apprenons à connaître un peu mieux la puce et son environnement de développement.

Si tout se passe comme prévu, vous verrez apparaître un nouveau projet (figure 8).

Figure 8 : Projet Hello World.

Il s'agit d'un projet HelloWorld de base que je vais utiliser pour expliquer la démarche. Tout d'abord, si vous regardez le code, vous verrez que de nombreux includes et fonctions ne sont pas résolus. Il s'agit pour le moment d'une limitation de la configuration du SDK en conjonction avec l'IDE Eclipse. Maxim conseille de consulter la section « troubleshooting unresolved symbols » (résolution des problèmes de symboles non reconnus) pour trouver une solution. Ceci étant, cette difficulté ne se pose que si vous aimez naviguer dans le code à l'aide d'Eclipse. Si vous compilez le code, vous obtiendrez un exécutable qui pourra être flashé sur le MAX78000. Pour ce faire, utilisez la petite icône en forme de marteau (figure 9) pour lancer la compilation.

Figure 9 : Actionnez l'icône en forme de marteau pour compiler.

Dans les fenêtres inférieures, vous verrez défiler quelques lignes produites sur une console sans produire aucune erreur. Votre premier exécutable HelloWorld est prêt et toutes les instructions pour le construire sont contrôlées par les Makefiles. Nous allons maintenant nous intéresser aux projets.

C et Makefile

Le Makefile - fort opportunément baptisé makefile - se trouve dans le dossier racine de votre projet. À ce stade, vous voyez un fichier main.c qui sera utilisé pour compiler du code C pour le cœur Cortex-M4 du microcontrôleur. Si nous utilisons du code C pur, parfait, mais que faire si vous avez l'intention d'écrire en C++ ? Il suffit dans ce cas de renommer le fichier main.c en main.cpp pour que le code soit traité comme du code C++. Si vous appuyez maintenant sur le bouton compile, vous verrez que l'exécutable Hello World n'est pas compilé. Le Makefile définit également le type de carte d'évaluation utilisé. Par défaut, le système suppose que vous utilisez la MAX78000EVKIT. Comme nous allons utiliser une carte MAX78000FTHR_RevA, nous devons transformer, dans le Makefile, la ligne 54 BOARD=EvKit_V1 en commentaire, et le signe # de la ligne BOARD=FTHR_RevA doit être supprimé.

Comme Eclipse et les outils utilisés dans les Makefiles reconnaissent le code compilé dans le dossier d'assemblage, une nouvelle compilation ne sera pas lancée, car elle n'est pas nécessaire. À ce stade, nous pouvons tout nettoyer manuellement en quelques clics de souris comme le montre la figure 10.
 

Figure 10 : Entrée de menu pour nettoyer un projet.

Choisissez Clean et une fenêtre d'assistant apparaît. Comme nous n'avons qu'un seul projet, choisissez de les nettoyer tous (Clean all projects), comme le montre la figure 11. Vous ferez ainsi place nette pour votre projet et vous pourrez définir le build ultérieurement.

Figure 11 : Assistant pour nettoyer les projets.

À ce stade, si nous compilons le fichier main.cpp renommé, l'éditeur de liens produira des erreurs indiquant que certains symboles et fonctions ne peuvent être résolus. Ceci tient à la méthode appliquée par les compilateurs C et C++ pour produire leur code. Comme main.c est devenu main.cpp, c'est le compilateur g++ qui est appelé. Il s'agit d'un compilateur C++, mais il comprend le code et la syntaxe du langage C. Certaines parties du SDK sont toujours en C pur et seront compilées par le compilateur gcc. L'éditeur de liens doit maintenant mélanger les codes C++ et C compilés pour fabriquer un exécutable.

Pour obtenir du code C++ qui peut être lié au code C, nous devons déclarer certains points extern "C" pour obtenir un code transformable en exécutable par le compilateur. La figure 12 indique comment le faire.
 

Figure 12 : Le projet C++ peut nécessiter une déclaration extern "C".

En général, cela se fait dans les fichiers d'en-tête inclus, si possible. Une demande de mise à jour du SDK est déjà faite sur GitHub et sera traitée par Maxim. Si certaines parties vous semblent nécessiter des améliorations, je vous encourage à utiliser GitHub et le gestionnaire de problèmes. Qu'il s'agisse d'une indication ou d'une demande, n'hésitez pas à décrire votre problème sur cette page. Votre contribution conduira peut-être à des changements ou des améliorations utiles. De plus, les autres utilisateurs du SDK bénéficieront de vos commentaires.

Modifier les dossiers et le Makefile

À ce stade, si nous ajoutons le code au projet, vous allez constater qu'il n'est pas compilé. C'est le Makefile qui est en cause. Comme le montre la figure 13, chaque fichier doit être ajouté à la ligne SCRS.
 

Figure 13 : Makefile livré.

Comme le processus peut être un peu compliqué au début, il est possible de l'automatiser. Une solution est proposée par la figure 14 : elle utilise tous les fichiers de code du dossier de projets.

Figure 14 : Makefile modifié.

Cette méthode évite d'avoir à inclure chaque fichier source à la main dans le Makefile. Notez également la modification de la structure des dossiers. Tous les fichiers source, y compris les fichiers principaux, sont maintenant situés dans ./src/ et vous pouvez y ajouter des dossiers et des fichiers supplémentaires. Vous pouvez également voir qu'un dossier MAX78000_FTHR a été ajouté au projet. Il s'agit de liens symboliques vers les fichiers de gestion de la carte, de fichiers de démarrage et de scripts de liaison dans le SDK. Vous y trouverez également du code pour les périphériques intégrés, lorsqu'ils sont disponibles.

Emplacements masqués

La raison pour laquelle ces liens symboliques sont ajoutés est de donner un certain nombre de détails sur le code de démarrage de la carte, ce qui vous permet de modifier le code pour vos propres besoins. Comme il s'agit d'un sujet plus avancé que nous ne pouvons pas décrire en détail ici, nous allons l'aborder de manière succincte. Comme l'indique la figure 15, startup_max78000.S et system_max78000.c correspondent au code exécuté directement lorsque le système en a terminé avec la réinitialisation.
 

Figure 15 : Fichiers de démarrage.

Dans le fichier startup_max78000.S, le cœur Cortex-M4 se prépare à exécuter du code et deux fonctions seront appelées : SystemInit et main. Trouver la fonction main n'est plus un secret pour vous, mais SystemInit par contre se cache dans system_max78000.c. Comme vous pouvez le voir sur la figure 16, la fonction est déclarée comme _weak void SystemInit(void). La clé _weak signifie que, si l'éditeur de liens trouve une deuxième fonction qui s'appelle également void SystemInit(void)- donc sans clé _weak - c'est elle qui sera choisie et liée.

Figure 16 : Fonction Weak StartupInit().

 

La fonction SystemInit n'est pas la seule à être déclarée. Les deux fonctions qu'elle appelle, SystemCoreClockUpdate et Board_Init, le sont aussi avec la clé _weak et Board_Init est aussi présente dans le fichier board.c, comme le montre la figure 17. À ce stade, tous les composants de base seront initialisés avant l'appel de main(). Il s'agit des E/S GPIO, de l'UART 0 comme console série, du régulateur d'alimentation et des LED. L'UART 0, connecté au débogueur intégré, est utilisé comme périphérique d'entrée et de sortie par défaut pour toutes les fonctions liées à printf. La modification de ces fichiers n'est destinée qu'à une utilisation plus avancée et ne devrait être envisagée qu'avec précaution si c'est votre premier projet.
 

Figure 17 : Fichier Board.c avec Board_Init().

Écrire en C ou C++ et envoyer du code au MAX78000, telle est la question

Pour commencer, choisissez d'écrire en C ou en C++. Si vous optez pour le C++, supprimez le fichier main.c de notre exemple de projet. Et si vous choisissez le C, supprimez le fichier main.cpp. Une fois le programme HelloWord compilé et exécutable, nous devons l'installer sur le MAX78000. Nous allons pour cela utiliser le débogueur embarqué, non seulement pour le programmer, mais aussi pour démarrer une session de débogage. Sélectionnez les paramètres de débogage, comme le montre la figure 18, nettoyez le projet et recompilez-le.
 

Figure 18 : Paramètres de débogage.

Il se peut que le code ne soit pas présent pour le débogage. Cliquez sur l'icône représentant un petit insecte vert, comme le montre la figure 19, et laissez le code se charger et s'exécuter.

Figure 19 : Icône de débogage.

Choisissez un terminal série, putty par exemple, pour surveiller des données produites par le MAX78000. Les paramètres requis sont 115200 bauds, 8 bits de données, pas de parité, un bit d'arrêt. Connectez-vous au port COM du débogueur embarqué sur la carte MAXIM78000FHTR et initialisez une connexion série. Le résultat devrait ressembler à ce que vous voyez sur la figure 20.
 

Figure 20 : Session de débogage, arrêtée sur main().

Le débogueur est attaché, le moniteur série est prêt à être utilisé et l'exécution de notre code a été arrêtée dans la fonction principale. Si nous appuyons maintenant sur le bouton de reprise (voir figure 21), nous obtiendrons des données sur notre terminal, comme le montre la figure 22.

 

Figure 21: Resume button.
Figure 22 : Exécution de l'exemple HelloWorld.

 

Explorer les périphériques pas à pas

Un petit conseil : explorez les périphériques fournis par le MAX78000 pas à pas. Vous aurez ainsi un bon aperçu du système lui-même. Des exemples sont donnés pour tous les périphériques. Pendant que vous les explorez, gardez un analyseur logique ou un oscilloscope numérique à portée de main pour vérifier que le système se comporte comme prévu. Il faut du temps pour se familiariser avec un nouveau microcontrôleur, surtout si vous êtes habitué à d'autres fournisseurs, Ici encore, les périphériques et les outils sont fournis. Quelques heures ne suffiront pas pour tout explorer, ce sera plutôt l'affaire de plusieurs semaines, voire quelques mois. Et si vous rencontrez des difficultés ou si un élément se comporte bizarrement, n'hésitez pas à demander de l'aide ou à déposer un problème sur GitHub.

Exemples d'IA

Pour l'instant, vous ne pourrez pas générer d'exemples d'IA pour le MAX78000 basés sur ceux accompagnant l'assistant fourni. Pour y accéder, vous devez les importer manuellement depuis le SDK. Si vous jetez un coup d'œil au guide accessible en [7], il vous montrera comment ajouter ces exemples à votre espace de travail Eclipse. Vous y trouverez également le projet kws20_demo sur lequel est basée la cafetière.

Construction de la cafetière

À ce stade, je vais supposer que vous êtes assez familier avec le MAX78000 et que vous créez votre premier programme Hello World avec lui. Je récapitule ci-dessous les composants nécessaires au cas où vous n'auriez pas la première partie de cet article sous la main :

  • Carte MAX78000FTHR RevA (figure 23)
 
Figure 23 : Carte MAX78000FTHR.
  • Carte d'essai
  • Cavaliers
  • Écran TFT 2,2" disponible dans l'e-choppe Elektor (figure 24)
 
Figure 24 : Écran TFT.

 

Ces composants, câblés comme indiqué sur la figure 25, constituent le strict minimum pour l'écran.

Figure 25 : Schéma du projet.

Cet écran a été choisi car le SDK fournit déjà un pilote prêt à l'emploi pour celui-ci. Nous pourrons ainsi gagner du temps ultérieurement puisque nous n'aurons pas à développer un pilote d'écran par nous-mêmes. Les fonctionnalités que nous allons implémenter sont les suivantes :

  • La machine doit écouter et comprendre son nom : HAPPY.
  • Demander si elle doit préparer un café.
  • Demander si une tasse est insérée.
  • Assurer le retour d'information vers l'utilisateur par le biais d'un écran LCD.

S'il manque une vraie cafetière dans cette liste, sachez qu'aucun appareil de ce type en état de marche n'a été endommagé lors de la réalisation de cette présentation. Comme il s'agit d'une étude de faisabilité, l'intégration dans une cafetière réelle dépend du fournisseur, et celle que nous utilisons ici est virtuelle.
Nous avons également besoin du réseau neuronal formé, créé dans la première partie. Assurez-vous d'avoir accès aux fichiers générés car nous en aurons besoin plus tard pour ce projet afin de permettre la reconnaissance de nos nouveaux mots sélectionnés.

Modifier le code

La cafetière est basée sur le projet kws20_demo, fourni par le SDK. La première chose à faire est de vérifier que nos mots, issus d'un nouvel entraînement, sont reconnus comme ils le devraient. Pour cela, nous prenons une copie de kws20_demo et la plaçons dans notre espace de travail Eclipse. Si vous avez choisi le chemin par défaut pour l'espace de travail Eclipse, le projet se trouve sur C:\Users\{username}\eclipse-workspace. Le projet ayant été copié, nous pouvons l'importer à partir de cet emplacement, comme le montre la figure 26.
 

Figure 26 : Importation du projet.

Suivez l'assistant comme indiqué aux figures 27 et 28.

Figure 27 : Première étape de l'assistant d'importation.
Figure 28 : Deuxième étape de l'assistant d'importation.

Un nouveau projet va apparaître dans votre espace de travail, comme le montre la figure 29.

Figure 29 : Projet importé.

Si vous avez toujours le code HelloWorld dans votre espace de travail, vous pouvez maintenant le supprimer. Tout d'abord, le code sera compilé et testé sur la carte MAX78000 pour vérifier que l'exemple fourni fonctionne. Comme pour l'exemple HelloWorld précédent, nous devons adapter ce projet à la carte MAX78000FTHR. Dans ce cas, nous devons entrer dans les paramètres C/C++ Build et saisir la commande Build. Entrez make -r BOARD=FTHR_RevA ECLIPSE=1 -j8 "" et appliquez les paramètres comme indiqué à la figure 30.

Figure 30 : Ligne ajoutée au build pour la carte MAX78000FTHR.

Ceci va vous permettre de compiler le projet kws20_demo pour la carte MAX78000FTHR. Une fois tout compilé, nous pouvons télécharger et déboguer le code. Si nous attachons le terminal série puTTY, nous pouvons voir les mots reconnus comme indiqué dans la figure 31.
 

Figure 31 : Mots détectés affichés dans le terminal puTTY.

Mise en place du nouveau réseau neuronal entraîné

L'entraînement abordé dans la première partie a produit un réseau neuronal qui peut être directement transféré dans ce projet Eclipse. À partir de notre projet entraîné, nous devons déplacer les fichiers cnn.h, cnn.c et weights.h dans le projet kws20_demo et remplacer les fichiers actuels. Après nettoyage (clean) et compilation (build), nous pouvons tester le nouveau réseau neuronal sur le MAX78000. Si le code est téléchargé et que nous utilisons le mot-clé HAPPY, le résultat sera ce que vous voyez à la figure 32. Si vous vous demandez maintenant pourquoi le mot-clé reconnu est DOWN, nous devons jeter un coup d'œil au code.

Figure 32 : Mot-clé non signalé, comme prévu.

Dans notre code main.c à la ligne 136 (figure 33), vous pouvez voir une ligne const char keywords[NUM_OUTPUTS][10] qui contiendra un tableau de chaînes de caractères.

Figure 33 : Tableau dans main.c.

Si vous regardez maintenant la figure 34, vous pouvez voir que nous avons modifié vos mots-clés pour qu'ils soient entraînés pour le réseau neuronal et que ceux du tableau dans notre main.c ne correspondent pas.
 

Figure 34 : Script d'entraînement modifié.

Cela tient à la façon dont nous obtenons les mots reconnus par l'accélérateur du CNN. Pour chaque mot résultant de l'entraînement, l'accélérateur donnera un index et une probabilité d'un mot. Ainsi, pour obtenir un résultat correct en sortie, nous devons ajuster le mot-clé afin de faire correspondre les éléments du tableau de chaînes avec l'index des mots utilisés dans notre réseau neuronal.

Si les nouveaux mots-clés sont en place, le code ressemblera à ce que vous voyez à la figure 35.

Figure 35 : Tableau mis à jour pour le rapport sur les mots-clés.

Si nous appelons maintenant HAPPY, nous pouvons voir un résultat tel que celui de la figure 36.

Figure 36 : Mot-clé signalé, comme prévu.

Alors que cette partie du code fonctionne, nous avons un affichage qui ne produit à ce stade aucun résultat en sortie. Pour le faire fonctionner, il suffit d'ajouter #define ENABLE_TFT à la ligne 73 de main.c et d'effectuer un nettoyage/compilation du projet. Une méthode préférée serait d'utiliser le Makefile et de supprimer le signe de commentaire de la ligne correspondante. Le pilote inclus fonctionnera parfaitement avec l'écran, et nous pourrons l'utiliser plus tard pour la cafetière. Le résultat apparaît sur la figure 37.
 

Figure 37 : Le matériel et le logiciel fonctionnent.

Utilisation d'une bibliothèque d'interface graphique fonctionnant presque partout

Nous avons maintenant un projet de repérage de mots-clés qui fonctionne et qui permet également d'afficher des graphiques sur l'écran associé. Pour éviter d'écrire notre propre bibliothèque GUI, nous en utilisons une qui existe. Pour ce projet, nous allons utiliser LVGL pour produire notre interface utilisateur. En plus d'être hautement portable, cette bibliothèque permet d'optimiser au minimum les ressources utilisées. Même avec les animations et les effets de transparence, le volume de mémoire RAM occupé est faible. Toute la question est de savoir s'il est difficile d'ajouter la bibliothèque LVGL au projet kws20_demo.

Comme la LVGL utilise également des Makefiles pour construire son code, l'intégration n'est pas si compliquée que cela. Le code lui-même est transféré dans nos projets dans un répertoire de bibliothèque. Il ressemblera à ce que vous pouvez voir à la figure 38.
 

Figure 38 : Ajout de la bibliothèque LVGL.

Le Makefile du projet est donc également modifié comme vous pouvez le voir sur la figure 39. Cela permettra de faire la compilation et l'édition de liens de notre projet et de la LVGL.

Figure 39 : Makefile modifié pour prendre en charge la bibliothèque LVGL.

Pour que la LVGL soit en mesure d'afficher des données sur notre écran, le pilote doit être capable de transférer un ensemble de données d'image. Bien que le pilote d'affichage fourni puisse écrire des données pixel par pixel dans des positions données, la charge sera très élevée. Une méthode plus rapide consiste à écrire un rectangle de données d'image sur l'écran. Ce processus est mis en œuvre pour le pilote de la caméra, mais la façon dont cette fonction attend les données n'est pas compatible avec la façon dont la LVGL génère ses données d'affichage. Il a été facile de modifier le pilote d'affichage avec une fonction permettant de traiter les données comme la LVGL les produit. De plus, alors que le code était en cours d'exécution, son dépôt dans le référentiel SDK MAX78000 a été demandé sous la forme d'une demande d'extraction [4]. Ainsi, il n'est pas nécessaire de modifier les fichiers du SDK, et tout le monde peut bénéficier du travail effectué. Ce qui permet d'améliorer le SDK et d'autres parties du logiciel.

Assembler tous les éléments

Nous avons maintenant une bibliothèque d'interface utilisateur graphique (GUI) qui peut fonctionner avec le MAX78000 et nous pouvons aussi détecter les mots-clés. Il ne nous manque donc que la logique. Avant de continuer, nous devons examiner comment fonctionne la détection des mots-clés. La figure 40 montre le flux logiciel original. Nous interceptons les mots-clés reconnus et nous les utilisons comme entrée pour un automate fini de cafetière. Celui-ci se charge pour nous de l'interface graphique et de la logique. À ce stade, le codage se déroule comme prévu.

Figure 40 : Flux d'origine pour le repérage des mots-clés.

Le traitement audio est un aspect crucial pour le repérage des mots-clés. Si nous consacrons trop de temps à d'autres tâches, il est possible que nos mots-clés ne soient pas reconnus. Cela peut se produire si des échantillons audio sont refusés parce que nous ne traitons pas les données d'entrée dans un laps de temps donné. Et c'est exactement ce qui s'est passé après le test de la première version de la cafetière. Le premier flux représenté sur la Figure 41 ne peut donc pas être utilisé. Si nous avons des contraintes de temps pour la partie audio, pourquoi ne pas déplacer l'interface graphique vers le cœur RISC-V ? Il devrait être largement capable d'exécuter l'interface graphique. De plus, la LVGL serait bien adaptée pour fonctionner avec ce cœur puisqu'il est conçu pour fonctionner en mode basse consommation.

Figure 41 : Premier flux prévu.

Nous avons un cœur RISC-V à notre disposition

Pour de telles tâches, le cœur RISC-V est idéal car il peut gérer l'interface graphique et offrir suffisamment de puissance pour produire et déplacer les données nécessaires à la bibliothèque LVGL. À un problème près, malheureusement. Si vous consultez le guide de l'utilisateur du MAX78000, vous trouverez quelques indications sur ce à quoi le processeur RISC-V peut accéder. Ce qui n'est mentionné qu'indirectement, c'est l'incapacité du cœur RISC-V à accéder aux périphériques sur bus AHB comme l'interface SPI0 ou le FiFo du CNN. Nous avons ici un petit obstacle, car l'écran et certains autres périphériques comme l'interface de la carte SD et la RAM SPI sont liés à SPI0. Cela signifie que dans ce cas, il n'est pas efficace pour le moment de décharger totalement l'interface graphique du cœur Cortex-M4. De plus, le débogueur intégré n'est pas lié au cœur RISC-V, et nous ne pouvons donc l'utiliser que pour déboguer le code exécuté sur le Cortex-M4. Nous n'allons pas aborder ici l'approche du double cœur, et ce sera peut-être l'objet d'un autre article. Pour avoir une vision un peu plus claire de ce qui est à votre disposition, consultez le schéma fonctionnel modifié de la figure 42.

Figure 42 : Schéma fonctionnel modifié du MAX78000.

Avec l'exemple basé sur un double cœur proposé, vous devez également savoir que vous perdrez la possibilité de faire du débogage sur le cœur RISC-V et le cœur Cortex-M4. Ceci tient à la façon dont l'exécutable combiné est produit actuellement. Cet aspect devrait être et sera probablement amélioré par Maxim dans le futur.

Il est temps de prendre un café !

Comme nous ne pouvons pas utiliser le processeur RISC-V, il a été nécessaire de procéder à quelques adaptations du flux du programme. Le flux modifié apparaît sur la figure 43.
 

Figure 43 : Flux modifié.

Avec ce flux, l'interface graphique n'est mise à jour qu'au moment où les interférences avec le processus de capture sonore sont moins susceptibles d'entraîner la perte d'échantillons audio. Il est possible de télécharger le code résultant à l'aide de la page GitHub d'Elektor pour avoir un meilleur aperçu de la mécanique. Si vous réalisez vos propres projets, je vous conseille d'identifier le flux de données pour lequel la notion de temps est critique.

La cafetière se met à l'écoute du mot HAPPY (son nom) et pose quelques questions avant de préparer votre café. Ces questions appellent de simples réponses YES (oui) ou NO (non), de sorte que nous n'utilisons qu'une fraction du mot appris. De plus, aucune instruction STOP (arrêt) n'a encore été mise en œuvre - par exemple, si votre tasse déborde. Comme il s'agit d'un exemple, il est loin d'être parfait. Pour être appliqué en production, il faudra encore beaucoup travailler sur le code et le flux de données interne.

Premier projet avec le MAX78000

Votre premier programme HelloWorld ne vous prendra que peu de temps. C'est également vrai pour une démo modifiée de repérage de mots-clés si vous avez les bons éléments. S'engager dans un projet avec le MAX78000 et faire de l'IA veut dire faire face à une documentation qui sera améliorée au fil du temps. Vous trouverez sans doute aussi des bogues ou des éléments manquants dans le SDK. Vous devez garder à l'esprit que le SDK et la documentation sont pour partie encore en construction.

Pour autant, le MAX78000FTHR est un outil peu coûteux pour entrer dans le monde de l'IA sur les dispositifs embarqués. Maxim a fait un excellent travail en intégrant un accélérateur de réseau neuronal convolutif dans une puce qui peut fonctionner avec des sources d'énergie limitées. Et si vous souhaitez d'autres conseils et astuces, rendez-vous dans les pages d'Elektor Labs et utilisez la fonction de commentaires.

Participez au concours de conception d'IA pour MAX78000

Si vous aimez les défis, en voici un. Vous pouvez participer au concours de conception d'IA pour MAX78000 de Maxim Integrated (sous l'égide d'Elektor) et vous aurez ainsi une chance de proposer une application du microcontrôleur MAX78000. Grâce à une carte MAX78000, vous pourrez développer un projet, partager votre expérience avec notre public et acquérir de l'expérience en IA. Vous aurez ainsi la chance d'être un véritable pionnier. Saisissez cette opportunité de découvrir un domaine où peu de développeurs d'applications embarquées sont intervenus, et où les dispositifs embarqués rencontrent l'IA. Pour en savoir plus, rendez-vous sur le site du concours - elektormagazine.com/ai-contest-max78000. Si vous avez des questions ou des difficultés pendant la durée du concours, vous pouvez également demander l'aide d'un des ingénieurs de Maxim. Vous pourrez ainsi éliminer les obstacles liés à la création de votre projet.

Souhaits d'améliorations futures

Il serait souhaitable d'améliorer dans un futur proche la documentation du cœur RISC-V et d'ajouter davantage d'exemples de code. De même, l'impossibilité d'accéder à certains périphériques à partir du cœur RISC-V devrait être énoncée plus clairement, et d'autres limitations liées à la combinaison des deux cœurs devraient faire l'objet d'un chapitre spécifique dans la fiche technique.

Concernant les exemples de code, un autre souhait serait de savoir de manière succincte comment utiliser le moteur DMA. Même si nous ne pouvons pas accéder directement au périphérique SPI0, l'unité DMA devrait pouvoir le faire. Ce qui peut donner un moyen d'utiliser le SPI0, même avec le cœur RISC-V. De plus, si cet aspect peut s'intégrer directement dans un manuel d'utilisation, quelques exemples de code de base expliquant comment écrire un gestionnaire d'interruption pour les processeurs Cortex-M4 et RISC-V rendront certainement les choses plus faciles pour l'utilisateur. Et puisque Maxim est actuellement sur le sujet, un bon point de départ serait un programme HelloWorld sur double cœur, qui permette de déboguer le cœur Cortex-M4 et d'exécuter le code sur le cœur RISC-V. Enfin, à titre de dernier souhait, nous avons quelques idées, sans être sûrs que ce soit la voie à suivre.

Pour l'IDE, même s'il s'agit peut-être d'un vœu pieux, que diriez-vous d'une intégration dans Platformio pour code Visual Studio ? Ou au moins une compatibilité officielle avec Linux. Pour l'entraînement de nos réseaux neuronaux, un système Linux est préférable. Pourquoi ne pas aussi l'envisager pour le développement logiciel du MAX78000 ?

Pousser l'IA au Max

Le MAX78000 offre un aperçu de l'avenir et introduit l'IA dans l'univers des dispositifs embarqués à ressources limitées. Si vous aimez utiliser des appareils à la pointe de la technologie, celui-ci est fait pour vous. Pour 40 € à peine, il met à votre portée un point d'entrée abordable dans le domaine de l'IA et des réseaux neuronaux. Le matériel est absolument passionnant, mais soyez prêt(e) à vous attaquer à une documentation qui nécessite des améliorations. Si vous êtes novice en matière de développement embarqué, il vous faudra peut-être un certain temps pour vous familiariser avec le MAX78000 et réaliser tout son potentiel. Mais ne vous laissez pas décourager par un bon défi d'ingénierie. Je suis curieux de voir ce que Maxim va améliorer au cours des prochaines semaines, voire des prochains mois. Peut-être verrons-nous une documentation améliorée et un chapitre supplémentaire pour le cœur RISC-V.

Avec un microcontrôleur MAX78000, de la créativité et un zeste de persévérance, je suis sûr que nombre d'entre vous proposeront très vite des projets novateurs. Je vous encourage à tester vos compétences en proposant vos projets dans le cadre du concours de conception d'IA pour MAX78000 de Maxim Integrated !
 

Note de l'auteur : tout au long de la rédaction de cet article, j'ai dialogué avec les ingénieurs de Maxim Integrated.

Des questions ? Des commentaires ?
Avez-vous des questions ou des commentaires techniques à propos de cet article ? N'hésitez pas à envoyer un courrier électronique à l'auteur à l'adresse mathias.claussen@elektor.com ou contactez Elektor à l'adresse editor@elektor.com.