EUR | USD

Starten met op RISC-V gebaseerde microcontrollers

Door Jacob Beningo

Bijgedragen door De Noord-Amerikaanse redacteurs van Digi-Key

Ontwerpers staan voortdurend onder druk om te innoveren en tegelijkertijd hun intellectueel eigendom (IP) geheim te houden, en tevens het energieverbruik en de kosten te minimaliseren. Daarom is de RISC-V open-source hardware-instructiesetarchitectuur (ISA) interessant geworden voor ontwerpers van processoren voor mobiele toepassingen. Nu RISC-V een optie is voor microcontrollers, hebben ontwerpers van embedded systemen en consumentenapparaten een springplank nodig om snel hun eigen RISC-V ontwerpen te gaan bouwen.

Zo'n springplank is het FE310 LoFive-R1 ontwikkelboard van GroupGets LLC. Voordat we de LoFive-R1 introduceren, gaan we in dit artikel in op RISC-V en waarom een ontwikkelaar daarmee zou willen werken. Vervolgens beschrijven we de LoFive-R1 en laten we zien hoe met het ontwikkelen van toepassingen kan worden begonnen, onder meer met enkele tips en trucs.

Wat is RISC-V?

RISC-V is een project voor een open-source hardware-instructiesetarchitectuur dat zijn oorsprong aan de University of California Berkeley in 2010. Voor het creëren van de RISC-V architectuur bestonden meerdere redenen:

  • De behoefte aan een open-source instructiesetarchitectuur (ISA) die in universiteitsprojecten en door studenten zou kunnen worden gebruikt
  • Een middel om ontwerpexpertise bij het ontwikkelen van ISA's te delen
  • Geen licentiegelden aan chipmakers hoeven betalen en kostenbesparing
  • De ontwerpgegevens van een architectuur (het IP van een bedrijf) beschermen om concurrerend te blijven

RISC-V is, vanuit een ontwerper gezien, een vereenvoudigde architectuur die ontwikkeld is voor snelle verwerkingen bij een laag energieverbruik. Hierdoor zijn op RISC-V gebaseerde chips niet alleen geschikt voor de academische wereld, maar ook voor commerciële toepassingen. De RISC-V Foundation heeft zoveel interesse gekweekt dat er inmiddels ca. 325 leden zijn, waaronder bedrijven als Si-Five, Google, Microchip Technology, NVIDIA en Qualcomm.

Hoewel er veel bedrijven zijn die aan de ontwikkeling van RISC-V bijdragen, is voor de gemiddelde ontwerper de beste manier om ervaring met RISC-V te krijgen het vinden van een op een RISC-V processor gebaseerd ontwikkelboard.

Het LoFive FE310 ontwikkelboard

Zo'n ontwikkelboard is het LoFive-R1 ontwikkelboard van GroupGets LLC (Afbeelding 1).

Afbeelding van het LoFive-R1 ontwikkelboard van GroupGetsAfbeelding 1: Het LoFive-R1 ontwikkelboard bevat een RISC-V processor samen met alle benodigde ondersteunende schakelingen waarmee het ontwikkelboard een processormodule is die direct op een basisboard kan worden gesoldeerd. (Afbeelding: GroupGets LLC)

De LoFive R1 bevat om te beginnen een RISC-V processor die met een kloksnelheid tot 320 megahertz (MHz) kan werken. De processor bevat 8 kilobyte (Kbyte) eenmalig programmeerbaar (OTP) geheugen, 8 Kbyte mask ROM, 16 Kbyte instructiecache en 16 Kbyte SRAM. De processor beschikt tevens over drie onafhankelijke pulsbreedtemodulatie (PWM) controllers, SPI, I2C, UART en zelfs een QSPI flash-interface.

Verder kan het ontwikkelboard ofwel gesoldeerde headers hebben of kan het, vanwege de randconnectoren, direct op een basisboard worden gesoldeerd en als processormodule worden gebruikt. Zo wordt het een ontwikkelaar erg eenvoudig gemaakt om eigen hardware te ontwikkelen zonder de logistieke rompslomp die bij het uitbesteden van de processor hoort.

Tenslotte bevat het ontwikkelboard een QSPI flash in de vorm van een IS25LP128 flashmodule van Integrated Silicon Solution Inc (ISSI). De IS25LP128 is een 128 megabit (Mbit) 16 Mbyte flashmodule die bij SPI-bussnelheden tot 133 MHz kan werken in viervoudige I/O-modus (Afbeelding 2). De SPI flashmodule kan voor opslag worden gebruikt zodat er voldoende opslagruimte is voor de toepassing of om runtime gegevens als toepassingslogboeken op te slaan.

Schema van de ISSI 128 Mbit SPI flashmoduleAfbeelding 2: Het LoFive-R1 ontwikkelboard bevat een ISSI 128 Mbit SPI flashmodule die voor gevensopslag door de toepassing wordt gebruikt. (Afbeelding: ISSI)

Het ontwikkelboard werkt ook op een voedingsspanning van 5 volt die door een SPX3819M5 lineaire spanningsregelaar van MaxLinear naar 3,3 volt wordt geconverteerd. De spanningsregelaar zit in een SOT23-5 behuizing en kan een stroomsterkte tot 500 mA leveren. Het ontwikkelboard trekt maar weinig stroom zodat extra sensoren en apparaten kunnen worden ondersteund zonder een extra voeding toe te hoeven voegen.

Schema van de SPX3819 3,3 volt lineaire spanningsregelaar van MaxLinearAfbeelding 3: De SPX3819 3,3 volt lineaire spanningsregelaar op het LoFive-R1 ontwikkelboard levert tot 500 mA. Dit is voldoende voor zowel de schakelingen op het board als voor enkele extra apparaten zoals sensoren. (Afbeelding: MaxLinear)

Tenslotte staan alle ontwerpdetails voor het ontwikkelboard, zoals de schema's en de te gebruiken onderdelen op github. Met deze informatie is het voor ontwerpers eenvoudiger te begrijpen hoe het board werkt. Bovendien kan de informatie als leidraad worden gebruikt voor de eigen ontwikkelprojecten.

De RISC-V omgeving instellen en het ontwikkelboard programmeren

Een ontwikkelaar zal merken dat er meerdere RISC-V omgevingen beschikbaar zijn, afhankelijk van het gekozen ontwikkelboard. Het is belangrijk te realiseren dat de SDK voor RISC-V beschikbaar is voor Windows, macOS en Linux. In dit artikel laten we zien hoe het ontwikkelboard onder Linux kan worden ingesteld.

Allereerst moet de LoFive Freedom-E SDK uit git worden uitgecheckt met de volgende opdracht:

git clone –recursive https://github.com/mwelling/freedom-e-sdk.git

Ga vervolgens naar de map die door de SDK is aangemaakt met:

cd freedom-e-sdk

Er zijn twee verschillende SDK's beschikbaar voor het ontwikkelboard. De eerste wordt 'the legacy SDK' genoemd, omdat dit een oudere versie is. Gebruik de nieuwste SDK. Deze heeft een kant-en-klare omgeving inclusief OpenOCD voor debuggen. De SDK kan worden uitgecheckt met de volgende opdrachten:

git checkout lofive-r1

git submodule sync

git submodule update –init –recursive

Het ontwikkelboard kan op verschillende manieren worden geprogrammeerd. Allereerst zijn er op de processor de standaard JTAG-signalen die via de LoFive-R1 uitbreidingsconnectoren beschikbaar zijn. Ontwikkelaars kunnen elke programmeringsadapter gebruiken die JTAG ondersteund, bijvoorbeeld een SEGGER J-Link. Als de ontwikkelaar geen programmeringsadapter heeft, dan kan hij of zij ook een goedkope USB-serieel-converter gebruiken als de FT2232H-56Q Mini MDL van FTDI (Afbeelding 4). De FT2232H-56Q Mini MDL is een module die alle verbindingen en breakouts bevat die nodig zijn om het LoFive-R1 ontwikkelboard te gebruiken. De SDK gebruikt de algemene I/O op de FT2232H-56Q om de vereiste JTAG-verbindingen te realiseren voor het programmeren van de microcontroller.

Afbeelding van de FTDI FT2232H-56Q MINI MDL seriële moduleAfbeelding 4: De FT2232H-56Q MINI MDL is een goedkope seriële module die via USB rechtstreeks op een computer kan worden aangesloten en tevens op de UART op het LoFive-R1 ontwikkelboard. (Afbeelding: FTDI)

Er moeten negen verschillende verbindingen worden gemaakt tussen het LoFive-R1 ontwikkelboard en de FT2232H-56Q module (Tabel 1).

Pin op LoFive-R1 ontwikkelboard Pin op FT2232H-56Q module
+5 VIN VBS
Massa GND
TRSTN AD5
TCK AD0
TDO AD2
TMS AD3
TDI AD1
UART0.TX BD1
UART0.RX BD0

Tabel 1: Een eenvoudige tabel die kan worden gebruikt om de verbindingen tussen het LoFive-R1 ontwikkelboard en de FT2232H-56Q module te maken. (Tabel: Digi-Key Electronics)

Deze verbindingen kunnen als volgt worden samengevat:

  • Voeding en massa
  • JTAG-signalen
  • UART-signalen

De verbindingen kunnen rechtstreeks worden gemaakt of via een breadboard als de PB-83M van Global Specialties (Afbeelding 5). Zulke breadboards kunnen met banaanstekkers op twee spanningsbronnen en massa worden aangesloten om het prototypen te vereenvoudigen.

Afbeelding van het Global Specialties PB-83M breadboard met aansluitingen voor banaanstekkers

Afbeelding 5: Op de PB-83M kunnen twee spanningsbronnen en massa met banaanstekkers worden aangesloten om het prototypen te vereenvoudigen. (Afbeelding: Global Specialties)

Als u de LoFive-R1 voor het eerst gebruikt, kunt u het beste een bootloader op het board installeren. De bootloader hoeft maar één keer te worden geïnstalleerd en kan worden gebruikt om upgrades mogelijk te maken. De bootloader kan in de SDK worden aangemaakt met de volgende opdracht:

make PROGRAM=lofive-boot TARGET=lofive-r1-bootloader upload

De toepassing 'hello world' kan dan op het ontwikkelboard worden geladen met de volgende opdracht:

make PROGRAM=sifive-welcome TARGET=lofive-r1 upload

Op dat moment heeft de ontwikkelaar diens eerste RISC-V-toepassing geprogrammeerd en zijn de vervolgmogelijkheden onbeperkt.

Tips en trucs om met RISC-V te werken

De eerste stappen met RISC-V processoren zijn iets anders dan bij de standaard microcontroller ecosystemen. Hier volgen enkele tips en trucs:

  • Check eerst de LoFive-R1 SDK uit en lees dan het bestand README.md in de hoofdmap. Hierin staat nuttige informatie over de locatie van de SDK documentatie, ondersteuningspakketten voor het board en andere nuttige informatie.
  • Als een professioneel debugger als een SEGGER J-Link aanwezig is, dan kan deze worden gebruikt om toepassingen op de RISC-V processor te programmeren. J-Link biedt al sinds 2017 ondersteuning voor RISC-V.
  • Ontwikkelaars die liever een IDE gebruiken dan opdrachtregels, is de Freedom Studio voor RISC-V een op Eclipse gebaseerde IDE.

Ontwikkelaars die deze 'tips en trucs' opvolgen, zullen merken dat ze veel tijd en problemen besparen wanneer ze voor het eerst met RISC-V werken.

Conclusie

RISC-V is een interessante architectuur die geschikt kan zijn voor ontwikkelaars die een open-source hardware architectuur willen gebruiken. Er bestaan momenteel ontwikkelboards voor RISC-V processoren en, zoals we in dit artikel hebben aangetoond, is het opzetten van de ontwikkelomgeving niet veel moeilijker dan bij andere standaard microcontrollers.

Vergeet niet dat, hoewel RISC-V aantrekkelijk lijkt, het niet het rijke ecosysteem heeft dat veel bestaande microcontrollers wel hebben. Ontwikkelaars die voor RISC-V kiezen zullen minder keuze hebben aan bronnen om het zich gemakkelijk te maken. Dat compromis kan de moeite waard zijn, afhankelijk van de eindtoepassing en de voorkeuren en mogelijkheden van de ontwikkelaar.

Disclaimer: The opinions, beliefs, and viewpoints expressed by the various authors and/or forum participants on this website do not necessarily reflect the opinions, beliefs, and viewpoints of Digi-Key Electronics or official policies of Digi-Key Electronics.

Achtergrondinformatie over deze auteur

Jacob Beningo

Jacob Beningo is een embedded software consultant. Hij heeft meer dan 200 artikelen over embedded software ontwikkelingstechnieken gepubliceerd, is een veelgevraagde spreker en technische trainer en heeft drie universitaire graden, waaronder een Masters of Engineering bij de University of Michigan.

Over deze uitgever

De Noord-Amerikaanse redacteurs van Digi-Key