Pak computerintensieve projecten aan met de ShieldBuddy

Veel hobbyisten, makers en doe-het-zelvers gebruiken Arduino microcomputer ontwikkelborden om hun projecten te controleren en te besturen. Dat geldt ook voor een toenemend aantal professionele ingenieurs die deze borden kunnen gebruiken als evaluatie- en prototypeplatforms om de ontwikkeling te versnellen en de kosten te verlagen die gepaard gaan met de evaluatie van geïntegreerde schakelingen (IC's), sensoren en randapparatuur. Zoals besproken in Arduino BOB's gebruiken om snel sensoren en randapparatuur te evalueren, kunnen deze ingenieurs werken in kleinere teams met strakkere time-to-market (TTM) beperkingen. Als zodanig moesten zij meerdere engineeringdomeinen en -taken omvatten, terwijl zij manieren moesten vinden om de evaluatie van componenten te versnellen en de kosten ervan te verlagen.

Eén oplossing is het gebruik van Arduino's samen met open-source hardware in de vorm van sensor- en perifere breakout boards (BOB's) in combinatie met open-source software met bijbehorende bibliotheken en voorbeeldprogramma's. Hoewel er een grote verscheidenheid is aan Arduino-borden om aan een reeks verwerkings- en geheugenvereisten te voldoen, kunnen sommige berekeningen toch beter worden uitgevoerd met een drijvende-kommereenheid (FPU) om de hoofdprocessor niet te vertragen. Dit probleem is binnen het Arduino-ecosysteem aangepakt door de ShieldBuddy.

Dit artikel zal verschillende Arduino verwerkingsplatform opties beschrijven en waarom FPU vermogen zo belangrijk is voor vele toepassingen. Vervolgens wordt de ShieldBuddy geïntroduceerd, een bord dat qua afmetingen vergelijkbaar is met Arduino-borden, maar dat drie onafhankelijke 32-bit verwerkingskernen heeft, elk draaiend op 200 MHz en elk met zijn eigen FPU. Het artikel zal het programmeermodel beschrijven en laten zien hoe de op Eclipse gebaseerde programmeeromgeving en de ondersteuning van Arduino's geïntegreerde ontwikkelomgeving (IDE) zowel doe-het-zelvers als ontwerpers in staat stelt er snel mee aan de slag te gaan.

Arduino voor nieuwkomers en professionals

Nieuwkomers in het Arduino-universum beginnen meestal met de Arduino Uno Rev3 (Figuur 1), die is gebaseerd op de 8-bit ATmega328P microcontroller met een snelheid van 16 megahertz (MHz). Dit bord heeft slechts 32 kilobytes (Kbytes) flash (programma) geheugen, 2 Kbytes SRAM, 14 digitale input/output (I/O) pinnen, en zes analoge input pinnen. Zes van de digitale pennen kunnen pulsbreedtemodulatie (PWM) uitgangen leveren, en de analoge pennen kunnen desgewenst ook als digitale I/O pennen worden gebruikt.

Figuur 1: Het Arduino Uno Rev3-ontwikkelingsbord is gebaseerd op de 8-bit ATmega328P microcontroller die werkt op 16 MHz. (Afbeelding bron: Arduino.cc)

Het oppervlak van de koppen van de Arduino Uno Rev3, met 14 digitale I/O-pinnen, 6 analoge ingangspinnen, en diverse voedings-, massa- en referentiepinnen, vormt de basis voor een enorm ecosysteem van dochterborden, shields genaamd.

Veel gebruikers van de Uno Rev3 stappen vervolgens over op het Arduino Mega 2560 Rev3 bord (figuur 2), dat is gebaseerd op de 8-bit ATmega2560 microcontroller die draait op 16 MHz. Dit bord heeft 256 Kbytes flash-geheugen en 8 Kbytes SRAM. De voetafdruk van zijn headers betekent dat hij dezelfde shields kan ondersteunen als de Uno, maar dankzij extra headers passen er 54 digitale I/O-pinnen en 16 analoge ingangspinnen in. In dit geval kunnen 15 van de digitale pennen PWM-uitgangen leveren, en - nogmaals - kunnen de analoge pennen ook worden gebruikt als digitale I/O-pinnen, indien nodig.

Figuur 2: Het Arduino Mega 2560 Rev3 ontwikkelingsbord is gebaseerd op de 8-bit ATmega2560 microcontroller die werkt op 16 MHz. Door de afmetingen van zijn headers kan hij dezelfde shields ondersteunen als de Arduino Uno, maar hij heeft ook extra headers, waardoor hij in totaal 54 digitale I/O-pinnen en 16 analoge ingangspinnen heeft. (Bron afbeelding: Arduino)

Naast de beperkingen opgelegd door een 8-bit datapad en een 16 MHz klok, bevatten noch de Arduino Uno noch de Arduino Mega microcontrollers een FPU, wat betekent dat alle berekeningen met floating-point waarden deze processoren dramatisch vertragen.

Voor gebruikers die nog meer verwerkingskracht wensen, is de volgende stap de Arduino Due (figuur 3), die een vergelijkbare fysieke voetafdruk heeft als de Arduino Mega, maar die is gebaseerd op de 32-bit Atmel/Microchip Technology SAM3X8E Arm® Cortex®-M3 processor met een snelheid van 84 MHz. Dit bord heeft 512 Kbytes flash-geheugen, 96 Kbytes SRAM, 54 digitale I/O-pennen, 12 analoge ingangspennen en twee analoge uitgangspennen die worden aangestuurd door digitaal-naar-analoog-converters (DAC's). In dit geval kunnen slechts 12 van de digitale pinnen PWM-uitgangen leveren, en - nogmaals - de analoge pinnen kunnen ook worden gebruikt als digitale I/O-pinnen indien nodig. Helaas, net als de Arduino Uno en Mega, bevat de processor van de Arduino Due geen FPU.

Figuur 3: Het Arduino Due ontwikkelingsbord is gebaseerd op de 32-bit Atmel SAM3X8E Arm Cortex-M3 processor met een snelheid van 84 MHz. De voetafdruk van zijn headers is identiek aan die van de Arduino Mega. (Afbeelding bron: Arduino.cc)

Veel gebruikers - zowel hobbyisten als professionals - genieten van het hoge aantal pinnen van de Arduino Mega en Arduino Due ontwikkelboards. Maar zelfs de 32-bit processor van de Arduino Due met een snelheid van 84 MHz kan ontoereikend zijn voor sommige rekenintensieve taken. Evenzo kunnen de 512 Kbytes flashgeheugen en 96 Kbytes SRAM van de Due onvoldoende zijn voor omvangrijkere programma's die met grote hoeveelheden gegevens werken.

Hoewel microcontrollers in staat zijn om steeds grotere hoeveelheden gegevens te verwerken, kunnen sommige berekeningen beter worden uitgevoerd met FPU's voor een grotere efficiëntie en een lagere latentie.

Wat zijn FPU's en waarom zijn ze nodig?

De redenen waarom FPU's nuttig zijn, gaan terug tot hoe computers met getallen omgaan. De eenvoudigste manier om getallen in computers weer te geven is door gehele getallen (hele getallen) te gebruiken. Bovendien is het uitvoeren van berekeningen met gehele getallen rekenkundig goedkoop. Gehele getallen zijn echter eindig van aard en kunnen geen groot dynamisch bereik tot uitdrukking brengen.

Dit is problematisch voor ingenieurs en wetenschappers, omdat zij vaak extreem grote en kleine waarden in dezelfde berekening moeten gebruiken. Natuurkundigen kunnen bijvoorbeeld berekeningen hebben waarin de numerieke waarden van de lichtsnelheid (300.000.000) en Newtons gravitatieconstante (0,00000000006674) worden gebruikt. Evenzo hebben ingenieurs waarden nodig met een groot dynamisch bereik voor taken als digitale signaalverwerking (DSP) en voor gebruik in kunstmatige intelligentie- (AI) en machine-leertoepassingen (ML).

De oplossing is het gebruik van floating-point numerieke weergave, waarbij de decimale punt kan "zweven" ten opzichte van de individuele cijfers van het getal, waardoor een fijnere numerieke "resolutie" kan worden bereikt. Het probleem is dat, hoewel een 32-bit floating-point waarde evenveel geheugen inneemt als een fixed-point 32-bit geheel getal, het uitvoeren van berekeningen met floating-point waarden aanzienlijk meer rekenkracht vergt.

Indien de processor wordt verplicht berekeningen met drijvende komma uit te voeren met standaard fixed-point hardware, zal dit de prestaties van die processor dramatisch beïnvloeden. De oplossing is de processor uit te rusten met een speciale FPU. Hierdoor kunnen verfijnde floating-point bewerkingen worden uitgevoerd met zeer weinig klokcycli.

Dit is waar de ShieldBuddy in het spel komt.

ShieldBuddy brengt FPU's en hoge prestaties naar Arduino ecosysteem

Een relatief nieuwe speler in de Arduino-compatibele ruimte, Infineon Technologies' KITAURIXTC275ARDSBTOBO1, of ShieldBuddy (afbeelding 4), is een ingebed evaluatiebord voor Infineon's TC275T64F200WDCKXUMA1 TC275 AURIX TC2xx TriCore 32-bit microcontroller.

Figuur 4: De ShieldBuddy TC275 is uitgerust met de Infineon TC275 32-bit multicore processor op een bord met dezelfde voetafdruk als de Arduino Mega en Arduino Due, waardoor het compatibel is met veel van de beschikbare toepassingsschilden.(Afbeelding bron: Hitex.com)

Met een vergelijkbare fysieke voetafdruk als de Arduino Mega en Arduino Due, is de ShieldBuddy compatibel met veel van de toepassingsschilden, maar hij onderscheidt zich door zijn gebruik van de TC275 met zijn drie onafhankelijke 32-bit kernen, die elk op 200 MHz draaien en elk hun eigen FPU hebben. Verder heeft de ShieldBuddy 4 megabytes (Mbytes) flashgeheugen (8x dat van de Arduino Due en 16x dat van de Arduino Mega) en 500 Kbytes RAM (5x dat van de Arduino Due en 62x dat van de Arduino Mega).

Een manier om dit te bekijken is dat de kern van de Arduino Mega slechts ongeveer zestien 8-bit instructies per microseconde (µs) kan verwerken. Ter vergelijking: de kernen van de TC275 hebben elk een cyclustijd van 5 nanoseconden (ns), wat betekent dat elke kern doorgaans zo'n 150 tot 200 32-bit instructies/µs kan uitvoeren. Aangezien elk van de processorkernen van de ShieldBuddy zijn eigen FPU heeft, kan het bord floating-point berekeningen uitvoeren met weinig of geen prestatieverlies.

Ontwikkelen met de ShieldBuddy

Bij het werken met de ShieldBuddy zullen professionele software ontwikkelaars wellicht een Eclipse IDE willen gebruiken, terwijl hobbyisten en makers wellicht de voorkeur geven aan de vertrouwde Arduino IDE. Beide opties worden ondersteund.

Gebruikers van de Arduino zullen bekend zijn met het feit dat elke sketch (programma) twee standaardfuncties moet hebben: setup(), die eenmalig wordt uitgevoerd, en loop(), die steeds opnieuw wordt uitgevoerd. Gebruikers kunnen ook hun eigen functies creëren.

De drie kernen van de ShieldBuddy worden Core 0, Core 1, en Core 2 genoemd. In het geval van de Arduino IDE kunnen de meeste bestaande sketches zonder aanpassing worden gecompileerd voor gebruik op de ShieldBuddy. Standaard zullen de setup() en loop() functies - samen met alle gebruikersfuncties die ze aanroepen - gecompileerd worden om op Core 0 te draaien.

Bij het maken van een nieuw programma kan de gebruiker hetzelfde effect bereiken door deze functies setup0() en loop0() te noemen. De gebruiker kan ook setup1() en loop1() functies creëren, die - samen met alle door de gebruiker gecreëerde functies die ze aanroepen - automatisch gecompileerd zullen worden om op Core 1 te draaien. Op dezelfde manier zullen setup2() en loop2() functies, samen met alle functies die ze aanroepen, automatisch gecompileerd worden om op Core 2 te draaien.

Standaard draait elke core onafhankelijk, wat betekent dat het mogelijk is om drie totaal verschillende programma's tegelijkertijd te laten draaien op de ShieldBuddy. Dit gezegd zijnde, kunnen de kernen ook onderling communiceren met behulp van technieken zoals gedeeld geheugen. Bovendien kan elke kern zachte interrupts in de andere kernen triggeren.

Conclusie

Het open source Arduino-concept is een enorm succes gebleken, en de daaruit voortvloeiende hardware- en software-ecosystemen zijn uitgegroeid tot honderden schilden en duizenden bibliotheken en toepassingen.

Hoewel vroege Arduino ontwikkelboards, zoals de 8-bit, 16 MHz Arduino Uno en Arduino Mega enigszins beperkt waren, zijn meer recente implementaties zoals de 32-bit, 84 MHz Arduino Due aanzienlijk krachtiger. Toch hebben veel gebruikers meer programmeerruimte (flash), meer dataruimte (SRAM), en meer rekenkracht nodig dan een traditionele Arduino kan bieden.

Met 4 Mbytes flashgeheugen, 500 Kbytes SRAM, en drie onafhankelijke 32-bit processorkernen die draaien op 200 MHz, elk met zijn eigen FPU, tilt de ShieldBuddy het Arduino-concept naar een heel nieuw niveau, waardoor het interessant is voor zowel extreme doe-het-zelvers als professionele ingenieurs.

Aanbevolen lectuur:

1. Elektronica onderwijzen aan absolute beginners
2. Snel en eenvoudig FPGA's toepassen met de Arduino MKR Vidor 4000
3. Word lid van de Maker World met een eenvoudig te gebruiken Arduino Starter Kit