Zie ook FPGA's versus microcontrollers

Snelle beeld- of videoverwerking is een goed voorbeeld. Of het verwerken van 'beelden' die niet zomaar optische beelden zijn, zoals radar- of lasersystemen.

Het belangrijkste om te overwegen zijn de vereisten voor doorvoer en latentie . Een microcontroller kan een interrupt (zeer ruwweg) eenmaal per microseconde bedienen. Het kan slechts één interrupt tegelijk bedienen. Als u het op een uitgebreide manier moet verwerken, beperkt dat het aantal dat u in een bepaalde tijd kunt bedienen.

Met een FPGA kunt u over het algemeen onmiddellijk reageren op een invoergebeurtenis. (nou ja, op de volgende klokcyclus). U kunt veel verwerkingseenheden parallel hebben. Als je weet dat je filter 20 cycli in beslag neemt, is dat volledig onafhankelijk van wat er ook gebeurt.

Zeer parallelle, integer-intensieve berekeningen werken het beste op FPGA's, vooral als er complexe gegevensafhankelijkheden zijn. Ze hebben echter niet veel intern geheugen; je kunt wat DRAM aan de zijkant toevoegen, maar dit gaat ten koste van de latentie.

Misschien wil je er ook een voor de randapparatuur, of wil je een of andere snelle digitale bus spreken. Je kunt HDMI niet in of uit een microcontroller knallen. Je kunt er geen PCI-kaart omheen bouwen.

Nou, ik bewerk real-time HD-video in FPGA's. Een deel van wat ik doe, kan worden gedaan in een GPU-chip, maar niet op een microcontroller of DSP. De FPGA is flexibeler.

Veel systemen combineren FPGA's en MCU's / DSP's om het beste van twee werelden te krijgen. Een project waar ik binnenkort aan werk, betreft objectherkenning in een videostream. De voorbereidende stappen (ruisverwijdering, normalisatie, randdetectie, etc.) kunnen het beste worden gedaan in de FPGA, maar de hogere logica die beslist welke low-level features deel uitmaken van de objecten die worden herkend, kan het beste worden gedaan op een CPU (ofwel binnen of buiten de FPGA).

Uiteindelijk zul je op beide gebieden vertrouwd willen zijn, dus het is eigenlijk gewoon de vraag welke je het eerst doet.

Kortom, FPGA's zijn goed waar u een beetje verwerking van veel gegevens moet uitvoeren, en CPU's zijn goed wanneer u veel gegevens moet verwerken.

Een HDMI videostream is veel data. Het kan worden gedaan door een CPU, GPU of ASIC in de algemene videobehuizing, maar als je er wat werk aan moet doen (bijvoorbeeld een overlay toevoegen), kun je een FPGA kiezen.

Een audiostream bevat niet veel gegevens, maar als je er spraakherkenning op moet uitvoeren, geef je de voorkeur aan een CPU boven een FPGA.

Hoewel je softwaregedefinieerde radio kunt doen in een CPU kun je gemakkelijker een veel groter deel van het spectrum aan met een FPGA dan met een CPU.

Hoewel je een toetsenbordcontroller zou kunnen maken van een FPGA, wordt een microcontroller goedkoper, minder stroom verbruiken en gemakkelijker geavanceerde toetsenbordsoftware (macro's, gamefuncties, opnieuw toewijzen) te ontwikkelen voor dan een FPGA.

Natuurlijk kun je alles in elk ervan doen, met afwegingen, maar als je als u bedreven bent in beide, kunt u de afwegingen beter afwegen en de hogere kosten van onderdelen of ontwikkelingstijd vermijden die u zou oplopen bij het kiezen van de verkeerde oplossing voor een bepaald probleem.

Over het algemeen gebruikt u een microcontroller wanneer deze de klus kan klaren. Een microcontroller voert de logica uit door opeenvolgende instructies uit te voeren.

Een FPGA voert de logica uit omdat de hardware-poorten logisch zijn bedraad om dit te doen. Dat betekent dat het dingen veel sneller kan doen, en een aantal van dergelijke dingen tegelijkertijd. Het is over het algemeen ingewikkelder en moeilijker om dezelfde logica te creëren en debuggen in een FPGA als in een micro, dus je gebruikt een FPGA wanneer de extra snelheid en lage latentie nodig is.

Een toepassing die ik nog niet heb genoemd, is micro-elektronische engineering of het ontwerp van MCU / CPU / GPU / ASIC-chips zelf. Deze chips worden vaak geprototypeerd door ze in HDL te ontwerpen en vervolgens in een FPGA te implementeren. Dit maakt ze gemakkelijker, goedkoper en sneller te testen en aan te passen voordat ze eindelijk de HDL gebruiken om de lay-out te creëren die nodig is voor de productie van het daadwerkelijke silicium in de processor of ASIC.

Een commentator noemde dit in de vorm van soft-core chips (hoewel ze een typfout hadden en ze sort-core chips noemden). U kunt een ARM / 8051 / enz. Nemen. soft-core en welke soft-core randapparatuur je ook nodig hebt en ontwerp in wezen je eigen aangepaste microcontroller geïmplementeerd in een FPGA. Aangenomen dat u over de middelen beschikt, zou u dit in uw eigen microcontroller kunnen laten verwerken.

Als dit soort applicatie iets is dat u interesseert, kijk dan eens naar OpenCores om te zien wat mogelijk is.

We bouwen radarinstrumenten (meestal synthetisch diafragma) die op grote schaal FPGA's gebruiken. Ik denk niet dat een microcontroller gemakkelijk aan de strakke timingvereisten kan voldoen. Ik geloof dat veel LIDAR-instrumenten ook FPGA's gebruiken.

In principe heeft alles waar timingvereisten in de nanoseconden liggen, FPGA's of ASIC's nodig.

Een microcontroller kan gegevens alleen opeenvolgend verwerken, één instructie per keer, dus als je een erg dure operatie hebt, wil je misschien je berekening op de een of andere manier parallel maken. Het verwerken van audio / video is hier een goed voorbeeld van. Om aan die behoefte te voldoen, zijn er digitale signaalprocessors ontwikkeld die bepaalde taken parallel kunnen uitvoeren, maar die niet voldoende gegeneraliseerd zijn om een ​​willekeurig algoritme te implementeren, dus deze processors zullen voor veel taken werken, maar niet voor alle taken. Een FPGA is een algemeen stuk hardware. Aangezien u in wezen het ontwerp van uw eigen stuk hardware kunt definiëren en het vervolgens naar de FPGA kunt downloaden, kan het elk denkbaar algoritme implementeren, mits het voldoende middelen heeft om dit te doen.

Een concreet voorbeeld : Ken Perlin stelt een hardware-implementatie voor van zijn simplex-ruisalgoritme. Het kan relatief snel worden gedaan met een traditionele CPU of microcontroller, maar kan supersnel worden gemaakt met aangepaste hardware. Aangezien ik betwijfel of een DSP hiervoor zou werken, zou het gemakkelijkste een FPGA zijn. De moeilijke manier is natuurlijk om een ​​echte fysieke chip voor je te laten maken, wat ongelooflijk duur is. http://www.csee.umbc.edu/~olano/s2002c36/ch02.pdf

Een antwoord dat hier niet is, is data-acquisitie. Als je een ADC wilt gebruiken om een ​​signaal (bijvoorbeeld een RF-signaal) van 200 MHz te bemonsteren en te verwerken, zal een microcontroller de gegevens simpelweg niet snel genoeg kunnen verwerken. Een typisch DAQ FPGA-bord zal een DDC ontvangen, filteren, uitvoeren en de RF-gegevens met een veel lagere frequentie naar een CPU sturen. FPGA's kunnen ook FFT's en kanalisatiebewerkingen uitvoeren op het RF-spectrum.

Een andere toepassing is pakketroutering, bijvoorbeeld een apparaat dat een (of meerdere) XAUI ethernet-interfaces beheert die elk met 10 Gb / s werken. Deze FPGA's filteren en plannen pakketwachtrijen voor verschillende bestemmingen. Een microcontroller / conventionele CPU zou de bandbreedte van deze interfaces niet aankunnen.

De fundamentele reden dat microprocessors en microcontrollers zo veel kunnen doen met een relatief kleine hoeveelheid schakelingen, is dat als de micro slechts 1.000 keer per seconde een complexe berekening hoeft uit te voeren en het 20 microseconden duurt (dus de micro werkt aan de berekening 2% van de tijd), kan de meeste hardware die voor die berekening zou worden gebruikt de resterende 98% van de tijd voor andere doeleinden worden gebruikt. Microcontrollers kunnen dus een bescheiden hoeveelheid hardware gebruiken om een ​​zeer groot aantal verschillende functies uit te voeren, zolang de functies niet tegelijkertijd nodig zijn.

De hoeveelheid schakelingen in een FPGA zal vaak vergelijkbaar zijn met die van een microcontroller (FPGA's variëren in grootte met enkele ordes van grootte, net als microcontrollers, maar de bereiken overlappen). In tegenstelling tot een microcontroller, waarvan de circuitelementen op een zodanige manier zullen worden verbonden dat het gebruik ervan voor veel niet-gelijktijdige taken wordt vergemakkelijkt, zal een FPGA worden ontworpen om delen van zijn circuits "fulltime" aan verschillende taken te wijden. Als je een microcontroller het aantal pulsen wilt laten tellen dat op elk van de 100 ingangen optreedt, zou het beperkt zijn tot het tellen van pulsen die zo langzaam waren dat de controller ze opeenvolgend, afzonderlijk zou kunnen verwerken - als alle ingangen zouden kunnen pulseren onafhankelijk zou zelfs een snelle controller moeite hebben om meer dan een paar duizend pulsen per seconde per ingang te tellen. Als iemand daarentegen een FPGA zou gebruiken om de klus te klaren, zou deze een tellerschakeling aan elke ingang kunnen toewijzen en zonder problemen elke puls van elke ingang kunnen tellen, zelfs als elke ingang onafhankelijk tientallen miljoenen keren per seconde pulseert. / p>

FPGA implementeert een hardware logisch circuit of functioneel blok, in theorie kan het alles implementeren wat je maar wilt. En die blokken worden gelijktijdig uitgevoerd, het is onwaarschijnlijk dat een conventionele MCU regel voor regel programmeert. Daarom zijn de prestaties van FPGA veel beter dan MCU, maar het vereist een kennis van HDL- of VHDL-taal die verschilt van programmeertaal in termen van syntaxis, stijl en concept.

Zoals ik al zei, kan het wat dan ook, daarom is het niet verwonderlijk dat u een MCU met functioneel blok kunt implementeren om uw ontwikkeling met hoge prestaties te vergemakkelijken. Xilinx biedt u een functioneel blok om MCU in te bouwen, genaamd Microblaze. Daarom kunt u ook een embedded systeemprogramma uitvoeren in FPGA.

U wilt bijvoorbeeld een programmeerbare audio-equalizer implementeren en het zwaarste rekengedeelte zoals FFT kan per functioneel blok worden geïmplementeerd in plaats van lopende softwareberekening. Maar enkele van de eenvoudige taken, zoals LCD, I / O-interface, kunnen door MCU worden gedaan. En FPGA stelt u in staat om tegelijkertijd MCU ingebed systeem en hardware functionele blokken te hebben.