Implementeren delay in VHDL

Hoe implementeer je een hardware delay in VHDL?
Ik heb het volgende op internet gevonden:


a = b after 2ns;

maar werkt dit ook in de FPGA of enkel in de simulator?
Ik heb een probleem door de hoge frequentie van de FPGA dat ervoor zorgt dat als ik telkens op de rising edge een signaal inlees, het signaal nog niet stabiel is. Ik zou enkele ns moeten wachten.
Hoe doe je dit?

Dat gaat je zo niet lukken. Dat is idd alleen voor een simulator.
Wat je kunt doen is je oscillator klok een procesje laten klokken en na die aantal tellen een rising of falling edge genereren! Wat ook kan is een DCM maken (zo heet dat in xilinx termen). Dit is een Digital klok manager, in deze ip kun je een klok stoppen en je kunt deze afdelen tot een lagere frequentie.
Good luck!

En is het niet mogelijk om de compiler een pad te laten berekenen dat exact x ns duurt?

Dat zou wel mogelijk zijn, maar tis wel slechte design practice. Wat wil je juist doen? Welke frequenties gebruik je? Toon je code eens...

Je moet via je constraints editor opgeven wat de setup/hold time van je ingangssignaal tenopzichte van de externe clock is. Dan komt 't automatisch goed.

Euhh is dat wel helemaal waar MagicBox? is het niet zo dat er gekeken wordt naar je constraints en als ze niet voldoen er een warning/error wordt gegeven?

Dus ALS je design netjes wordt gecompileerd is het kennelijk gelukt :)

Maar inderdaad: eigenlijk moet je constraints gebruiken als controle op wat je verwacht, of als leidraad voor de compiler, maar dat is nog wat anders dan het als implementatie-methode in te zetten. Misschien iets meer info over het hoe en waarom? Het zou best kunnen dat TS in zijn geval inderdaad gewoon constraints moet gebruiken.

Je constraints zijn wel degelijk een INPUT voor je synthese en P&R proces, en niet een controle achteraf of het gelukt is. Bv met een clk constraint op 1MHz zal nooit geprobeerd worden om tot 100MHz te komen en is het maar toevallig als dit gehaald wordt. Een constraint op 105MHz helpt al een heleboel.

Maar terug naar de vraag: die delay werkt inderdaad niet op hardware (wat voor hardware zou dat moeten worden dan?). En hoe weet je zo zeker dat het signaal niet stabiel is op de clk flank?

@Jochem hieronder. Ok, duidelijk. Ik wilde niet zeggen dat je verhaal niet klopte.. beetje aanvullen hooguit.
Met constraining kun je dus zorgen dat setup/hold tijden gehaald worden, maar niet om een extra delay line in te voegen. Da's VIES ontwerpen als het al lukt.

[Bericht gewijzigd door flipflop op (22%)]

Tuurlijk, het is wel een input, dat bedoelde ik met leidraad voor de compiler. Maar ik vroeg me af of dit wel de manier van implementeren was in geval van TS, gezien hij vraagt om 'een delay'.

Met een PLL kan je voor een bepaalde frequentie een fase opgeven, dus je kan een 'delay' opgeven.

Maar de vraag is waarom je eigenlijk die delay nodig hebt, vanwaar komt dat signaal, enzovoort. Er is wat meer info nodig

Op 4 mei 2009 13:03:28 schreef Scheef_schaap:
Hoe implementeer je een hardware delay in VHDL?
Ik heb het volgende op internet gevonden:


a = b after 2ns;

als ik telkens op de rising edge een signaal inlees, het signaal nog niet stabiel is. Ik zou enkele ns moeten wachten.
Hoe doe je dit?

door te lezen als het wel stabiel is ....
pak de falling edge dan. of stuur je clock extern door een invertor. die zal wel een paar nanoseconden toevoegen.

je kan ook een delay generator maken met lcell (altera , weet niet hoe dat noemt in xilinx)

maar dergelijk blok moet je als schema tekenen en opgeven aan de synthesizer dat het niet mag weggeminimaliseerd worden.

Schema tekenen? Instantieren heet dat.

Op 5 mei 2009 21:25:09 schreef flipflop:
Schema tekenen? Instantieren heet dat.

hangt van de tools af. in quartus is er een optie waarbij je voor een schema kan opgeven : poten af. implementeer zoals getekend. daar kan je natuurl,ijk een vhdl of verilog entity van maken en dat gaan instantieren.

je kan het ook via de verilog netlist via een of andere compiler directive. maar ik zie liever een schema dna 2 meter verilog netlist te moeten lezen hoor ...

ik heb zo een programmeerbaar skew blok gemaakt als schema. een mooie multiplexer die als boomstructuur gemaakt is en exact de zelfde looptijd heeft in alle takken. tussen de takken staat telkens een dubbele lcell.
via 5 bits kan ik skewen in stapjes van 410 picosecondes. ik kan dus bijna 12 nanoseconde skewen. mijn clock is 10ns. bij powerup staan de skewers halverwege. ik compenseer looptijden op het bord door middel van de skewers te tunen. werkt vlekkeloos.

Hoe zet je de synth zo dat die van bepaalde blokken afblijft in quartus?

er is een setting onder projects waarbij je kan opgeven : do not minimize schematic. zal straks eens zien hoe het juist noemt.