Vraag:
Wat is een FPGA?
zklapow
2009-12-16 07:11:45 UTC
view on stackexchange narkive permalink

Ik heb al veel mensen over FPGA's zien praten en ik weet dat het staat voor field-programmable gate array, maar hoe werkt het en wat is het doel van het gebruik van een FPGA?

Vijf antwoorden:
#1
+30
Maciek Sawicki
2009-12-16 07:37:52 UTC
view on stackexchange narkive permalink

Het zijn elektronische componenten die logica toevoegen aan uw circuits (ze lijken dus op microcontrollers). Maar de ontwerpaanpak is dan totaal anders dan bij de uC (microcontroller). In een uC kunt u het interne uC-ontwerp niet wijzigen; je kunt er alleen "klassieke" programma's op draaien. Het programmeren van FPGA's lijkt meer op het maken van nieuwe hardware. Je legt nieuwe verbindingen tussen logische poorten en creëert een nieuwe, gespecialiseerde processor. En u kunt het allemaal bij u thuis, op uw bureau en op uw pc doen.

Klinkt cool? Ja, maar er zijn enkele nadelen. Bijvoorbeeld prijs (maar ik denk dat het moeilijk is om het te vergelijken), hoger stroomverbruik en lagere kloksnelheden (maar je kunt je applicatie op een slimme manier ontwerpen en meer bewerkingen uitvoeren in één klokcyclus).

Handige links:

Voorbeeldgebruik: http://nsa.unaligned.org/

Ik zal opmerken dat veel FPGA's groot genoeg zijn om meerdere CPU-kernen te bevatten, waardoor de FPGA een volledige computer op zichzelf kan zijn.
Als een opmerking: ik denk dat lagere kloksnelheden misleidend kunnen zijn. vergeleken met een pc, ja. In vergelijking met een pic16 kunnen ze sneller zijn, maar dit hangt af van de kosten. De meeste van de goedkopere die ik heb gehad, draaien op 40 MHz, maar nogmaals, product tot productvariatie.
#2
+24
SiliconFarmer
2009-12-19 02:10:37 UTC
view on stackexchange narkive permalink

Een FPGA is letterlijk een reeks logische poorten die in het veld kunnen worden geprogrammeerd. Flip-flops, multiplexers, 4-bits opzoektabellen, enz. Die op elke gewenste manier kunnen worden aangesloten, met behulp van een C-achtige taal (Verilog).

Een uC, zoals een AVR, is ook gemaakt van vergelijkbare logische poorten, maar ze zijn geconfigureerd toen het apparaat werd gemaakt. Natuurlijk heeft het RAM en Flash, zodat je software kunt schrijven om inputs te lezen en output te besturen, maar je kunt de feitelijke opstelling van de poorten niet veranderen. De poorten zullen altijd worden gerangschikt in een ALU, een geheugencontroller, een seriële poort, enz.

Het voordeel van de uC is dat u deze in het veld (aan uw bureau) kunt programmeren, met een gemakkelijke om vertrouwde taal van hoog niveau te gebruiken, zoals C. Het probleem is dat software "traag" is. Om een ​​input een output te laten sturen, zou je in het eenvoudigste geval kunnen schrijven:

void loop () {buttonState = digitalRead (buttonPin); if (buttonState == HIGH) {
digitalWrite (ledPin, HIGH);
} else {digitalWrite (ledPin, LOW); }}

Dat zou worden omgezet in een dozijn montage-instructies, dus de lus zou ongeveer een microseconde nodig hebben om die ene output van één input te besturen. En je hebt de hele UC-chip nodig om het zo snel te doen. Natuurlijk kun je veel meer doen, maar dan zal je vermogen om die output te controleren langzamer gaan naarmate de UC bezig is met andere dingen.

In een FPGA zou ik de poorten kunnen configureren om een ​​inputcontrole te hebben een output in 1 klok. Dus de output zou de input volgen met een vertraging van misschien 25 nanoseconden. Dat is 40x sneller, met dezelfde klokperiode. En de rest van de poorten in de FPGA zijn beschikbaar om veel andere dingen te doen, die de snelheid van deze kleine functie niet beïnvloeden.

De code voor de FPGA zou een simpele flip-flop zijn:

always @ (posedge clock) ledPin < = buttonPin;

Dit zou slechts 1 FPGA-cel nodig hebben, ongeveer 40 poorten, van de tienduizenden in een FPGA.

Ik kan mijn FPGA herprogrammeren om iets anders te doen, bijvoorbeeld de led aansturen op basis van een combinatie van vier inputs, nog steeds in één klok, nog steeds met behulp van die ene FPGA-cel. Of bedien de led op basis van een seriële stroom van de ingang, in een paar FPGA-cellen, wat honderden poorten zouden zijn. Dus ik zou de LED kunnen besturen op basis van seriële gegevens, zeg "AAN" of "UIT", met de seriële stream op een zeer hoge snelheid (gemakkelijk 20 MHz), en toch slechts een klein deel van de capaciteit van de FPGA gebruiken.

Het voordeel van een FPGA is dus duidelijk de snelheid. Het kan alles wat een UC kan doen, en het kan het veel sneller doen, terwijl alles parallel wordt gedaan. Complexe dingen die een UC in milliseconden zou doen, zou een FPGA in microseconden of minder kunnen doen. Zolang er poorten overblijven in de FPGA, kan ik er meer functies aan toevoegen zonder de snelheid of werking van eerdere functies in de FPGA te beïnvloeden. Overigens kan een FPGA heel gemakkelijk een kloksnelheid van 20 MHz draaien.

De kosten zijn geen onderscheidende factor. Ik kan een FPGA kopen die bijna elk Arduino-ontwerp kan implementeren dat ik ooit heb gezien voor ongeveer $ 5, ongeveer hetzelfde als een Arduino AVR-chip. Er zijn ook gratis toolchains (IDE, compiler, debugger) voor FPGA's.

Power is geen onderscheidende factor. Omdat ik de FPGA met een veel lagere kloksnelheid kan gebruiken om dezelfde functie te krijgen als een uC, en een klein deel van zijn poorten kan gebruiken (ongebruikte poorten gebruiken alleen lekvermogen), kan een FPGA de kracht verslaan van bijna alle op uC gebaseerde ontwerp.

Het grootste nadeel van een FPGA is dat het veel complexer en tijdrovender is om een ​​niet-triviaal FPGA-ontwerp te definiëren, te schrijven en te debuggen dan een uC-programma. Een typisch UC-project dat u op een avond zou kunnen doen, kan dagen duren op een FPGA.

Andere, mogelijk op te lossen problemen zijn dat de meeste mensen zijn opgeleid in softwareprogrammering, maar weinigen begrijpen hardwareprogrammering. U kunt Verilog vrij gemakkelijk leren. Maar je zou ook moeten denken in termen van hardware-ontwerp in plaats van software-ontwerp. De ontwerppatronen zijn heel anders.

Een ander probleem is dat FPGA's niet in kleine 8 tot 20 pin DIP-pakketten zitten. Ze komen meestal in 100-pins of grotere pakketten voor oppervlaktemontage, dus het bouwen van de borden is moeilijker.

En een laatste probleem is dat een heleboel interessante projecten prima kunnen worden geïmplementeerd in die gebruiksvriendelijke UC's, dus waarom zou u zich druk maken over een FPGA?

"Ik kan voor ongeveer $ 5 een FPGA kopen die bijna elk Arduino-ontwerp kan implementeren dat ik ooit heb gezien." Het spijt me, maar hvæt? Waar?
#3
+9
ppvi
2009-12-16 14:19:26 UTC
view on stackexchange narkive permalink

Als u bekend bent met logische basispoorten, moet u weten dat ze vrijwel onmiddellijk werken. De operatie A en B OF C veranderen onmiddellijk wanneer A, B of C veranderen.

Een FPGA is (een soort van) een matrix van programmeerbare logische poorten. Je kunt de inputs en outputs definiëren (als een combinatie van de inputs).

In een uC zou A + B / C * sqrt (D) verschillende klokcycli en wat geheugen nodig hebben. In een FPGA is het resultaat vrijwel onmiddellijk.

Ze zijn geweldig voor video, DSP, cryptografie ...

Dat is het belangrijkste voordeel. Moderne FPGA's zijn nu uitgerust met geheugen en er zijn uC / FPGA-hybriden.

Ik ken veel Oefenende EE's met vele jaren ervaring die vaak gewoon via een FPGA in het ontwerp terechtkomen in plaats van een UC waar je voorheen UC zag. Ik denk echt dat ze geweldig zijn voor het afhandelen van interfaces.
Ja, ik vind dit een mooi voorbeeld: http://www.armadeus.com/english/index.html. Vooral interessant voor mij is servobesturing: http://marwww.in2p3.fr/~duval/wiki_html_dump/articles/m/o/t/MotionSystem_05a0.html
Merk ook op dat er steeds meer "C naar VHDL" of "C naar Verilog" converters zijn. Het zijn nog niet de meest efficiënte dingen, maar u kunt reeds geschreven code omzetten in hardware die kan worden gebruikt om de snelheid te verbeteren. Best gaaf als je het mij vraagt ​​(en als je er het deeg voor hebt).
#4
+5
endolith
2009-12-18 00:26:06 UTC
view on stackexchange narkive permalink

Ze worden gebruikt om coderingssleutels veel sneller te kraken dan een computer voor algemene doeleinden zou kunnen. : D

Haha, ik heb genoten van je zeer functionele beschrijving. Ze zijn absoluut geweldig in parallelle verwerking.
Een codebrekerproject: http://www.copacobana.org/
#5
+2
Brian Carlton
2010-02-23 03:03:15 UTC
view on stackexchange narkive permalink

Om geld en risico te besparen ten opzichte van een ASIC. Tenzij je

  1. veel om macht geeft of
  2. bouwt er een aantal (zeg> 10k eenheden)

de vaste ( NRE) kosten voor het doen van een ASIC maken het onbetaalbaar.

Aangezien u een FPGA gemakkelijk kunt wijzigen, kunt u het ontwerp minder simuleren en sneller naar het laboratorium gaan. U kunt ook een gedeeltelijk ontwerp maken en erop voortbouwen, zoals bij software.



Deze Q&A is automatisch vertaald vanuit de Engelse taal.De originele inhoud is beschikbaar op stackexchange, waarvoor we bedanken voor de cc by-sa 2.0-licentie waaronder het wordt gedistribueerd.
Loading...