Koffie zetten met de MAX78000 en een stukje AI (deel 2)

In het eerste deel van deze serie hebben we laten zien hoe een convolutioneel neuraal netwerk op een Linux PC kan worden getraind om gesproken sleutelwoorden te herkennen. Het resultaat was een aantal bestanden, met daarin het CNN en de bijbehorende functies. In dit artikel gaan we beginnen met het ontwikkelen in de Maxim Micro SDK om de code voor de besturing van onze demo-koffiemachine te implementeren. Om de instap met de MAX78000 gemakkelijker te maken, tonen we niet alleen hoe de code is gemaakt en hoe hij werkt, maar bespreken we ook het inrichten van de IDE en geven we wat tips voor uw eigen projecten.

De Maxim Micro SDK is gebaseerd op Eclipse, een bekende, veelgebruikte IDE. Veel fabrikanten maken gebruik van deze IDE, die veel aanpassingsmogelijkheden biedt: we kunnen add-ons installeren en het uiterlijk helemaal aanpassen aan onze eigen wensen. Maxim gebruikt een niet-aangepaste versie van de Eclipse-IDE, met alleen een paar toevoegingen die het gemakkelijker maken om uw MCU-project op te zetten. Dat maakt het onderhoud gemakkelijk en geeft de gebruiker de vrijheid om de IDE naar eigen inzicht aan te passen.

Op dit moment ondersteunt de Maxim Micro SDK alleen Windows, dus we gaan er bij dit project van uit dat u Windows 10 gebruikt. We hebben ook het standaardpad voor SDK-installatie niet veranderd (figuur 1), want spaties en andere bijzondere tekens kunnen problemen veroorzaken in een Windows pad.
 

Na het downloaden van de installer van de Maxim-website kunt u deze opstarten. Er verschijnt dat een wizard. Kies bij het installeren alleen de MAX78000 als te ondersteunen platform (zie figuur 2). Dan wordt de installatie niet te groot en krijg u niet teveel overtollige files op uw harde schijf. Het installeren kan even duren en er is een werkende Internetverbinding bij nodig om bepaalde componenten te downloaden.

Als de installatie klaar is, kunt u de Maxim Micro SDK starten. Ga gewoon naar het startmenu, zoek naar Maxim Integrated SDK en kies Eclipse MaximSDK (figuur 3).
 

Dan verschijnt de Eclipse-IDE zoals in figuur 4.

 

Werk in Uitvoering

De MAX78000 is een nieuwe microcontroller van Maxim, en terwijl de hardware wordt gefabriceerd en verzonden, gaat Maxim door met het verbeteren en updaten van de documentatie. Ga naar de GitHub-pagina voor de MAX78000 voor de nieuwste documentatie en software. U kunt daar ook melding maken van problemen die u tegenkomt. Dat geldt niet alleen voor de documentatie maar ook voor de SDK. Ook de MAX78000-handleiding is nog in bewerking: nog niet alle hoofdstukken zijn definitief. Aan het hoofdstuk over RISC-V wordt nog gewerkt. Naar verwachting zal er in de toekomst nog meer worden toegevoegd om dit deel van de chip meer in detail te beschrijven. De documenten en de SDK zijn gewoon nog een “werk in uitvoering”, op weg naar versie 1.0 en ze zullen steeds verder verbeterd worden. Als u nog informatie mist, kunt u misschien een vraag stellen aan Maxim, of zelf dieper in de code duiken.

Een nieuw project, makefiles en wat trucs

We beginnen met een nieuw HelloWorld-project om de basisbeginselen te laten zien en te wijzen op wat verborgen mogelijkheden in de Maxim SDK. Niet iedereen is dol op makefiles. Veel tools helpen u door het maken van de code voor de makefile min of meer te automatiseren. Er zijn programma’s die automatisch de afhankelijkheid tussen stukken broncode analyseren en makefiles genereren. En er zijn tools die gebruik maken van CMake of SCons voor het genereren van uitvoerbare code. In dit geval moet u wel met makefiles werken, maar we kunnen u wel wat aanwijzingen geven die dat gemakkelijker maken.

Open de Eclipse MaximSDK om een nieuw project aan te maken. U ziet dan eerst de welkomstpagina (figuur 5).

We maken een nieuw project aan met de projectwizard, zoals in figuur 6.

Kies een naam voor het project en kies in het dialoogvenster de instellingen in figuur 7.

Hiermee kopieert u het voorbeeldproject HelloWorld naar uw eigen workspace. Als u in de lijst de projecten en voorbeelden voor de AI-accelerator mist, geen zorgen daar komen we nog op terug. Voorlopig willen we alleen de chip en de ontwikkelomgeving wat beter leren kennen.

Als alles goed gaat, ziet u nu een nieuw project (figuur 8).

Dit is een eenvoudig HelloWorld-project dat ik wil gebruiken om het een en ander uit te leggen. Als u naar de code kijkt, zult u zien dat veel includes en functies niet gevonden kunnen worden. Dat is op dit moment een tekortkoming in de samenwerking tussen de SDK en de Eclipse-IDE. Maxim geeft in de tutorial Getting Started with Eclipse wat tips over dit probleem in het hoofdstuk “Troubleshooting unresolved symbols”. Maar u hebt hier alleen last van, als u met de hulp van Eclipse wilt navigeren door de code. Als u de code compileert, maakt de IDE een executable, die u in de MAX78000 kunt flashen. Gebruik de knop met het hamertje (figuur 9) om de compilatie te starten.

In de onderste vensters verschijnen enkele regels output op een console, hopelijk zonder foutmeldingen. Uw eerste HelloWorld-executable is dan klaar. Alle recepten voor het bouwen worden bestuurd vanuit makefiles. Laten we daarom de makefile voor dit project maar eens bekijken.

C en de makefile

De makefile heet makefile en bevindt zich in de projectdirectory. U ziet daar ook een file main.c, die de C-code voor de Cortex-M4 MCU bevat. Als u normale C-code wilt gebruiken is dat goed, maar wat als u C++ wilt gaan gebruiken? In dat geval verandert u de naam van main.c in main.cpp, en wordt de code behandeld as C++. Als u nu op de compile-knop drukt, zult u zien dat de HelloWorld-executable helemaal niet wordt gebouwd. In de makefile staat namelijk ook gedefinieerd welk type evaluatieboard u gebruikt. Standaard staat dit ingesteld op de MAX78000EVKIT, Maar wij gebruiken een MAX78000FTHR_RevA. Daarom moeten we in de makefile regel 54 BOARD=EvKit_V1 uitcommentariëren en op regel 55 BOARD=FTHR_RevA het # juist verwijderen, om die regel actief te maken.

Na die aanpassing vinden Eclipse en de tooling in de makefile het nog niet nodig om opnieuw te compileren: de broncode is niet veranderd en het resultaat van de vorige compilatie staat er nog. Daarom moeten we nu even met de hand met enkele muisklikken alles opruimen, zoals in figuur 10.

Kies Clean en er verschijnt een wizard-venster, waarin we kunnen kiezen wat er moet worden opgeschoond. We hebben maar één project, dus we kunnen gewoon kiezen voor All, zoals in figuur 11. Dit schoont het project op en maakt het mogelijk om opnieuw te bouwen.

Als we nu onze main.cpp compileren, geeft de linker foutmeldingen, omdat enkele functies en symbolen niet zijn gedefinieerd. Dat heeft te maken met de manier waarop de C- en C++-compiler werken en code produceren. Omdat we main.c hebben hernoemd naar main.cpp, wordt nu de g++-compiler aangeroepen. Dat is weliswaar een C++-compiler, maar hij begrijpt ook C-code. Sommige delen van de SDK zijn nog in normale C-code geschreven en worden gecompileerd door de gcc-compiler. De linker moet nu gecompileerde C++- en C-code met elkaar samenvoegen tot één executable.

Om C++-code te maken die met C-code samen te linken is, moeten we op enkele plaatsen dingen declareren als extern "C". Hoe dat in zijn werk gaat, ziet u in figuur 12.

Dat moet zoveel mogelijk worden gedaan in de included header-files. Er is al een verzoek voor een geüpdate SDK gedaan op GitHub en Maxim gaat daar voor zorgen. Als u ook zaken vindt die verbeterd kunnen worden, maak dan gebruik van de issue tracker op GitHub. Dat is de plaats om feedback te geven. Uw input kan leiden tot nuttige veranderingen of verbeteringen. En alle andere SDK-gebruikers kunnen profiteren van uw feedback.

Aanpassingen in de mappen en de makefile

Als u code gaat toevoegen aan het project, zult u al snel merken dat die niet wordt gecompileerd. Dat komt door de makefile. Zoals u kunt zien in figuur 13, moet elk bestand worden toegevoegd aan de SCRS-regel.

Dan kan in het begin wat lastig zijn, maar er zijn manieren om dat te automatiseren. Een oplossing is te zien in figuur 14. Hiermee worden alle codebestanden in uw projectmap gebruikt.

Dit verlost u van de eis dat elke broncodefile met de hand aan de makefile moet worden toegevoegd. Wat opvalt, is dat de directory-structuur is aangepast. Alle broncode, inclusief main.cpp, bevindt zich nu in  ./src/. Daar kunt u extra mappen en files toevoegen. U ziet ook dat er een map MAX78000_FTHR is toegevoegd aan het project. Dit zijn symbolische links naar de bestanden voor ondersteuning van het board, start-up-files en linker-scripts in de SDK. U vindt daar ook code voor de periferie, voor zover die beschikbaar is.

Verborgen locaties

Deze symbolische links zijn toegevoegd om u naar de start-up-code voor de kaart te leiden, waar u de code zou kunnen aanpassen aan uw eigen behoeften. Dat is iets waar we nu nog niet aan toe zijn, maar we kunnen alvast een kijkje nemen. Zoals te zien is in figuur 15 zijn startup_max78000.S en system_max78000.c verantwoordelijk voor de code die wordt uitgevoerd na het resetten van de kaart.

In startup_max78000.S wordt de Cortex-M4-kern voorbereid voor het uitvoeren van code en er worden twee functies aangeroepen: SystemInit en main. Het is wel duidelijk waar main() te vinden is, maar SystemInit zit verborgen in system_max78000.c. Zoals u kunt zien in figuur 16, wordt deze functie gedeclareerd als _weak void SystemInit(void). Het sleutelwoord _weak betekent, dat als de linker een tweede functie met dezelfde naam vindt, maar dan zonder _weak, dat hij dan die andere functie moet gebruiken bij het linken.

 

Niet alleen SystemInit maar ook de twee functies die hij aanroept, SystemCoreClockUpdate en Board_Init, zijn _weak gedeclareerd en Board_Init zit ook in het bestand board.c, zoals u ziet in figuur 17.

Nu zijn alle basiscomponenten geïnitialiseerd voordat main() wordt aangeroepen. Dat zijn de GPIO’s, UART 0 als serieel console, de voedingsregelaar en LED’s. UART 0, die verbonden is met de debugger, worden gebruikt als default input- en output-apparaat voor alle functies die te maken hebben met printf. Deze files aanpassen is meer iets voor geavanceerde gebruikers. U kunt daar beter voorzichtig mee zijn bij uw eerste project.

Kies C of C++ en stuur code naar de MAX78000

Kies eerst C of C++ voor uw project. Als u gaat voor C++, verwijder dan main.c voor ons voorbeeldproject. En als u kiest voor C, verwijder dan main.cpp.

Als onze HelloWorld eenmaal is gecompileerd, moeten we hem nog op de MAX78000 zien te krijgen. We gaan de debugger op de kaart gebruiken, niet alleen om hem te programmeren, maar ook om een debug-sessie te starten. Kies de Debug-instellingen zoals figuur 18, schoon het project op en bouw het opnieuw.

Als u release kiest, kan het zijn dat de code niet beschikbaar is om te debuggen. Klik het pictogram met de groene kever aan (zie figuur 19) en laat de code uploaden en uitvoeren.

Gebruik een seriële monitor, zoals putty, om de output van de MAX78000 weer te geven. De instellingen zijn 115200 Baud, 8 databits, geen pariteit, één stopbit. Maak verbinding met de COM-poort van de debugger van de MAXIM78000FHTR en start een seriële verbinding. Dat moet er uitzien als in figuur 20.

De debugger is aangesloten, de seriële monitor is klaar voor gebruik en de uitvoering van onze code is gestopt bij de functie main(). Als we nu op resume drukken (zie figuur 21), 

wordt er data weergegeven in onze terminal, zoals in figuur 22.

 

Onderzoek de periferie stap voor stap

Een advies: onderzoek de periferie van de MAX78000 stap voor stap. Daarmee krijgt u een goed inzicht in het systeem. Er zijn voorbeelden beschikbaar voor alle periferie. Het is aan te raden om bij dit verkennen een logic analyzer of een digitale scoop bij de hand te hebben om de werking te controleren. Een nieuwe microcontroller is altijd even wennen, zeker als u gewend bent aan controllers van een andere fabrikant. Er zijn periferie en tools voor alle onderdelen beschikbaar. Dit krijgt u niet in een paar uur onder de knie; het gaat meerdere weken of zelfs maanden duren. En als u vastloopt, of als iets niet werkt zoals verwacht, stel dan vragen, of voer issues in op GitHub.

 

AI-voorbeelden

Wat u nog niet kunt genereren met de bestaande voorbeelden en de beschikbare wizard zijn de AI-voorbeelden voor de MAX78000. Die zijn wel beschikbaar in de SDK, maar u moet ze met de hand importeren. In [7] kunt u lezen, hoe u deze voorbeelden kunt toevoegen aan uw Eclipse-workspace. U vindt daar ook de demo kws20_demo, waar de koffiemachine op is gebaseerd.

Bouwen van de koffiemachine

Vanaf hier ga ik er vanuit dat u een beetje bekend bent met de MAX78000 en uw eerste HelloWorld hebt gedaan. Ik vat hier nog even samen, welke onderdelen we nodig hebben, voor het geval dat u het eerste artikel niet bij de hand hebt:

• MAX78000FTHR RevA-board (figuur 23);

  
• Breadboard;
• Dupont-kabeltjes;
• 2,2” TFT-scherm uit de ElektorShop (figuur 24).

  

 

Die componenten, aangesloten zoals in figuur 25, zijn het absolute minimum voor het display.

Er is voor dit display gekozen, omdat de SDK er al een complete driver voor bevat. Dat bespaart ons een hoop werk, want nu hoeven we niet zelf een driver te ontwikkelen. We gaan de volgende functies implementeren:

• De machine herkent het woord HAPPY als zijn naam.
• Hij moet vragen of hij koffie moet maken.
• Hij moet vragen of er een beker geplaatst is.
• Hij moet feedback aan de gebruiker geven via een LCD.

Er komt geen koffieautomaat voor op de lijst. Wees gerust: er zijn geen werkende koffiemachines beschadigd bij het doen van dit project. We willen alleen aantonen dat het concept kan werken. Inbouwen in een echte koffieautomaat is per fabrikant verschillend, dus wij gebruiken een virtuele automaat.

We hebben ook het getrainde neurale netwerk nodig, dat we in het eerste deel hebben gemaakt. Houd de gegenereerde files bij de hand, want we moeten ze straks gedeeltelijk opnemen in dit project om onze nieuw geselecteerde woorden te herkennen.

Pas de code aan

De koffiemachine is gebaseerd op het project kws20_demo in de SDK. Eerst moeten we controleren of onze nieuw getrainde woorden worden herkend. We nemen daarvoor een kopie van de kws20_demo en plaatsen die in onze Eclipse-workspace. Als u het standaard pad voor de Eclipse-workspace hebt gekozen, staat het project onder C:\users\{gebruikersnaam}\eclipse-workspace. Als het project gekopieerd is, kunnen we het vanaf die locatie importeren zoals in figuur 26.

Volg de wizard zoals in figuur 27 en figuur 28.

Er verschijnt een nieuw project in uw workspace zoals in figuur 29.

Als er nog een HelloWorld in uw workspace staat, kunt u die nu verwijderen. Bouw de code eerst en test hem op de MAX7800 om te controleren of het beschikbaar gestelde voorbeeld echt werkt. Net als bij het HelloWorld-voorbeeld moeten we het project zelf instellen voor de MAX78000FTHR-kaart. In dit geval moeten we naar de C/C++ Build-instellingen en het Build command invoeren. Voer in: make -r BOARD=FTHR_RevA ECLIPSE=1 -j8 "" en voer instellingen in zoals in figuur 30.

Nu kunt u de kws20_demo bouwen voor de MAX78000FTHR. Als alles is gecompileerd, kunnen we de code uploaden en debuggen. Gebruik weer putty als seriële terminal. Als het goed is, ziet u dan de herkende woorden zoals in figuur 31.

Zet het zelf getrainde neurale netwerk op zijn plaats

De training die we hebben gedaan in het eerste deel van deze serie, heeft een neuraal netwerk opgeleverd, dat we rechtstreeks in dit Eclipse-project kunnen zetten. We moeten cnn.h, cnn.c en weights.h uit ons getrainde project naar het kws20_demo-project kopiëren, waarbij de huidige files worden overschreven. Na een clean end build kunnen we het nieuwe neurale netwerk testen op de MAX78000. Als de code is geüpload, moet het sleutelwoord HAPPY worden herkend. Het resultaat ziet er dan uit als in figuur 32.
En als u zich afvraagt, waarom we DOWN als uitkomst krijgen, moet u even in de code kijken.

In main.c ziet u op regel 136 (figuur 33) een const char keywords[NUM_OUTPUTS][10] waar we een array van strings opslaan.

Als u nu kijkt in figuur 34, ziet u dat we de te trainen sleutelwoorden voor het neurale netwerk hebben veranderd en de woorden in het array in main.c komen daarmee niet overeen.

Dat komt door de manier waarop we de herkende woorden van de CNN-accelerator krijgen. Voor ieder woord dat we hebben getraind, geeft de accelerator een index en een waarschijnlijkheid terug. Om dus de juiste output te krijgen, moeten we zorgen dat de index van de sleutelwoorden in het array overeenkomt met de index van de woorden in ons neurale netwerk.

Als de nieuwe sleutelwoorden op de juiste plek staan, ziet de code er uit als in figuur 35.

En als we nu HAPPY roepen, zien we een output zoals in figuur 36.

Dit deel van de code werkt dus. Maar we hebben ook een display aangesloten waar nog niets op te zien is. We kunnen het gemakkelijk laten werken, door gewoon #define ENABLE_TFT toe te voegen op regel 73 van onze main .c en een clean build van het project te doen. Een betere manier is om in de makefile het commentaarteken van de corresponderende regel weg te halen. De meegeleverde driver werkt prima met het display en we kunnen die later gebruiken voor de koffiemachine. Het resultaat is te zien in figuur 37.

Werken met een GUI-library die bijna alles kan

We hebben nu een werkend sleutelwoordherkenningsproject dat ook output kan weergeven op een aangesloten display. We gaan geen eigen GUI-library schrijven, we gebruiken er gewoon een die al bestaat. Bij dit project gebruiken we LVGL om de gebruikersinterface te genereren. Deze bibliotheek is zeer goed porteerbaar en het is mogelijk om de gebruikte resources te minimaliseren. Zelfs met animaties en transparante effecten is niet te veel RAM-geheugen nodig. Hoe moeilijk kan het zijn om de LVGL-library toe te voegen aan het kws20_demo-project?

Omdat LVGL ook makefiles gebruikt voor het bouwen van de code, is de integratie niet zo ingewikkeld. We kopiëren de code naar een library-directory in ons project. Dat ziet er uit als in figuur 38.

Ook onze makefile moet worden aangepast zoals in figuur 39. Hiermee kan ons project LVGL bouwen en meelinken.

Om data op ons display te zetten, moet de driver een blok beelddata kunnen versturen. De beschikbare display-driver kan wel pixel voor pixel data naar bepaalde posities schrijven, maar dat zou een enorme overhead geven. Een snellere manier is om een hele rechthoek van beelddata naar het display te schrijven. Dat is geïmplementeerd voor de camera-driver, maar de manier waarop de data in deze functie wordt verwacht is niet compatibel met de manier waarop LVGL de displaydata genereert. Gelukkig bleek het niet zo moeilijk om de display-driver aan te passen met een functie die de data kan verwerken, zoals LVGL die produceert. Toen de code werkte, is die ingezonden naar de MAX78000 SDK-repository als een pull request [4]. Nu hoeft u de SDK-files niet te veranderen, en kan iedereen profiteren van het werk dat we eraan hebben gedaan. Zo kunnen de SDK en de andere onderdelen worden verbeterd.

Alles bij elkaar

We hebben nu een GUI-bibliotheek die kan werken op de MAX78000 en we kunnen sleutelwoorden detecteren. Het enige dat nog ontbreekt, is de toepassingscode. Voordat we verdergaan, moeten we even kijken hoe het herkennen van de sleutelwoorden-in zijn werk gaat. In figuur 40 ziet u de flowchart van de originele software. We willen hier aanhaken op de plaats waar woorden zijn herkend en we willen die woorden gebruiken als input voor een toestandsmachine voor onze toepassing. Die moet de GUI en het gedrag voor ons besturen. Tot nu toe ging al het coderen volgens plan.

Bij het herkennen van sleutelwoorden is de verwerking van de audiodata essentieel. Als we te veel tijd gebruiken voor andere taken, worden de sleutelwoorden misschien niet herkend. Dat kan gebeuren als we audio-samples verliezen wanneer de inputdata niet snel genoeg wordt verwerkt. En dat is precies wat er gebeurde, toen we de eerste versie van de koffiemachine gingen testen. Dus de eerste flowchart in figuur 41 is niet bruikbaar. Maar als de timing van het audiogedeelte kritiek is, kunnen we dan niet de GUI overbrengen naar de RISC-V-kern? Die is ruimschoots krachtig genoeg om de GUI te draaien. En de LVGL is daar ook helemaal op zijn plaats, omdat die is ontworpen om te werken in low power-mode.

Er is een RISC-V-core

De RISC-V-kern is hiervoor ideaal, want hij kan de GUI prima draaien en heeft genoeg power om alle datatransfer voor de LVGL op zich te nemen. Helaas is er toch een probleem. In de user guide van de MAX78000 staat te lezen welke periferie de RISC-V kan gebruiken. Tussen de regels door is daaruit af te leiden dat de RISC-V-core geen toegang heeft tot de AHB-periferie zoals SPI0 en de CNN-FiFo. Dat stelt ons voor een probleem, want het display en enkele andere periferie-elementen, zoals de SD-interface en het SPI RAM-geheugen zijn aangesloten op SPI0. Dat betekent in ons geval, dat we de GUI niet 100% zonder de Cortex-M4 kunnen laten werken. Daar komt nog bij dat de debugger niet verbonden is met de RISC-V-kern, we kunnen daarmee alleen de code op de Cortex-M4 debuggen. We gaan in dit artikel niet door op de dual core-aanpak. Misschien komt dat nog eens in een toekomstig artikel. Figuur 42 geeft een wat duidelijker beeld van wat we kunnen aansturen.

Met het nu beschikbare dual core-voorbeeld verliest u ook de mogelijkheid om te debuggen op de RISC-V-kern en op de Cortex-M4-kern. Dat heeft te maken met de manier waarop de gecombineerde executable op het ogenblik wordt gegenereerd. Maxim zou dat in de toekomst moeten verbeteren en waarschijnlijk gaan ze dat ook wel doen.

Toch een koffiemachine

Omdat we de RISC-V niet konden gebruiken, moesten we het programmaverloop gaan aanpassen. Het nieuwe flowdiagram is te zien in figuur 43.

De GUI wordt nu alleen geüpdate op momenten waar verstoring van de audioverwerking minder waarschijnlijk is. De definitieve code is te downloaden van Elektor’s GitHub-pagina. Daar is meer in detail te zien hoe alles in zijn werk gaat. Als u zelf projecten doet, let dan altijd goed op de tijdkritische dataflow.

De koffiemachine luistert nu naar de naam HAPPY en stelt enkele vragen voordat hij koffie serveert. De vragen zijn eenvoudig met YES of NO te beantwoorden, dus we gebruiken maar een klein deel van de getrainde woorden. Er is ook nog geen STOP geïmplementeerd. Dat zou heel handig zijn als de beker te vol wordt. Dit is maar een voorbeeld, het is nog lang niet perfect. Voor gebruik in een productie-omgeving, zou er nog heel wat werk gedaan moeten worden aan de code en de interne dataflow.

Een eerste MAX78000-project

U kunt uw eerste HelloWorld vrij snel gedaan hebben. En met de juiste aanwijzingen hoeft een aangepaste sleutelwoordherkenningsdemo ook niet veel tijd te kosten. Op dit moment betekent AI doen met een MAX78000 dat u te maken gaat krijgen met documentatie die in de loop der tijd wordt verbeterd. U kunt wat fouten en ontbrekende delen tegenkomen in de SDK. Vergeet niet dat de SDK en de documentatie nog op verschillende punten in ontwikkeling zijn.

Met de MAX78000FTHR krijgt u een goedkoop tool om in te stappen in de wereld van AI op embedded apparaten. Maxim heeft een geweldige prestatie geleverd door een convolutioneel neuraal netwerk accelerator te integreren in een chip die kan werken met weinig energie. Als u meer tips en trucs wilt, ga dan naar de Elektor Labs pagina’s en maak gebruik van de commentaarfunctie.

Een MAX78000-ontwerpwedstrijd voor AI-pioniers

Als u van uitdagingen houdt, dan hebben we er hier een voor u. U kunt deelnemen aan de Maxim Integrated MAX78000 AI Design Contest (powered by Elektor) en kans maken om een idee aan te leveren voor een toepassing van de MAX78000. Uitgerust met een MAX78000-kaart kunt u een project ontwikkelen, uw ervaring delen met ons publiek en meer ervaring opdoen met AI. Dit is uw kans om een ware pionier te zijn. Grijp deze kans aan om kennis te vergaren in een veld waar nog niet veel embedded ontwikkelaars hebben gecodeerd: waar embedded en AI samengaan. Ga naar de wedstrijdpagina, elektormagazine.com/ai-contest-max78000,  voor meer informatie. Als u tijdens de wedstrijd vragen of problemen hebt, kunt u ook één van de Maxim-engineers vragen om ondersteuning. Dat zal u helpen om niet vast te lopen bij de creatie van uw project.

Wensen voor toekomstige verbeteringen

Voor de nabije toekomst hopen we dat er meer documentatie over de RISC-V-kern komt en meer voorbeeldcode. Ook de onmogelijkheid voor de RISC-V-kern om belangrijke periferie aan te sturen moet duidelijker onder de aandacht worden gebracht. En andere beperkingen bij de combinatie van beide processorkernen zouden een eigen hoofdstuk moeten krijgen in het datasheet.

Bij de codevoorbeelden zouden we graag zien hoe de DMA-engine te gebruiken is in zo weinig mogelijk stappen. Zelfs al kunnen we geen rechtstreekse toegang tot de SPI0-periferie krijgen, met de DMA-eenheid zou dat toch moeten kunnen. Dat zou een manier geven om de SPI0 zelfs vanuit de RISC-V-kern te gebruiken. Ook wat eenvoudige codevoorbeelden over hoe een interrupt-handler voor de Cortex-M4 en de RISC-V kan worden geschreven zou de gebruikersvriendelijkheid ten goede komen. En als Maxim toch bezig is, dan zou een dual-core HelloWorld, met debuggen op de Cortex-M4 en code uitvoeren op de RISC-V een mooi beginpunt zijn. Voor die laatste wens hebben we zelf al wat ideeën, maar we zijn niet zeker of die passen in de plannen van Maxim.

En voor de IDE, natuurlijk is dit wishful thinking, maar zou er ook een integratie in PlatformIO voor Visual Studio-code kunnen komen? Of tenminste officiële ondersteuning voor Linux. Voor het trainen van onze neurale netwerken verdient een Linux-systeem echt de voorkeur, waarom kunnen we dan niet ook de softwareontwikkeling voor de MAX78000 op Linux doen?

Maximaal profijt van AI

TDe MAX78000 geeft u een doorkijkje naar de toekomst en brengt AI naar de wereld van embedded apparaten met beperkte resources. Als u graag met bleeding-edge apparaten werkt, dan is dit echt iets voor u. Voor maar €40 is dit een betaalbare instap in het veld van AI en neurale netwerken. De hardware is heel interessant, maar wees erop voorbereid dat sommige documentatie nog verbeterd moet worden. Als embedded ontwikkeling nieuw voor u is, kan het even duren, voordat u goed met de MAX78000 overweg kunt en gaat inzien welke mogelijkheden die biedt. Maar laat u niet afschrikken door een mooie uitdaging voor ontwikkelaars. Ik ben benieuwd wat Maxim in de komende weken en maanden gaat verbeteren. Misschien krijgen we verbeterde documentatie en een hoofdstuk voor de RISC-V-kern.

Met een MAX78000, wat creativiteit, en wat doorzettingsvermogen, zult u zeker met innovatieve projecten komen in de nabije toekomst. Ik wil u aansporen om uw vaardigheden op de proef te stellen door uw projecten in te zenden in de Maxim Integrated MAX78000 AI Design Contest!

Opmerking van de auteur: Bij het schrijven van dit artikel heb ik contact gehad met de engineers van Maxim Integrated.

 

---

Vragen of opmerkingen?
Als u technische vragen of opmerkingen hebt over dit artikel, stuur dan een email naar de auteur via mathias.claussen@elektor.com of neem contact op met Elektor via editor@elektor.com.