PROTOTÍPUSKÉSZÍTÉS VERILOG NYELVEN Előadó: Dr. Oniga István
Összeállította Dr. Oniga István A következő anyagok felhasználásával Digitális rendszerek tervezése FPGA áramkörökkel. Fehér Bela Szanto Peter, Lazanyi Janos, Raikovich Tamas (BME Merestechnika es Informacios Rendszerek Tanszek) Embedded Design using Programmable Gate Arrays. Dennis Silage Introduction ti to Verilog course. Xilinx Inc.
FPGA-k FPGA: Field Programmable Gate Array programozható logikai áramkör Jelentősebb gyártók: Xilinx, Altera, Actel, Quicklogic, i Lattice Jellemzők A funkciót, működést a konfiguráció határozza meg A konfiguráció esetleg módosítható, törölhető Komplexitás 50000 8000000 kapu 100 600 I/O láb 100 400 MHz működés (terv függő) Felépítés lehet pl. RAM alapú, MUX alapú
Xilinx FPGA-k Több család Spartan: hatékony, optimalizált struktúra Virtex: speciális funkciók, gyorsabb, komplexebb, gazdagabb g funkcionalitás Felépítés: CLB: logikai blokk IOB: I/O blokk BlokkRAM: belső memória Szorzó Huzalozás
Xilinx FPGA: Alap logikai elem Logikai elem (Slice): 2 LUT + 2 FF + kiegészítő logika Carry OUT Comb. OUT L U T I N 4 LUT Carry + MUX FF FF OUT LUT: Look-Up Table MUX IN 16x1 bites memória (4 bemenet esetén) Cím: a logikai függvény bemeneti változói Tartalom: igazságtábla Carry IN Bármilyen négy bemenetű, egy kimenetű logikai függvény megvalósítható
Xilinx FPGA-k Részlet egy kész tervből: logikai blokkok + huzalozás
Xilinx FPGA-k: a logikai elem részletei A CLB belső felépítése az FPGA Editor-ban nézve
Xilinx FPGA: konfiguráció A konfigurációt iót (LUT tartalom, t huzalozás, csatlakozások, k egyéb paraméterek) SRAM tárolja Tápfeszültség kikapcsolásakor elveszíti a konfigurációt Bekapcsolás után konfiguráció szükséges EEPROM-ból, automatikusan Fejlesztői kábel segítségével ún. JTAG porton keresztül
Szabvány HDL nyelvek Szabványos HDL (hardware description language) nyelvek Verilog 1984: Gateway Design Automation Inc. 1990: Cadence -> Open Verilog International 1995: IEEE szabványosítás 2001: Verilog 2001 Verilog-2005 (IEEE Standard 1364-2005) SystemVerilog (IEEE standard P1800-2005). VHDL 1983-85: IBM, Texas Instruments 1987: IEEE szabvány 1994: VHDL-1993
Egyéb HDL HDL fejlesztés a szoftver fejlesztéshez viszonyítva továbbra is időigényes Sok fejlesztő rendelkezik C/C++ ismerettel, viszonylag kevés HDL ismerettel Magasszintű hardver leíró nyelvek Celoxica Handel-C: C alapú, spec. kiegészítések SystemC: szabványos, ma már (részben) szintetizálható, C++ alapú Mentor Catapult-C: C++ kiegészítések nélkül Impulse-C, Mitrion-C Gyorsabb szimuláció/verifikáció HW/SW együttes tervezés
HDL nyelvek célja Hardver modellezés Mindkét nyelv jelentős része csak a hardver funkciók modellezésére ill. szimulációra használható Szintetizálható részhalmaz szintézer függő Kapuszintű modulokból építkező, kapcsolási rajzon alapuló tervezési módszerek leváltása RTL (register transfer level) szintű leírás Automatikus hardver szintézis a leírásból Tervezői hatékonyság növelése
HDL nyelvek Alapvetően moduláris felépítésű tervezést tesz lehetővé HDL modul Be-, kimenetek definiálása Be-, kimenetek k közötti ötti logikai i kapcsolatok k és időzítések definiálása iálá NEM szekvenciálisan végrehajtódó szoftver Alapvetően időben párhuzamos, konkurens működést ír le
Szintaktika Megjegyzések (mint C-ben) // egy soros /* */ több soros Konstansok <bitszám>< alap><érték> 5 b00100: bináris szám decimális érték: 4, 5 bites: 00100 8 h4e: hexadecimális szám decimális érték: 78, 8 bites: 1001110 4 bz: bináris szám nagy impedanciás állapot: ZZZZ Ha a bitszám nem adót, az alapértelmezet: 32 bit Ha az alap nem specifikált, az alapértemezet decimális
Szintaktika 138 // decimal number, 32 bit as 00000000000000000000000010001010 10 d138 // decimal number, 10 bit as 0010001010 6 o74 // octal number, 6 bits as 111100 24 h25f // hexadecimal number, 24 bit as 000000000000001001011111 8 hxb // hexadecimal number, 8 bit as xxxx1011 3 b010 // binary number, 3 bits as 010-6 b101 // 6 bit, two s complement of 000101 or 111011-10 d15 // 10 bit, two s complement of 0000001111 or 1111110001 5 d124 // decimal number, 5 bits as 11100 since 7 bits are required 12 of2 // invalid, F is not a octal digit 8 b1010 Automatically zero-extended and stored as 0000_1010 4 b10110111 Automatically truncated and stored as 0111
Modulok Építőelem komplex rendszerek létrehozására Hierarchikus leírás, feladat partícionálás Top-down tervezés
Verilog: module (1995) Dupla munka, kettős hibalehetőség
Verilog: module (2001) Preferált a kompakt lista, kevesebb hiba
Modul használat... wire clock, reset; wire local_bus_in, _ local_bus_out; _ something inst_name (.clock (clock),.reset t( (reset),.bus_in (local_bus_in),.bus_out (local_bus_out) out) ); Almodulban Itteni valtozo deklaralt valtozo
Strukturális leírás Hierarchia felépítése: modulok összekapcsolása module top_ level (input in0, in1, in2, output r); wire xor0; xor_m xor_inst0(.i0(in0),.i1(in1),.o(xor0)); xor_m xor_inst1(.i0(xor0), i0( 0).i1(in2),.o(r)); endmodule
Bitműveletek Logikai műveletek bitvektorokon (egy vagy több bites adatokon) ~ negálás, & és, ~ & NAND, or, ~ NOR, ^ xor, ~^ XNOR. Vektorokon bitenként, pl.: 4 b1101 & 4 b0110 = 4 b0100 Ha a két operandus szélessége nem egyezik meg, a kisebbik az MSB biteken 0- val kiterjesztve 2 b11 & 4 b1101 = 4 b0001 A felteteles kifejezesek logikai operatorai az igaz-hamis vizsgalatokhoz elterőek:!, &&, (negalas, es, vagy)
Bit redukciós operátorok Egy operandusú művelet, a bitvektor összes bitjét önálló egybites változóként értelmezve, eredménye is egy bites (Egy vektor összes bitjén végeznek műveletet, kimenetük egy bites) &, ~&,, ~, ^, ~^ (es, nem es, vagy, nem vagy) Peldak: &4 b1101 = 1 b0 4 b1101 = 1 b1 Hasznalat: Számláló kimenet végérték? assign tc = &cnt; ALU kimenet nulla? assign z = ~ result;
Komparátor operátorok C-szintakszissal i megegyezőő Egyenlőség g ==,!= ===: egyenlőség az x, z értékek k figyelembevételével!==: nem egyenlő, x, z figyelembevételével Nem egyenlőség <, >, <=, >=
Aritmetikai operátorok C-szintakszissal megegyező Operátorok: +, -, *, /, % Nem mindegyik szintetizálható Szintézer függő, de tipikusan / pl. csak akkor, ha az osztó kettő hatvány Negatív számok kettes komplemens kódban
Egyéb operátorok Konkatenálás (összefűzés): {}, pl: {4 b0101, 4 b1110} = 8 b01011110 Shift operátor <<, >> Bit kiválasztás Pl. Kiválasztott rész konstans: data[5:3] wire [ 31:0 ] DATA_BUS ; wire [ 0:7 ] H_BYTE ; reg [15:0 ] CONTROL ; assign DATA_BUS [ 31:28 ] = H_BYTE [ 4:7 ] ;
Bit kiválasztás használata Pl. reg [ 7:0 ] CNTRL_BUS = 8 b11100011; Kiválasztás iránya meg kell egyezzen az eredeti iránnyal CNTRL_BUS [ 3:0 ] OK CNTRL_BUS [ 0:3 ] ERROR CNTRL_BUS [ 10:7 ] returns unknown x CNTRL_BUS [ 3:0 ] has value of 3 (0011) Egy bit kiválasztása: assign H_BYTE [ 7 ] = CONTROL [ 14 ] ;
Adattípusok wire assign Nevének megfelelően viselkedik (vezeték) Pl. 8 bites vezeték: wire [7:0] data; reg always Szintézis utáni eredmény nem mindig regiszter Vezeték Latch Flip-flop Pl.: reg [7:0] data;
Assign assign -val csak wire típusú változónak lehet értéket adni Folyamatos értékadás Pl. A bal oldali változó folyamatosan kiértékelődik assign c = a & b; a b Egy változó csak egy assign által kaphat értéket assign értékadások egymással párhuzamosan műkődnek (hardver) Kombinációs logika leírására alkalmas c
Always két esete Kombinációs logika always @ (a, b) c <= a & b; always @ (*) c <= a & b; a b c Flip-Flop always @ (posedge clk) c <= a & b; clk a b D[0] Q[0] c
Always blokk Szintakszis: always @ (.) begin.... end Érzékenységi lista Blokkon belüli műveletek Egy változó csak egy always blokkban kaphat értéket always blokk nem lehet érzékeny a saját kimenetére always blokkban nem használható assign Az always blokkok egymással (es az assign típusú értékadásokkal) é a párhuzamosan működnekű
Always értékadás Blokkoló értékadás: = Blokkolja az utána következő értékadásokat -> szekvenciális utasítás végrehajtás Nem blokkoló értékadás: <= A nem blokkoló értékadások párhuzamosan hajtódnak végre Blokkoló nem blokkoló példa később Nem-blokkoló értékadás használata javasolt
Always Flip Flop Flip Flop: élérzékeny tároló always @ (posedge clk) c <= a & b; Szinkron reset clk a b D[0] Q[0] c always @ (posedge clk) if (rst) c <= 1'b0; else c <= a & b; clk Aszinkron reset a b D[0] R Q[0] c always @ (posedge clk, posedge rst) if (rst) c<= 1'b0; else c <= a & b; rst
Always Flip Flop Xilinx FPGA-kban a FF maximum 3 élérzékeny bemenettel rendelkezik, ezek (prioritas sorrendben): reset, set, clock A reset, set lehet szinkron is Aszinkron: always @ (posedge clk, posedge rst, posedge set) if (rst) c <= 1'b0; else if (set) c<=1'b1; else c <= a & b; clk set a b rst S D[0] Q[0] R c
Always komb. log. Szemléletesen: kombinációs logika esetén a kimenet bármely bemenet bármilyen változásánál á á kiértékelődik always @ (a, b) c <= a & b; always @ (*) c <= a&b; a b c
Always latch Latch: szintvezérelt tároló: amíg a gate bemenente 1, addig mintavételezi i az adatbemenetet t t always @ (*) If (g) c <= a & b; a b g D[0] C lat c Q[0] c
Always latch hiba Latch véletlen létrehozása Nem teljes if vagy case szerkezet Szintézer általában figyelmeztet always @ (*) case (sel) 2 b00: r <= in0; 2 b01: r <= in1; 2 b10: r <= in2; endcase always @ (*) if (sel==0) r<= in0; else if (sel==1) r <= in1; else if (sel==2) r <= in2;
Always helyes Helyes kód always @ (*) case (sel) 2 b00: r <= in0; 2 b01: r <= in1; 2 b10: r <= in2; default: r <= bx; endcase always @ (*) if (sel==0) r <= in0; else if (sel==1) r <= in1; else r <= in2;
Tervezési tanácsok 1 modul, egy funkcióért felelős (pl. órajel generátor, összeadó blokk, szűrő blokk, memória tömb etc...) Minden modulban az always es assign utasítások párhuzamosan értékelődnek ki. Always blokkban nem használunk assignt! Egy always blokk egy jól meghatározott funkciót tölt be. (pl. shift regiszter, multiplexer, órajel osztó etc.) Egy always blokk egyetlen vagy néhány funkciójában szorosan kapcsolódó- reg változónak ad értéket. Minden (reg) változónak csak 1 always blokkban adjunk értéket.
Logikai operátorok &&& Logikai ÉS Logikai OR! Logikai negáció Pl. x = 1001 és y = 0110 x && y = 0 x y = 1 Prototípuskészítés Verilog nyelven
Logikai shift operátorok > > Logikai shift jobbra balról 0 töltődik < < Logikai shift balra jobbról 0 töltődik Pl. x = 10011100 x >> 2 = 00100111 x << 2 = 01110000 Prototípuskészítés Verilog nyelven
Aritmetikai shift operátorok >>> Aritmetikai shift jobbra balról MSB töltődik <<< Aritmetikai shift balra jobbról 0 töltődik Pl. x = 10011100 x >>> 2 = 11100111 x <<< 2 = 01110000 (x << 2 = 01110000) Logikai shift balra = Aritmetikai shift balra Prototípuskészítés Verilog nyelven
Feltétel leírása <Boolean expression>? <result if true> : <result if false> Pl. assign wire_name = (condition)? input1 : input0; c = (a > b)? 1 : 0; // c = 1 vagy 0 c = (a == b)? a b : a + b; // c = a b vagy a + b c = (a b) > 4? a : b; // c = a vagy b IF utasítás always @ ( * ) - always @ (posedge clk) if (condition0) statement0; e else if (condition1) statement1; else Statement2; t t2 Prototípuskészítés Verilog nyelven CASE utasítás always @ ( * ) - always @ (posedge clk) case (two_bit select) 2'b00 : statement0; 2'b01 : statement1; 2'b10 : statement2; 2'b11 : statement3; df default: statement_def; tt tdf endcase
Modul működés leírása Három alapvető modell típus Strukturális modell Explicit strukturális modell Implicit strukturális modell Procedurális modell a fentiek keveréke is lehet Prototípuskészítés Verilog nyelven
Explicit strukturális modell Strukturális modellek objektumokat kapcsolnak össze a kívánt működésű rendszer megvalósításához. Megadja a felhasznált elemeket és az elemek összekapcsolását Kapcsolat az azonosítók pozíciója szerint Kapcsolat név szerinti egymáshoz rendeléssel Az elem lehet egy, a nyelv által definiált funkcionális alapelem (primitive) vagy egy általunk külön definiált modul (UDP). Pl. module Nand_Latch (output q, qbar, input preset, clear); wire preset, clear; nand #1 G1 (q, preset, qbar), G2 (qbar, clear, q); Endmodule (#1) - 1ns késleltetést jelent (csak a szimulációnál van értelme) Prototípuskészítés Verilog nyelven
Explicit strukturális modell KAPU SZINTŰ PRIMITIVEK (26 beépített, kombinációs) FELHASZNÁLÓI PRIMITIVEK (kombinációs, szekvenciális) Tranzisztor kapcsolási szintű primitívek Modul deklaráció és hivatkozás Késleltetési modellek: a kapuk inerciális, a huzalok transzport modellel 4 értékű logika, 8 meghajtáserősséggel Huzalozott AND és OR logikák Prototípuskészítés Verilog nyelven
Implicit strukturális modell RTL modell vagy adatfolyam (dataflow) - előre definiált nyelvi operátorokat és a konkurens k folytonos kijelölés" utasítást t használja a logikai i működés előírására. á Az operátorok közvetve (implicit) meghatározzák a megvalósító hardvert is. Az ilyen közvetett strukturális modellek alapján a szintézer programok könnyen tudnak közel optimális logikai hálózatot generálni. assign folytonos értékadási utasítást használjuk. Pl. module vagy (output o, input a, b); assign o = a b; endmodule module vagy4 (output [3:0] o, input [3:0] a, b); assign o = a b; // Bitenkénti OR endmodule Operátorok rugalmasak Prototípuskészítés Verilog nyelven
Procedurális modell Algoritmikus működési leírás magasszintű HDL műveleti utasításokkal, ami a kívánt I/O működést írja le, függetlenül a konkrét hardver megvalósítástól A korszerű szimulátorok mindig eseményvezéreltek, és a Verilog nyelv is a viselkedés eseményvezérelt kiértékelését támogatja. module compare_2_ algoritmikus (output reg A_lt_B, A_gt_B, A_eq_B, input [1:0] A,B); always @ (A or B) // Esemény figyelő begin A_lt_B = 0; A_gt_B = 0; A_eq_B = 0; if (A==B) A_eq_ B = 1; else if (A>B) A_gt_B = 1; else A_lt_B = 1; end endmodule d Always csak állapottartó, regiszter típusú változókat tud kezelni, ezért a kimeneti változók a deklaráció szerint regiszter típusúak A begin.end programrészleten belül SZEKVENCIÁLIS a programvégrehajtás. Prototípuskészítés Verilog nyelven
Szimuláció Testbench: ISE két lehetőséget biztosít Testbench Waveform Grafikus felületen megadható bemenetek Verilog Test Fixture Verilog kódban megírt stimulus s Szimulátor ISE szimulátor Modelsim (MXE) Prototípuskészítés Verilog nyelven
Verilog Test Fixture Test Fixture A Test Fixture egy Verilog modul A tesztelendő modul almodulként van beillesztve Minden, a szintézisnél használt nyelvi elem felhasználható Nem szintetizálható nyelvi elemek Időalap timescale 1ns/1ps Megadott idők ns-ban értendők Szimulációs lépésköz: 1 ps Prototípuskészítés Verilog nyelven
Test Fixture - initial initial blokk 0. időpillanatban kezdődik a végrehajtása Egyszer fut le Az initial blokkok egymással, és az always blokkokkal párhuzamosan működnek Az initial blokkon belüli késleltetések összeadódnak, pl. initial begin a <= 0; #10 a <= 1; #25 a <= 2; #5 a <= 0; end 1 2 0 0 10 35 40 Prototípuskészítés Verilog nyelven
Órajel generálás initial clk <= 1; always #5 clk <= ~clk; Test Fixture - always Órajelre működő bemenetek (pl. számláló) initial cntr <= 0; always @ (posedge clk) #2 cntr <= cntr + 1; Prototípuskészítés Verilog nyelven 0 1 2 3 4 5 6 t OH =2ns
Strukturális leírás Hierarchia felépítése: modulok összekapcsolása module top_level (input in0, in1, in2, output r); wire xor0; xor_m xor_inst0(.i0(in0), i0(in0).i1(in1),.o(xor0)); xor_m xor_inst1(.i0(xor0),.i1(in2),.o(r)); endmodule module top_level (input in0, in1, in2, output r); wire xor0; xor_m xor_inst0(in0, in1, xor0); xor_m xor_inst1(xor0, in2, r); endmodule in0 in1 xor_m i0 i1 o xor_inst0 xor_m i0 i1 o xor_inst1 r in2
Strukturális leírás - generate Hierarchia felépítése: modulok összekapcsolása wire [2:0] in_bus0; wire [1:0] in_bus1; assign in_bus0[0] = in0; assign in_bus1 = {in2, in1}; generate genvar k; for (k=0; k < 2; k++) begin: inst xor_m(.i0(in_bus0[k]),.i1(in_bus1[k]),.o(in_bus0[k+1]); end endgenerate in0 in1 xor_m i0 i1 o xor_inst0 xor_m i0 i1 o xor_inst1 r in2
Példa MUX (1.) 2:1 multiplexer module mux_21 (input in0, in1, sel, output r); assign r = (sel==1 b1)? in1 : in0; endmodule module mux_21 (input in0, in1, sel, output reg r); always @ (*) if (sel==1 b1) r <= in1; else r <= in0; endmodule module mux_21 (input in0, in1, sel, output reg r); always @ (*) case(sel) 1 b0: r <= in0; 1 b1: r <= in1; endmodule
Példa MUX (2.) 4:1 multiplexer module mux_41 (input in0, in1, in2, in3, input [1:0] sel, output reg r); always @ (*) in0 case(sel) 2 b00: r <= in0; [1] 2 b01: r <= in1; 0 2 b10: r <= in2; in2 1 2 b11: r <= in3; endcase endmodule sel[1:0] in1 [1] 0 1 I0 I1 O r [0] S in3
Példa MUX (3.) 4:1 multiplexer, 4 bites kiválasztó jel always @ (*) casez(sel) /*synthesis parallel_case*/ 4 b1???: r <= in0; 4 b?1??: r <= in1; 4 b??1?: r <= in2; 4 b???1: r <= in3; default: r <= bx; endcase endmodule always @ (*) case(sel) 4 b1000: r <= in0; 4 b0100: r <= in1; 4 b0010: r <= in2; 4 b0001: r <= in3; default: r <= bx; endcase endmodule in3 in2 in1 sel[3:0] [3:0] in0 [0] [1] [2] [3] e d e d e d e d r r