Verilog - Verilog

Az IEEE 1364 néven szabványosított Verilog egy hardverleíró nyelv (HDL), amelyet az elektronikus rendszerek modellezésére használnak . Ez a leggyakrabban használt tervezési és ellenőrzési digitális áramkörök a regiszter transzfer szintjét az absztrakció . Azt is használják ellenőrzését analóg áramkörök és kevert jelű áramkörök , valamint a tervezés genetikai áramkörök . 2009-ben a Verilog szabványt (IEEE 1364-2005) beolvasztották a SystemVerilog szabványba, létrehozva az IEEE 1800-2009 szabványt. Azóta a Verilog hivatalosan a SystemVerilog nyelv része. A jelenlegi verzió az IEEE 1800-2017 szabványa.

Áttekintés

A hardverleíró nyelvek, mint például a Verilog, hasonlóak a szoftveres programozási nyelvekhez, mert tartalmazzák a terjedési idő és a jelerősség (érzékenység) leírási módjait. Kétféle hozzárendelési operátor létezik ; egy blokkoló hozzárendelés (=) és egy nem blokkoló (<=) hozzárendelés. A nem blokkoló hozzárendelés lehetővé teszi a tervezők számára, hogy leírják az állam-gép frissítést anélkül, hogy deklarálniuk és ideiglenes tárolóváltozókat kellene használniuk . Mivel ezek a fogalmak a Verilog nyelvi szemantikájának részét képezik, a tervezők gyorsan megírhatták a nagy áramkörök leírását, viszonylag kompakt és tömör formában. A Verilog bevezetésének idején (1984) a Verilog óriási termelékenységjavulást jelentett az áramköri tervezők számára, akik már grafikus vázlatos rögzítő szoftvereket és speciálisan írt szoftver programokat használtak az elektronikus áramkörök dokumentálására és szimulálására .

A Verilog tervezői a C programozási nyelvhez hasonló szintaxisú nyelvet akartak , amelyet már széles körben használtak a mérnöki szoftverfejlesztésben . A C-hez hasonlóan a Verilog is megkülönbözteti a kis- és nagybetűket, és rendelkezik egy alapprocesszorral (bár kevésbé kifinomult, mint az ANSI C / C ++). A vezérlésfolyam kulcsszavak (if / else, for, while eset, stb) megfelel, és annak operátor precedencia összeegyeztethető C. szintaktikai eltérések: szükséges bit-szélességek változódeklarációkat, lehatárolása eljárási blokkok (Verilog felhasználása kezdődik / vég göndör zárójelek helyett {}), és sok más kisebb különbség. A Verilog megköveteli, hogy a változóknak meghatározott méretet adjanak. A C-ben ezeket a méreteket a változó 'típusából' vezetik le (például egy egész típus 8 bites lehet).

A Verilog kialakítása modulok hierarchiájából áll . A modulok beillesztik a tervezési hierarchiát , és más deklarált bemeneti, kimeneti és kétirányú portok segítségével kommunikálnak más modulokkal . Belsőleg egy modul a következők bármelyik kombinációját tartalmazhatja: nettó / változó deklarációk (vezeték, reg, egész szám stb.), Egyidejű és szekvenciális utasításblokkok , valamint más modulok példányai (alhierarchiák). A szekvenciális utasításokat egy kezdő / vég blokkba helyezzük, és a sorrendben sorrendben hajtjuk végre. Magukat a blokkokat azonban egyidejűleg hajtják végre, így a Verilog adatfolyam-nyelvvé válik .

A Verilog 'vezetékes' koncepciója mind a jelértékekből (4 állapot: "1, 0, lebegő, undefined"), mind a jelerősségből (erős, gyenge stb.) Áll. Ez a rendszer lehetővé teszi a megosztott jelvonalak absztrakt modellezését, ahol több forrás vezet közös hálózatot. Ha egy vezetéknek több illesztőprogramja van, akkor a vezeték (olvasható) értékét a forrásmeghajtók és erősségeik függvénye oldja fel.

A Verilog nyelvű állítások egy része szintetizálható . Azok a Verilog modulok, amelyek megfelelnek a szintetizálható kódolási stílusnak, az RTL ( register-transfer level ) néven, fizikailag megvalósíthatók szintézis szoftverrel. A szintézis szoftver algoritmikusan átalakítja az (absztrakt) Verilog forrást netlistává , logikailag ekvivalens leírásként , amely csak elemi logikai primitívekből áll (ÉS, VAGY, NEM, papucsok stb.), Amelyek egy adott FPGA vagy VLSI technológiában elérhetők. További manipulációk a kötéslistában végső soron egy áramköri gyártási terv (mint például egy fényképet maszk készlet egy ASIC , vagy egy bitfolyam fájl egy FPGA ).

Történelem

Kezdet

A Verilogot Prabhu Goel , Phil Moorby , Chi-Lai Huang és Douglas Warmke hozta létre 1983 vége és 1984 eleje között. Chi-Lai Huang korábban dolgozott egy LALSD hardverleíráson, egy nyelven, amelyet SYH Su professzor fejlesztett ki PhD munkájához. . Ennek a folyamatnak a jogosultja az „automatizált integrált tervező rendszerek” volt (később 1985-ben átnevezték Gateway Design Automation névre ). A Gateway Design Automation-t 1990- ben a Cadence Design Systems vásárolta meg . A Cadence immár teljes tulajdonjoggal rendelkezik a Gateway Verilogjához és a Verilog-XL-hez, a HDL-szimulátorhoz, amely a következő évtizedre de facto (Verilog logikai szimulátorok ) szabványává válik . Eredetileg a Verilog csak a szimuláció leírására és engedélyezésére szolgált; a nyelv részhalmazainak automatizált szintézisét a fizikailag megvalósítható struktúrákig (kapuk stb.) azután fejlesztették ki, hogy a nyelv elterjedt.

A Verilog a „verifikáció” és a „logika” szavak áttekintése.

Verilog-95

A VHDL akkori növekvő sikerével a Cadence úgy döntött, hogy elérhetővé teszi a nyelvet a nyílt szabványosításhoz . A Cadence a Verilogot az Open Verilog International (OVI) (ma Accellera néven ismert ) szervezet által nyilvánosan hozzáférhetővé tette . A Verilogot később benyújtották az IEEE-hez, és az IEEE 1364-1995 szabvány lett, amelyet általában Verilog-95 néven emlegetnek.

Ugyanebben az időszakban a Cadence megkezdte a Verilog-A létrehozását , hogy szabványos támogatást helyezzen az analóg Spectre szimulátor mögé . A Verilog-A-t soha nem szánták önálló nyelvnek, és a Verilog-AMS részhalmaza, amely magában foglalta a Verilog-95-t.

Verilog 2001

A Verilog-95 kiterjesztéseit visszaküldték az IEEE-nek, hogy fedezzék azokat a hiányosságokat, amelyeket a felhasználók az eredeti Verilog szabványban találtak. Ezek a kiterjesztések az IEEE 1364-2001 szabvány lett , Verilog-2001 néven.

A Verilog-2001 a Verilog-95 jelentős frissítése. Először kifejezett támogatást ad a (2-es kiegészítés) aláírt hálózatokhoz és változókhoz. Korábban a kód szerzőinek aláírt műveleteket kellett végrehajtaniuk kínos bitszintű manipulációkkal (például egy egyszerű 8 bites összeadás végrehajtási bitjéhez a logikai algebra pontos leírása szükséges annak helyes értékének meghatározásához). Ugyanezt a funkciót a Verilog-2001 alatt röviden leírhatja az egyik beépített operátor: +, -, /, *, >>>. A generáló / endgeneráló konstrukció (hasonlóan a VHDL generátorához / endgenerátorához) lehetővé teszi a Verilog-2001 számára a példányok és utasítások példányosításának vezérlését normál döntési operátorokon keresztül (case / if / else). A Generil / endgenerate használatával a Verilog-2001 példányok tömbjét képes példányosítani, az egyes példányok összekapcsolhatóságának ellenőrzésével. A fájl I / O-t számos új rendszerfeladat javította. Végül néhány szintaxis kiegészítést vezettünk be a kód olvashatóságának javítása érdekében (pl. Mindig @, megnevezett paraméter felülírása, C stílusú függvény / feladat / modul fejléc deklaráció).

A Verilog-2001 a Verilog azon verziója, amelyet a kereskedelmi EDA szoftvercsomagok többsége támogat .

Verilog 2005

Nem tévesztendő össze a SystemVerilog , Verilog 2005 ( IEEE szabvány 1364-2005) áll kisebb korrekciók, pontosítások spec, és néhány új nyelvi jellemzőket (például a uwire kulcsszó).

A Verilog szabvány külön része, a Verilog -AMS megkísérli az analóg és a vegyes jelmodellezés integrálását a hagyományos Verilog-tal.

SystemVerilog

Az olyan hardverellenőrző nyelvek megjelenése, mint az OpenVera és a Verisity e nyelve, ösztönözte a Superlog fejlesztését a Co-Design Automation Inc. (a Synopsys tulajdonában ). Az alapjait Superlog és Vera adományoztak Accellera , amely később az IEEE szabvány P1800-2005: SystemVerilog.

SystemVerilog egy felülbírálja Verilog-2005, sok új funkciók és képességek, hogy segítse tervezés ellenőrzés és tervezés modellezés. 2009-től a SystemVerilog és a Verilog nyelvi szabványokat beolvasztották a SystemVerilog 2009-be (IEEE 1800-2009 szabvány). A jelenlegi verzió az IEEE 1800-2017 szabványa.

Példa

Két papucs egyszerű példája következik:

module toplevel(clock,reset);
  input clock;
  input reset;

  reg flop1;
  reg flop2;

  always @ (posedge reset or posedge clock)
    if (reset)
      begin
        flop1 <= 0;
        flop2 <= 1;
      end
    else
      begin
        flop1 <= flop2;
        flop2 <= flop1;
      end
endmodule

A <= Verilog operátora egy másik szempontja annak, hogy hardverleíró nyelv, szemben a normál eljárási nyelvvel. Ezt "nem blokkoló" hozzárendelésnek nevezik. Művelete csak a mindig blokk végrehajtása után regisztrálódik. Ez azt jelenti, hogy a hozzárendelések sorrendje lényegtelen és ugyanazt az eredményt hozza: a flop1 és a flop2 minden órában felcseréli az értékeket.

A másik hozzárendelési operátort = blokkoló hozzárendelésnek nevezzük. A = hozzárendelés logikai célokra történő felhasználása esetén a célváltozó azonnal frissül. A fenti példában, ha az utasítások a = blokkoló operátort használták volna a <= flop1 és a flop2 helyett , nem cserélték volna fel. Ehelyett, a hagyományos programozáshoz hasonlóan, a fordító megérti, hogy a flop1-et egyszerűen megegyezik a flop2-vel (és ezt követően figyelmen kívül hagyja a redundáns logikát, hogy a flop2 egyenlő legyen a flop1-el).

Példa a számláló áramkörre:

module Div20x (rst, clk, cet, cep, count, tc);
// TITLE 'Divide-by-20 Counter with enables'
// enable CEP is a clock enable only
// enable CET is a clock enable and
// enables the TC output
// a counter using the Verilog language

parameter size = 5;
parameter length = 20;

input rst; // These inputs/outputs represent
input clk; // connections to the module.
input cet;
input cep;

output [size-1:0] count;
output tc;

reg [size-1:0] count; // Signals assigned
                      // within an always
                      // (or initial)block
                      // must be of type reg

wire tc; // Other signals are of type wire

// The always statement below is a parallel
// execution statement that
// executes any time the signals
// rst or clk transition from low to high

always @ (posedge clk or posedge rst)
  if (rst) // This causes reset of the cntr
    count <= {size{1'b0}};
  else
  if (cet && cep) // Enables both  true
    begin
      if (count == length-1)
        count <= {size{1'b0}};
      else
        count <= count + 1'b1;
    end

// the value of tc is continuously assigned
// the value of the expression
assign tc = (cet && (count == length-1));

endmodule

Példa késésekre:

...
reg a, b, c, d;
wire e;
...
always @(b or e)
  begin
    a = b & e;
    b = a | b;
    #5 c = b;
    d = #6 c ^ e;
  end

A fenti záradék mindig a felhasználás másik típusát szemlélteti, vagyis akkor hajt végre, amikor a listában szereplő entitások ( ab vagy e ) bármelyike megváltozik. Amikor az egyik ilyen változás, egy azonnal rendelt egy új értéket, valamint amiatt, hogy a blokkoló feladat, b van rendelve egy új értéket utána (figyelembe véve az új értéket a ). 5 idõegység késése után c- hez hozzárendeljük b értékét, és a c ^ e értékét elrejtjük egy láthatatlan tárolóban. Ezután további 6 időegység után d- hez hozzárendelik az eldugott értéket.

A folyamaton belülről indított jeleknek (kezdő vagy mindig blokkoló) reg típusúnak kell lenniük . A folyamaton kívülről vezérelt jeleknek típusú vezetékeknek kell lenniük . A reg kulcsszó nem feltétlenül jelent hardverregisztert.

Az állandók meghatározása

Az állandók meghatározása a Verilogban támogatja a szélesség paraméter hozzáadását. Az alapvető szintaxis:

< Szélesség bitekben > '< alapbetű > < szám >

Példák:

• 12'h123 - Hexadecimális 123 (12 bit használatával)
• 20'd44 - 44 tizedes (20 bit használatával - a 0 kiterjesztés automatikus)
• 4'b1010 - bináris 1010 (4 bit használatával)
• 6'o77 - 77. október (6 bit használatával)

Szintetizálható konstrukciók

A Verilogot széles körben HDL-nek (hardverleíró nyelv) tartják. A Verilogban számos olyan állítás található, amelyeknek nincs analógja a valódi hardverben, pl. $ Display. Következésképpen a nyelv nagy része nem használható hardver leírására. Ez azt jelentené, hogy általában a Verilog nyelv definícióját megfelelően újra kell jellemezni. Az itt bemutatott példák azonban a nyelv klasszikus (és korlátozott) részhalmazai, amelyek közvetlen leképezéssel rendelkeznek a valós kapukhoz.

// Mux examples — Three ways to do the same thing.

// The first example uses continuous assignment
wire out;
assign out = sel ? a : b;

// the second example uses a procedure
// to accomplish the same thing.

reg out;
always @(a or b or sel)
  begin
    case(sel)
      1'b0: out = b;
      1'b1: out = a;
    endcase
  end

// Finally — you can use if/else in a
// procedural structure.
reg out;
always @(a or b or sel)
  if (sel)
    out = a;
  else
    out = b;

A következő érdekes szerkezet egy átlátszó retesz ; akkor továbbítja a bemenetet a kimenetre, amikor a kapujel "áthaladásra" van állítva, és rögzíti a bemenetet, és a kapujel átmenetekor "tartásra" tárolja. A kimenet a bemeneti jeltől függetlenül stabil marad, miközben a kapu "tartásra" van állítva. Az alábbi példában a kapu "áteresztési" szintje az lenne, ha az if záradék értéke igaz, azaz a kapu = 1. Ez a "ha a kapu igaz, a din folyamatosan a latch_out-ba kerül". Ha az if záradék hamis, a latch_out utolsó értéke megmarad, és független a din értékétől.

// Transparent latch example

reg latch_out;
always @(gate or din)
  if(gate)
    latch_out = din; // Pass through state
    // Note that the else isn't required here. The variable
    // latch_out will follow the value of din while gate is
    // high. When gate goes low, latch_out will remain constant.

A flip-flop a következő jelentős sablon; a Verilogban a D-flop a legegyszerűbb, és így modellezhető:

reg q;
always @(posedge clk)
  q <= d;

A példában a figyelemre méltó dolog a nem blokkoló hozzárendelés használata. Alapvető ökölszabály : a <= használata, ha a mindig záradékban van posedge vagy negedge utasítás.

A D-flop egyik változata aszinkron nullázással rendelkezik; van egy megállapodás, miszerint a reset állapot lesz az első, ha záradék az utasításban.

reg q;
always @(posedge clk or posedge reset)
  if(reset)
    q <= 0;
  else
    q <= d;

A következő változat tartalmaz mind aszinkron visszaállítást, mind aszinkron beállítási feltételt; ismét a konvenció lép életbe, vagyis a reset időtartamot követi a beállított kifejezés.

reg q;
always @(posedge clk or posedge reset or posedge set)
  if(reset)
    q <= 0;
  else
  if(set)
    q <= 1;
  else
    q <= d;

Megjegyzés: Ha ezt a modellt egy Set / Reset flip flop modellezésére használják, akkor szimulációs hibák léphetnek fel. Vegye figyelembe a következő eseménysorozatot. 1) a visszaállítás magasra megy 2) a clk magasra megy 3) a set magasra megy 4) az clk újra magasra 5) a reset visszaáll alacsonyra, majd 6) a set alacsonyra megy. Feltételezzük, hogy nincs beállítás, és tartsuk fenn a szabálysértéseket.

Ebben a példában a always @ utasítás először akkor hajt végre, amikor bekövetkezik a visszaállítás emelkedő széle, amely q értéket 0 értékre állítja. A következő alkalommal, amikor a mindig blokk végrehajtódik, a clk emelkedő széle lesz, amely megint megtartja q értékét 0. A mindig blokk akkor hajt végre, ha a beállított érték magasra megy, ami azért áll fenn, mert a visszaállítás nagy q erőket jelent, hogy 0 maradjon. Ez a feltétel lehet vagy nem helyes a tényleges flip flop függvényében. Ezzel a modellel azonban nem ez a fő probléma. Figyelje meg, hogy amikor a visszaállítás alacsony szintre esik, a készlet még mindig magas. Valódi flip-flop esetén ez a kimenetet 1-es szintre emeli. Ebben a modellben azonban ez nem fog bekövetkezni, mivel a mindig blokkot a beállított és a visszaállító - nem a szintek - emelkedő élei váltják ki. Másfajta megközelítésre lehet szükség a flip-papucsok beállításához / visszaállításához.

A végső alapváltozat az, amely egy D-flopot valósít meg a bemenetét tápláló muxszal. A mux rendelkezik d-bemenettel és visszajelzéssel a floptól. Ez lehetővé teszi a zárt terhelési funkciót.

// Basic structure with an EXPLICIT feedback path
always @(posedge clk)
  if(gate)
    q <= d;
  else
    q <= q; // explicit feedback path

// The more common structure ASSUMES the feedback is present
// This is a safe assumption since this is how the
// hardware compiler will interpret it. This structure
// looks much like a latch. The differences are the
// '''@(posedge clk)''' and the non-blocking '''<='''
//
always @(posedge clk)
  if(gate)
    q <= d; // the "else" mux is "implied"

Ne feledje, hogy ebben a leírásban nincsenek "kezdeti" blokkok. Az FPGA és az ASIC szintéziseszközök megosztottak ezen a struktúrán. Az FPGA eszközök lehetővé teszik a kezdeti blokkokat, ahol a reg értékeket meghatározzák, ahelyett, hogy "reset" jelet használnának. Az ASIC szintéziseszközei nem támogatják ezt az állítást. Ennek oka az, hogy az FPGA kezdeti állapota olyan, amelyet az FPGA memóriatáblázataiba töltenek le. Az ASIC egy tényleges hardveres megvalósítás.

Kezdeti és mindig

Két különféle módon lehet bejelenteni a Verilog folyamatot. Ezek a mindig és a kezdeti kulcsszavak. A mindig kulcsszó szabadon futó folyamatot jelez. A kezdeti kulcsszó azt jelzi, hogy a folyamat pontosan egyszer hajt végre. Mindkét konstrukció a szimulátor 0 időpontjában kezdi meg a végrehajtást, és mindkettő a blokk végéig hajt végre. Miután egy mindig blokk véget ért, azt (újra) átütemezik. Általános tévhit, ha azt gondoljuk, hogy egy kezdeti blokk egy mindig blokk előtt fog végrehajtódni. Valójában jobb, ha a kezdeti blokkot a mindig blokk speciális esetének tekintjük , amely az első befejezése után szűnik meg.

//Examples:
initial
  begin
    a = 1; // Assign a value to reg a at time 0
    #1; // Wait 1 time unit
    b = a; // Assign the value of reg a to reg b
  end

always @(a or b) // Any time a or b CHANGE, run the process
begin
  if (a)
    c = b;
  else
    d = ~b;
end // Done with this block, now return to the top (i.e. the @ event-control)

always @(posedge a)// Run whenever reg a has a low to high change
  a <= b;

Ez a két kulcsszó klasszikus felhasználása, de két további jelentős felhasználás létezik. Ezek közül a leggyakoribb egy mindig kulcsszó a @ (...) érzékenységi lista nélkül. Használható mindig az alábbiak szerint:

always
  begin // Always begins executing at time 0 and NEVER stops
    clk = 0; // Set clk to 0
    #1; // Wait for 1 time unit
    clk = 1; // Set clk to 1
    #1; // Wait 1 time unit
  end // Keeps executing — so continue back at the top of the begin

A mindig kulcsszó a C nyelvi konstrukcióhoz hasonlóan működik, míg az (1) {..} abban az értelemben, hogy örökké végrehajtódik.

A másik érdekes kivétel a kezdeti kulcsszó használata az örökre kulcsszó hozzáadásával .

Az alábbi példa funkcionálisan megegyezik a mindig példával.

initial forever // Start at time 0 and repeat the begin/end forever
  begin
    clk = 0; // Set clk to 0
    #1; // Wait for 1 time unit
    clk = 1; // Set clk to 1
    #1; // Wait 1 time unit
  end

Villa / csatlakozás

Az elágazás / csatlakozás párost a Verilog használja párhuzamos folyamatok létrehozására. A villa / összekötő pár közötti összes utasítás (vagy blokk) egyidejűleg kezdi meg a végrehajtást, amikor a végrehajtási folyamat eléri a villát . A végrehajtás a csatlakozás után folytatódik, ha elkészül a leghosszabb futó utasítás vagy blokk a villa és a csatlakozás között .

initial
  fork
    $write("A"); // Print char A
    $write("B"); // Print char B
    begin
      #1; // Wait 1 time unit
      $write("C"); // Print char C
    end
  join

A fentiek megírásával lehetséges az "ABC" vagy a "BAC" sorozat kinyomtatása. Az első $ írás és a második $ írás közötti szimuláció sorrendje a szimulátor megvalósításától függ, és a szimulátor szándékosan randomizálhatja. Ez lehetővé teszi, hogy a szimuláció baleseti versenyfeltételeket, valamint szándékos, nem determinisztikus viselkedést tartalmazzon.

Vegye figyelembe, hogy a VHDL nem képes dinamikusan létrehozni több folyamatot, például a Verilogot.

Versenyfeltételek

A végrehajtás sorrendje nem mindig garantált a Verilogon belül. Ezt leginkább egy klasszikus példa szemlélteti. Vegye figyelembe az alábbi kódrészletet:

initial
  a = 0;

initial
  b = a;

initial
  begin
    #1;
    $display("Value a=%d Value of b=%d",a,b);
  end

Mit nyomtatnak ki az a és b értékeire? A kezdeti blokkok végrehajtásának sorrendjétől függően ez lehet nulla és nulla, vagy felváltva nulla és valamilyen más tetszőleges inicializálatlan érték. A $ display utasítás mindig végrehajtásra kerül, miután mindkét hozzárendelési blokk elkészült, az # 1 késés miatt.

Operátorok

Megjegyzés: Ezek az operátorok nem sorrendben jelennek meg.

Négyértékű logika

Az IEEE 1364 szabvány négyértékű logikát határoz meg négy állapottal: 0, 1, Z ( nagy impedancia ) és X (ismeretlen logikai érték). A versengő VHDL esetében a többértékű logikához dedikált szabvány létezik IEEE 1164 néven , kilenc szinttel.

Rendszerfeladatok

Rendszerfeladatok állnak rendelkezésre az egyszerű I / O és a különböző tervezési mérési funkciók kezelésére a szimuláció során. Az összes rendszerfeladatot előtaggal $ jelöli, hogy megkülönböztesse őket a felhasználói feladatoktól és függvényektől. Ez a szakasz a leggyakrabban használt feladatok rövid listáját mutatja be. Ez korántsem egy átfogó lista.

• $ display - Nyomtatás egy sor megjelenítéséhez, amelyet automatikus új sor követ.
• $ write - Nyomtatás egy sor megjelenítéséhez az új sor nélkül.
• $ swrite - Nyomtatás egy sor változóra az új sor nélkül.
• $ sscanf - A formátum által megadott karaktersorozat beolvasása a változóból. (* Verilog-2001)
• $ fopen - Nyissa meg a fájl kezelőjét (olvasás vagy írás)
• $ fdisplay - Nyomtasson egy sort egy fájlból, majd egy automatikus új sort.
• $ fwrite - Nyomtatás egy sor új sor nélküli fájlozásához.
• $ fscanf - Olvassa el a fájlból egy formátumban megadott karakterláncot. (* Verilog-2001)
• $ fclose - Zárja be és engedje fel a megnyitott fájlkezelőt.
• $ readmemh - Olvassa el a hex fájl tartalmát egy memória tömbbe.
• $ readmemb - bináris fájlok tartalmának beolvasása memóriatömbbe.
• $ monitor - Nyomtassa ki az összes felsorolt ​​változót, ha bármilyen változás történik.
• $ time - Az aktuális szimulációs idő értéke.
• $ dumpfile - Nyújtsa be a VCD ( Value Change Dump ) formátumú kimeneti fájl nevét.
• $ dumpvars - Kapcsolja be és dobja ki a változókat.
• $ dumpports - Kapcsolja be és dobja ki a változókat Extended-VCD formátumban.
• $ random - Véletlenszerű értéket ad vissza.

Programnyelvi interfész (PLI)

A PLI egy programozónak biztosít egy mechanizmust, amely átadja a vezérlést a Verilogról egy C nyelven írt programfunkcióra. Az IEEE Std 1364-2005 hivatalosan megszüntette az újabb Verilog Eljárási Interfész javára , amely teljes mértékben felváltja a PLI-t.

A PLI (jelenleg VPI) lehetővé teszi a Verilog számára, hogy együttműködjön más, C nyelven írt programokkal, például tesztkötegekkel , egy mikrovezérlő utasításkészlet-szimulátorával , hibakeresőkkel és így tovább. Például megadja a C függvényeket , amelyeket az aktuális Verilog feladat vagy függvény argumentumának megírásához és olvasásához használnak. tf_putlongp()tf_getlongp()

Szimulációs szoftver

A Verilog szimulátorokkal kapcsolatos információkért lásd a Verilog szimulátorok listáját .

Lásd még

Kiegészítő anyag

• A Verilog szimulátorok listája
• Hullámforma néző
• SystemVerilog Direct Programming Interface (DPI)
• Verilog Procedural Interface (VPI)

Hasonló nyelvek

• VHDL
• SystemC - C ++ könyvtár, amely HDL eseményvezérelt szemantikát biztosít
• SystemVerilog
• OpenVera
• e (ellenőrzési nyelv)
• Tulajdonságspecifikációs nyelv
• Véső , a Scala tetejére épített nyílt forráskódú nyelv

Verilog generátorok

Hivatkozások

Megjegyzések

Külső linkek

A szabványok fejlesztése

• IEEE Std 1364-2005 - A Verilog 2005 hivatalos szabványa (nem ingyenes).
• IEEE P1364 - a Verilog munkacsoportja (inaktív).
• IEEE P1800 - A SystemVerilog munkacsoportja (a fentiek helyébe lép).
• Verilog szintaxis - A szintaxis leírása Backus-Naur formában . Ez megelőzi az IEEE-1364 szabványt.
• Verilog-AMS - Az Accellera kevert jelkiterjesztéseket adott a Veriloghoz

Nyelvi kiterjesztések

• Verilog AUTOs - Nyílt forráskódú metakommentár, amelyet az ipari IP használ a Verilog kód karbantartásának egyszerűsítésére.