FPGA-ontwerp simuleren zonder de daadwerkelijke hardware te hebben

De Xilinx-tools kunnen, voor zover ik weet, niet in realtime communiceren, noch kan ModelSim (gebruikt door Actels Libero IDE).
Ik weet niets van open source-simulatoren, er zijn er nogal wat exotische projecten die er zijn, dus het is mogelijk dat er iets is dat dit zou kunnen doen.

Dit kan echter voor jou een antwoord zijn waar je niet om hebt gevraagd (ik zal het verwijderen als het niet nuttig is), maar ik zou overwegen om je eigen FPGA-bord te bouwen om dit te doen, of in ieder geval begin er onderweg naar toe. Ik heb mijn eerste FPGA-bord geëtst en hoewel het erg eenvoudig was (het bord niet het proces ;-)), leerde het me vrij snel heel veel.

Voordelen:

• Goedkoop
• Spring meteen in het diepe en leer alles wat je moet weten over de hardware-overwegingen. Dwingt je om eerst de meeste datasheets te lezen en je eigen te schrijven startercode, die IMHO vaak beter is dan de plug-and-play ontwikkelbordbenadering van leren.
• Zet alleen op het bord wat je nodig hebt.
• Breng je verder naar je doel van een echt werkend ontwerp met mogelijk dezelfde inspanning / onderzoek als het uitzoeken hoe alles in realtime kan worden gesimuleerd.

Nadelen:

• Moet nog steeds een programmeur kopen, hoewel goedkope versies van de Xilinx / Altera-programmeurs op eBay te vinden zijn.
• Als het ontwerp en de problemen met de integriteit van het PCB / signaal niet iets zijn waarop u zich wilt concentreren, dan bent u misschien niet geïnteresseerd in veel van de kennis die u op deze manier kunt opdoen.

Ik begrijp dat het etsen van je eigen bord waarschijnlijk niet nodig is, ik deed het alleen omdat ik de FPGAs daar had, ongeduldig was en geen 2 weken wilde wachten op een printplaat. Er zijn hier extreem goedkope deals voor 2-laags boards, wat voldoende zou zijn om je ontwerp op zijn minst uit te voeren (mogelijk met lagere snelheden dan uiteindelijk gewenst – normaal zou het minimum aantal lagen voor een high-speed FPGA-ontwerp 4 zijn, maar deze zijn veel duurder)

Hoe dan ook, Spirit Circuits doet een volledig gratis 2-laags “kale” PCB-deal (één per maand, één ontwerp, geen masker of zeefdruk) wat handig is voor een eenmalig ontwerp .
Voor goede goedkope prototypekaarten met 2 en 4 lagen gaan ITead en Seed Studio zo laag als $ 10 voor 10 boards (of mogelijk 5 voor die prijs).

Opmerkingen

• zeer interessante kijk hierop! en ook bemoedigend

De standaard Xilinx ISE Webpack (de gratis versie die u kunt downloaden van xilinx.com) bevat een simulator genaamd iSim. Het is geen geweldige simulator, maar is volledig functioneel en de prijs is goed.

Hoewel ik de Altera-tools niet heb gebruikt, zou het me verbazen als er geen simulator was inbegrepen.

Maar … je moet weten wat een simulator wel en niet kan doen . Om te beginnen kan het geen FPGA simuleren die op volle snelheid draait. In feite zijn ze vrij traag. Afhankelijk van de complexiteit van de FPGA die wordt gesimuleerd, zou het me niet verbazen als het 1 minuut duurt om 1 ms van “gesimuleerd tijd “. Als je een uur” gesimuleerde tijd “wilt simuleren, zou het 1000 uur realtime nodig hebben.

Ook kan een gesimuleerde FPGA niet rechtstreeks communiceren met zaken als je USB-poort. De gesimuleerde FPGA communiceert met een “testbank”. De testbank is een brok VHDL- of Verilog-code die de invoer van de FPGA (of delen van de FPGA) voedt en de uitvoer van je FPGA verifieert. Je kunt een aantal vrij complexe dingen doen in een testbank , zoals het gebruik van getallen met drijvende komma, bestanden lezen en schrijven, en logica uitvoeren die onmogelijk te synthetiseren is.

Opmerkingen

• A ltera ‘ s heeft gratis edities van Quartus, waaronder ModelSim. De gratis versie van ModelSim beperkt je simulatiesnelheid, en de gratis versie van Quartus beperkt het aantal CPU-cores dat wordt gebruikt om te synthetiseren, maar is verder volledig functioneel.
• Altera ModelSim ondersteunt geen co-simulatie van VHDL en Verilog in hetzelfde ontwerp.

Ik ken geen enkele simulator die rechtstreeks zal communiceren op signalen die op een USB-poort (of andere hardware) binnenkomen.

In theorie zou het tenminste mogelijk zijn om software te schrijven die signalen die op een poort binnenkomen, te vertalen naar een testbankbestand dat een simulator zou kunnen verwerken. Helaas ken ik geen bestaande software om dit te doen, en het zelf schrijven zou beslist niet triviaal zijn.

Opmerkingen

• dan is de beste manier om een instapmodel, goedkoop FPGA-bord te krijgen voor n00bs zoals ik
• Je hoeft niet ‘ echt door een testbench-bestand als je een simulator hebt die h ondersteunt een interface naar aangepaste code zoals een VPI, maar aangezien de simulator ordes van grootte langzamer zal draaien dan real-time, kan het gemakkelijker zijn om vastgelegde gegevens te verwerken in een bestand dat kan worden gelezen met de snelheid van de simulatie.
• @ChrisStratton Ik ben geïnteresseerd in een idee van vastgelegde gegevens in een bestand. Zijn daar middelen voor? Bedankt
• Het hangt volledig af van de randapparatuur die u als gegevensbronnen wilt gebruiken.

Je hebt een co-simulatie-interface nodig (DPI, VPI, VHPI, FLI) waarmee je code kunt schrijven die in de simulator haakt en zo een brug slaat tussen de RTL die in simulatie draait en echte hardware op je machine .

De significante problemen die u zult tegenkomen (afgezien van slecht gedocumenteerde interfaces) zijn gerelateerd aan synchronisatie en timing. RTL die in simulatie draait, is veel langzamer dan echte hardware – je moet door interacties met de externe interface kunnen stappen om de simulatiesnelheid te evenaren. Sommige hardware-interfaces zullen dit niet leuk vinden! Als u bijvoorbeeld TCP gebruikt, moet u misschien de timers in de kernelstack fudgen om valse heroverdrachten enz. Te voorkomen.

Icarus ondersteunt de VPI en is gratis, zodat u kunt experimenteren zonder geld uit te geven aan licenties. Misschien wil je kijken naar bestaande frameworks die een deel van de co-simulatie zwaar tillen en een schonere abstractie aan de simulator bieden. Een van die frameworks is Cocotb , een open-sourcebibliotheek die een Python-interface naar de simulator biedt. ( Disclaimer: ik “ben een van de ontwikkelaars van cocotb.)

Een voorbeeld dat relevant kan zijn: gisteren heb ik RTL opgestart om te reageren op pingverzoeken en heb ik een testbank gemaakt dat opent een TUN-interface. Je kunt dan de interface pingen met het ping commando en de RTL die in simulatie draait, ontvangt de ping en reageert. De hele testbank is minder dan 50 regels Python! De broncode voor dit voorbeeld is op Github en het draait op Icarus onder Linux.

In de overgrote meerderheid van de gevallen blijft alles wat je in de simulatie doet in de simulatie. Je hebt er geen toegang toe tot echte hardware – je moet een simulatiemodel van de echte hardware hebben.

Als je echter bereid bent om wat moeite te doen, hebben de meeste simulators een interface naar willekeurige code. In Verilog is het een vrij standaard interface zoals ik het begrijp, dus de Verilog-kant van de dingen zal tussen simulators worden overgedragen. In VHDL-land is er een standaardmanier om het te doen, maar ten minste een van de grote leveranciers heeft zijn eigen manier van het doen!

Houd er ook rekening mee dat interfacing in realtime (dat wil zeggen met de snelheid waarmee de FPGA het zou doen) zeer onwaarschijnlijk is – en de rest van uw simulatie (de HDL) zal niet in het echt draaien -tijd ofwel.Zoals opgemerkt in de commentaren, is real-time gesimuleerde verwerking van video op deze manier niet haalbaar.

Persoonlijk heb ik dit nooit hoeven proberen, ik merk dat ik productievere schrijfmodellen ben van de hardware en draait alles in VHDL.

Maar “vergeet de voordelen van simulatie niet – het is een veel snellere manier om te ontdekken of dingen werken (compileren duurt seconden) en vervolgens bitstreams bouwen (compileren duurt tientallen minuten tot uren) en ze in hardware uitproberen.

Opmerkingen

• Niet waar, zie opmerkingen bij de vraag.
• OK, ik had ‘ duidelijker moeten zijn – ik beperkte mijn antwoord tot de ” ik ‘ m nieuw bij FPGA ” level 🙂 Antwoord bijgewerkt