A VERILOG HARDVER LEÍRÓ NYELV ALKALMAZÁSA A LOGIKAI SZINTÉZISBEN

Átírás

1 A VERILOG HARDVER LEÍRÓ NYELV ALKALMAZÁSA A LOGIKAI SZINTÉZISBEN M.D. CILETTI Department of Electrical and Computer Engineering University of Colorado Colorado Springs, Colorado Copyright 1997 No part of these notes may be copied or reproduced in any form without the written permission of the author. A szerző írásbeli engedélye és jóváhagyása alapján átdolgozta és magyarra fordította FEHÉR BÉLA Budapesti Műszaki Egyetem Méréstechnika és Információs Rendszerek Tanszék

2 TARTALOM 1. rész: Bevezetés, modellek, hierarchikus tervezés, szimuláció 2. rész: Modulok felépítése, adattípusok, logikai operátorok 3. rész: Felhasználói primitívek, késleltetési modellek 4. rész: Működési leírás modellezése Veriloggal 5. rész: A Verilog szintézis módszereinek ismertetése 2

3 UTASÍTÁSON BELÜLI KÉSLELTETÉS PÉLDA module dff_viselk (data, clk, q, qbar, reset); input data, clk, reset; output q, qbar; reg q; parameter kapcs_ido = 5; parameter kis_ido = 2; assign qbar = # kis_ido ~q; // Eltérés q, qbar között or reset) begin if (reset == 0) q = # kapcs_ido 0; else q = # kapcs_ido data; end endmodule A data bemenet értéke a kapcs_ido kapcsolási idő múlva jeleneik meg a q kimeneten, amit egy kis_ido múlva a qbar kimenet változása is követ. 3

4 UTASÍTÁSON BELÜLI KÉSLELTETÉS preset data q clk qbar clear module D_Flop (preset, clear, q, qbar, clock, data); input preset, clear, clock, data; output q, qbar; reg q; parameter delay = 5; assign qbar = ~q; (negedge clock) q = # delay data; // késleltetett értékadás (clear or preset) begin if (!clear) #1 assign q = 0; //PCA else if (!preset) assign q = 1; else deassign q; end endmodule 4

5 ISMÉTLŐDŐ ESEMÉYEK Az utasításon belüli késleltetés tartalmazhat ismétlődési számot is. PÉLDA reg_a = repeat (negedge clock) reg_b; // reg_b mintavételezett értékét 5 órajel ciklus utáni másolja át reg_a-ba EKVIVALENS MEGOLDÁS begin temp = (negedge (negedge (negedge (negedge (negedge clock); reg_a = temp; end 5

6 ISMÉTLŐDŐ ESEMÉNYEK VEZÉRLÉSE module repeater; reg clock; reg reg_a, reg_b; clock initial clock = 0; reg_a t initial begin #5 reg_a = 1; #10 reg_a = 0; #5 reg_a = 1; #20 reg_a = 0; end always #5 clock = ~ clock; initial #100 $finish; reg_b initial begin #10 reg_b = repeat (posedge clock) reg_a; end endmodule t t 6

7 IDŐZÍTÉSVEZÉRLÉSI MODELLEK A VISELKEDÉSI LEÍRÁSOKBAN ASSIGNMENTS Procedural Assignment (=) Procedural -Continuous (assign) Non-Blocking (<=) Assignment Delay Control FLOW CONTROL Case Branching Loops Parallel Activity (fork... join) Assignment Event Control Intra-Assignment Delay TIMING Wait Named Events Pin-Pin Delay CODE MANAGEMENT Function Calls Task Calls Prog. Lang. Interface (PLI) 7

8 IDŐZÍTÉSI ÉS KÉSLELTETÉSI MODELLEK CÉL: A viselkedési leírás egy-egy aktivitásához késleltetést rendelhet. X_in PROCEDURÁLIS KÉSLELTETÉS Y_out t X_in KI-BEMENETI VISELKEDÉS LEÍRÁSA Y_out t algo t Késleltetés vezérlés (#) (Blokkolja / felfüggeszti a végrehajtást) Eseményvezérlés (@) (Aktivitásokat szinkronizál) Utasításon belüli késleltetés (Késlelteti az értékadást) Wait (a továbblépés feltételei) Nevesített esemény (Szinkronizáció absztrakt eseményekhez) Interfész (I/O) késleltetés modellezése 8

9 A 'wait' UTASÍTÁS CÉL: A SZINTÉRZÉKENY ESEMÉNYVEZÉRLÉS TÁMOGATÁSA SZINTAKTIKA wait (feltétel_kifejezés) utasítás_vagy_üres; HATÁSA: A végrehajtás felfüggesztődik, amíg a 'wait' feltétel_kifejezés értéke 'IGAZ' nem lesz. PÉLDA... begin wait (!enable) #10 a = b; #10 c = d; end... 9

10 PÉLDA A 'wait' HASZNÁLATÁRA - HANDSHAKE module server (data_out, server_ready, client_ready); output [15:0] data_out; output server_ready; input client_ready; reg server_ready; reg [15:0] data_out; SERVER data_out server_ready client_ready 16 CLIENT data_in server_ready client_ready várakozás client_ready-re server_ready és várakozás!client_ready-re várakozás client_ready-re client_ready!client_ready client_ready 10

11 PÉLDA 'wait' HASZNÁLATÁRA - HANDSHAKE always // SZERVER OLDAL begin server_ready = 0; // kezdeti feltétel beállítása forever begin wait (client_ready) // várakozás a kliens kérésére data_out = $random; // kimeneti adat frissítése server_ready = 1; // szerver kész az adat küldésre wait (!client_ready) // átvitel kész server_ready = 0; end end endmodule 11

12 PÉLDA 'wait' HASZNÁLATÁRA - HANDSHAKE module client (data_in, server_ready, client_ready); input [15:0] data_in; input server_ready; output client_ready; reg client_ready; reg [15:0] data_reg; SERVER data_out server_ready client_ready 16 CLIENT data_in server_ready client_ready várakozás client_ready-re server_ready és várakozás!client_ready-re várakozás client_ready-re client_ready!client_ready client_ready 12

13 PÉLDA 'wait' HASZNÁLATÁRA - HANDSHAKE always // KLIENS OLDAL begin client_ready = 1; // kliens kész jelzés forever begin wait (server_ready) // várakozás a szerver válaszára data_reg = data_in; // adat átvétele client_ready = 0; // jelzés visszavétele // adat feldolgozása wait (!server_ready) // várakozás a szerverre client_ready = 1; // kész válasz a szervernek end end endmodule 13

14 HANDSHAKE SZIMULÁCIÓ module top_module(); // Random client/server wire [3:0] data_out, data_in; wire server_ready, client_ready; server M1 (data_out, server_ready, client_ready); client M2 (data_out, server_ready, client_ready); initial begin #300 $finish; end endmodule module server(data_out, server_ready, client_ready); output [3:0] data_out; output server_ready; input client_ready; reg server_ready; reg [3:0] data_out; reg [3:0] timer; always begin # 15 server_ready = 0; forever begin wait (client_ready) timer = $random; # timer data_out = $random; #5 server_ready = 1; wait (!client_ready) #3 server_ready = 0; end end endmodule module client(data_in, server_ready, client_ready); input [3:0] data_in; input server_ready; output client_ready; reg client_ready; reg [3:0] data_reg; reg [3:0] timer; always begin #30 client_ready = 1; forever begin wait (server_ready) #2 data_reg = data_in; timer = $random; # timer client_ready = 0; wait (!server_ready) #30 client_ready = 1; end end endmodule 14

15 KOMMUNIKÁCIÓ ELJÁRÁSOK KÖZÖTT (INTER-PROCESS COMMUNICATION, IPC) A Verilog nyelv két módszert kínál a konkurrens folyamatok (viselkedési leírások) szinkronizációjára: Élérzékeny eseményvezérlő kifejezés Nevesített esemény. A nevesített események olyan szinkronizációt biztosítanak, amely akár hierarchikus szintek között is, modulportokat nem igényelve használható. 15

16 NEVESÍTETT ESEMÉNYEK CÉL: ELJÁRÁSOK KÖZTI KOMMUNIKÁCIÓ BIZTOSÍTÁSA. JELLEMZŐK: NINCS MEGVALÓSÍTÁSHOZ KÖTVE, MINT PL. wire OR reg. ABSZTRAKT MECHANIZMUS A KOMMUNIKÁCIÓRA / SZINKRONIZÁCIÓRA TÁMOGATJA A MAGAS SZINTŰ VISELKEDÉSI MODELLEZÉST SPECIÁLIS TULAJDONSÁG: AZ IPC PORTOK NÉLKÜL VALÓSÍT MEG MODULOK KÖZÖTTI KOMMUNIKÁCIÓT 16

17 NEVESÍTETT ESEMÉNYEK DEKLARÁCIÓ: event esemény_neve; HASZNÁLAT: -> esemény_neve; MEGJEGYZÉSEK: A nevesített eseményeket a használat előtt deklarálni kell. Nincs szükség hardver elemekre az esemény tárolásához (reg) vagy az átviteléhez (wire). A nevesített esemény szerkezet sokkal absztraktabb, mint az egyszerű eseményvezérlő kifejezés. A VHDL-ben nincs hasonló szerkezet. Nem szükséges semmi speciális művelet a mechanizmus használatához. 17

18 PÉLDA NEVESÍTETT ESENÉNY HASZNÁLATÁRA clock up_edge_of_clock q_out data module named_event1(q_out, clock, data); input clock, data; output q_out; reg q_out; event up_edge_of_clock; clock) -> up_edge_of_clock; q_out = data; endmodule 18

19 PÉLDA NEVESÍTETT ESEMÉNY HASZNÁLATÁRA clock M1 do_it M2 q_out module Top (clock, data, q_out); input clock, data; output q_out; Talker M1 (clock); Receiver M2 (q_out, data); endmodule module Talker (clock); input clock; event do_it; clock) -> do_it; endmodule data module Receiver (q_out, data); input data; output q_out; reg q_out; q_out = data; endmodule 19

20 KÉSLELTETÉSI MODELLEK - MODULOK BE-/KIMENETI KÉSLELTETÉSE CÉL: A teljes modul késleltetés modellezése egyszerű be/kimeneti időadatokkal. X_in MODUL BE/KIMENETI KÉSLELTETÉS Y_out t X_in VERILOG MODUL Y_out t mod t Különböző ütemezések lehetségesek Interfész alapú viselkedési model A késleltetést szétválasztja a belső funkcionalitástól MEGJEGYZÉS: CSAK A MODULOKNAK LEHET BE/KIMENETI KÉSLELTETÉSE 20

21 MODULOK BE-/KIMENETI KÉSLELTETÉSE preset clear 5ns 5ns data clock flop_qca q 8ns A be/kimeneti késleltetési modell megengedi a tervezőnek a időzítés specifikáció elválasztását a modul belső funcionalitásának definiálásától. 21

22 MODUL KÉSLELTETÉSI JELUTAK A be/kimeneti utaknak két típusa lehetséges: párhuzamos vagy teljes. => *> Párhuzamos be/kimeneti késl. Teljes be/kimeneti késleltetés A párhuzamos kapcsolat skalárokat vagy azonos méretű vektorokat igényel. A teljes kapcsolat vektort skalárral, vektorokat eltérő vagy azonos méretű vektorokkal, többszörös jelforrásokat többszörös jelvégpontokkal társít össze. 22

23 JELUTAK MEGADÁSÁNAK SZABÁLYAI SZABÁLYOK A modul jelút végpont csak modulon belüli meghajtó kimenete lehet. A => operator párhuzamos kapcsolatot specifikál a megfelelő be- és kimeneti bitek között. A *> operator teljes kapcsolatot specifikál minden bemenet és minden kimenet között. A modul jelút forrása csak deklarált input vagy inout lehet. A modul jelút végpontja csak deklarált output vagy inout lehet. 23

24 PÉLDA MODUL JELÚT KÉSLELTETÉSRE module mod_path_ff (clock,data,clear,preset,q_out,q_outbar); input clock, data, clear, preset; output q_out, q_outbar; reg q; wire q_outbar = ~ q_out; buf (q_out, q); // Szükséges meghajtó (clear or preset) begin if (!clear) assign q = 0; // PCA else if (!preset) assign q = 1; else deassign q; end clock) q = data; data clk y preset clear q_out q_outbar specify specparam t_rise_clk_q = 90, t_fall_clk_q = 110, t_rise_ctl_q = 40, t_fall_ctl_q = 50; // be-/kimeneti jelút időzítés specifikáció (clock => q_out) = (t_rise_clk_q, t_fall_clk_q); (clear, preset *> q_out) = t_rise_ctl_q, t_fall_ctl_q); endspecify endmodule 24

25 PÉLDA: NAND KAPU KÉSLELTETÉSI MODELLJE Az ASIC technológiai könyvtárak gyakran két részletben modelleznek: primitívekkel írják le a fuknkciót és ún. "specify" blokkal a be-/kimeneti késleltetéseket. module nanf201 (O, A1, B1); // 1.2 mikronos CMOS cella output O; input A1, B1; nand(o, A1, B1); // primitív kapu használata specify // optionális modul jelút időyítések specparam Tpd_0_1 = 0.052:0.097:0.289, Tpd_1_0 = 0.061:0.129:0.330; (A1, B1 => O) = (Tpd_0_1, Tpd_1_0); endspecify endmodule 25

26 ÖSSZEFOGLALÓ A KÉSLELTETÉS SPECIFIKÁCIÓS SZERKEZETEKRŐL KOMBINÁCIÓS LOGIKA KÉSLELTETÉS TÍPUSA Primitív kapu késleltetése Tehetelenségi(min:typ:max, rising, falling, turn-off) assign értékadás Tehetelenségi(min:typ:max, rising, falling, turn-off) Huzal deklaráció Transzport késleltetés Huzal assign értékadás Tehetetlenségi(min:typ:max, rising, falling) SZEKVENCIÁLIS LOGIKA Késleltetés vezérlás # blokkoló_utasítás Esemény Utasításon belüli késleltetés # (esemény_kifejezés) repeat ( (esemény_kifejezés) Be/kimeneti késleltetés Specifikációs blokk 26

27 IDŐZÍTÉS ELLENŐRZÉS Verilog nyelv a szimuláció során szükséges minden időzítés ellenőrzési feladatra beépített rendszer taszkokat biztosít. TASZK $setup $hold $setuphold $period $width $skew $recovery FUNKCIÓ Figyelmeztet, ha a jel a referenciajel aktív éle előtti specifikált intervallumban változik. Figyelmeztet, ha a jel a referenciajel aktív éle utáni specifikált Intervallumban változik. Együttesen ellenőrzi mindkét fenti feltételt. Figyelmeztet, ha a jel periódusideje rövidebb a specifikáltnál. Figyelmeztet, ha a pulzus szélesség keskenyebb a specifikáltnál. Figyelmeztet, ha két jel elcsúszása meghaladja a specifikált értéket. Figyelmeztet, ha a jel feléledési ideje meghaladja a specifikált értéket. 27

28 BEÁLLÁSI IDŐ (SETUP TIME) $setup (adat_esemény, referencia_esemény, határérték, jelzés); PÉLDA sys_clk sig_a 5 slack sig_a A beállási idő veszélyeztetése akkor fordul elő, amikor az adat_esemény a referencia_ eseményhez képest a megadott határértéknek megfelelő időintervallumon belül fordul elő. A gyakorlatban az adatnak stabilnak kell lennie, a regiszterek (flipflop-ok) órajelének aktív éle előtt. sig_b t setup $setup (sig_a, posedge sys_clk, 5) sig_a teljesíti a beállási idő korlátozást. sig_b nem teljesíti a beállási idő korlátozást. A szintézis eszközök a kombinációs jel utak késleltetésének minimalizálásával igyekeznek megfelelő tartalék időt (slack) biztosítani a kritikus jelútban is. Az időzítés ellenőrzéseket általában a specify endspecifiy blokk tartalmazza a modulban. A szimulátorok automatikusan figyelik a jelalakok megfelelősségét. 28

29 TARTÁSI IDŐ (HOLD TIME) $hold (adat_esemény, referencia_esemény, határérték, jelzés); PÉLDA sys_clk sig_a 2 t hold A tartási idő veszélyeztetése akkor fordul elő, amikor az adat_esemény a referencia_ eseményhez képest a megadott határértéknél rövidebb idő alatt fordul elő. A gyakorlatban az adatnak stabilnak kell maradnia az órajel aktív éle után, hogy a flip-flop-on belüli tranziens folyamatok megbízhatóan befejeződjenek. sig_b A szintézis eszközök a rövid kombinációs jel utakat megnyújtják, az időzítési adatok teljesítése érdekében. $hold (sig_a, posedge sys_clk, 5) sig_a nem teljesíti a tartási idő korlátozást. sig_b teljesíti a tartási idő korlátozást. Az opcionális jelzés regiszter használható az időzítésbeli problémák kezelésére a modellben, pl. x érték továbbadására. (Lásd Verilog Language Reference Manual) 29

30 BEÁLLÁSI ÉS TARTÁSI IDŐK (SETUP AND HOLD TIMES) $setuphold (adat_esemény, referencia_esemény, setup_limit, hold_limit, jelzés); PÉLDA sys_clk setup_limit hold_limit posedge jelentése: 01, 0x, x1 átmenetek sig_a sig_b $setuphold (sig_a, posedge sys_clk, 5,3) sig_a teljesíti mindkét korlátozást. negedge jelentése: 10, x0, 1x átmenetek Az élváltásoknál nincs különbség a 'z' érték és az 'x' érték kezelése között. A Verilog támogatja az egyedi él specifikációkat is, pl.: edge [01] sig_b nem teljesíti valamelyik korlátázást. 30

31 MINIMÁLIS PULZUS SZÉLESÉG (PULSE WIDTH) PÉLDA $width (referencia_esemény, határérték jelzés); t MPW A $width taszk ellenőrzi a minimális pulzus szélességet az élvezérelt eszközök modelljeinél. clock_a clock_b clock_a teljesíti a pulzus szélesség korlátot. $width (posedge clock_a, 20); Az élvezérelt eszköz órajel pulzusának egy minimális időtartamot meg kell haladnia, a belső tranziens folyamatok teljes befejeződése érdelében. Az órajel terjesztési fák tervezése fokozott gondosságot igényel. clock_b nem teljesíti a pulzus szél. korlátot. 31

32 PERIÓDUSIDŐ $period (referencia_esemény, határérték, jelzés); PÉLDA clock_a t period A $period taszk ellenőrzi a kiválasztott jel két referencia eseményének alapján a periódusidőt. t limit $period (posedge clock_a, 25); clock_a teljesíti a periódusidő korlátot. 32

33 ELCSÚSZÁS (SKEW) $skew (referencia_esemény, adat_esmény, határérék, jelzés); PÉLDA clk1 clk2 t skew A $skew taszk ellenőrzi az időelcsúszást, (időeltérést) a két jel referencia élei között és jelzi, ha ez kisebb a megadott határértéknél Az órajel elcsúszás minimalizálásának fontos szerepe van a rendszer teljesítő képességének növelésében. $skew(posedge clk1, negedge clk2, 3); 33

34 FELÉLEDÉSI IDŐ (RECOVERY TIME) $recovery (referencia_esemény, adat_esmény, határérék, jelzés); PÉLDA set clock_a t rec A $recovery taszk ellenőrzi, hogy egy szinkron viselkedési leírással adott modell a reset vagy set vezérlőjel deaktiválása után a megadott időn belül működésre kész-e. clock_a teljesíti a feléledési idő által a periódusidejére adott korlátot. A feléledési idő korlát specifikálja, hogy a vezérlőjel megszűnése után mennyi időn belül kell megjönnie az első órajel felfutó élnek. $recovery (negedge set, posedge clock,3); Tipikus alkalmazás a buszjelek bekapcsolási időzítésének ellenőrzése. 34

35 FELTÉTELES ESEMÉNYEK (CONDITIONED EVENTS) A feltételes események összekapcsolják az időzítés ellenőrzést egy feltételes jellel. PÉLDA $setup (data, posedge clock &&& (~reset), 10); MEGJEGYZÉS: A reset jel aktív értéke esetén a &&& speciális operátor segítségével a szükségtelen időzítési jelzéseket letiltjuk. 35

36 PÉLDA IDŐZÍTÉSADATOK HASZNÁLATÁRA FLIP-FLOP MODELLEZÉSÉNÉL `timescale 1ns / 1ps `celldefine module dfnf311 (Q, Q_b, DATA1, CLK2); // Negative edge-triggered flip-flop with Q and QB input DATA1, CLK2; output Q, Q_b; reg notify; parameter vlib_flat_module = 1 ; U_FD_N_NO inst1 (Q_int, DATA1, CLK2, notify); // user-defined primitive buf inst2 (Q, Q_int); not inst3 (Q_b, Q_int); 36

37 specify // Module paths specparam Area_Cost = ; (negedge CLK2 => (Q +: DATA1)) = (0.525:1.129:2.889, 0.749:1.525:3.948); specparam RiseScale$CLK2$Q = : : ; specparam FallScale$CLK2$Q = : : ; (negedge CLK2 => (Q_b -: DATA1)) = (0.590:1.243:3.207, 0.425:0.914:2.616); specparam RiseScale$CLK2$Q_b = : : ; specparam FallScale$CLK2$Q_b = : : ; specparam inputcap$clk2 = 40.18, InputCap$DATA1 = 24.11; specparam InputLoad$CLK2 = 0.009:0.021:0.053, InputLoad$DATA1 = 0.005:0.013:0.032; specparam t_setup$data1 = 0.76:0.92:1.68, t_hold$data1 = 0.44:0.74:0.46, t_pw_h$clk2 = 0.37:0.67:1.99, t_pw_l$clk2 = 0.37:0.67:1.99; 37

38 // Timing checks $setuphold(negedge CLK2, DATA1, t_setup$data1, t_hold$data1, notify); $width (posedge CLK2, t_pw_h$clk2, 0, notify); $width (negedge CLK2, t_pw_l$clk2, 0, notify); `ifdef not_cadence specparam MaxLoad = `MAX_LOAD_1X; `endif endspecify endmodule `endcelldefine 38

39 primitive U_FD_N_NO (Q, D, CP, NOTIFIER_REG); output Q; input NOTIFIER_REG, D, CP; reg Q; // FUNCTION : NEGATIVE EDGE TRIGGERED D FLIP-FLOP ( Q OUTPUT UDP ). table // D CP NOTIFIER_REG : Qt : Qt+1 1 (10)? :? : 1; // clocked data 0 (10)? :? : 0; 1 (1x)? : 1 : 1; // reducing pessimism 0 (1x)? : 0 : 0; 1 (x0)? : 1 : 1; 0 (x0)? : 0 : 0;? (0x)? :? : -; // no change on rising edge? (?1)? :? : -; *?? :? : -; // ignore edges on data?? * :? : x; // all transitions endtable endprimitive 39

40 A SZIMULÁCIÓS IDŐ SKÁLÁZÁSA `timescale <idő_egység> / <idő_felbontás> A `timescale direktíva specifikálja a fizikai időegységet és azt a felbontást amit a Verilog forrásnyelvi modulban használni akarunk. s seconds ms milliseconds us microseconds ns nanoseconds ps picoseconds fs femtoseconds `timescale 10 ns / 1 ns module parameter delay = 1.76; endmodule A delay értéke 18 ns lesz a kerekítés miatt. A numerikus értékek az idő_egység többszöröseként értelmezettek A felbontásnak megfelelő értékre kerekít a rendszer. A szimuláció során az eltérő időegységet használó modulok keverhetők. 40

41 KÓD SZERVEZÉS ASSIGNMENTS Procedural Assignment (=) Procedural -Continuous (assign) Non-Blocking (<=) Assignment Delay Control FLOW CONTROL Case Branching Loops Parallel Activity (fork... join) Assignment Event Control Intra-Assignment Delay TIMING Wait Named Events Pin-Pin Delay CODE MANAGEMENT Function Calls Task Calls Prog. Lang. Interface (PLI) 41

42 TASZKOK ÉS FÜGGVÉNYEK CÉL: A meglévő, korábbi Verilog kód újra felhasználása A kód kisebb egységekre osztása Érthetőség növelése Adat rejtés, információ redukció modulok között Kód karbantarthatóságának növelése 42

43 BEÉPÍTETT TASZKOK ÉS FÜGGVÉNYEK Néhány példa a beépített rendszer taszkokra: $rtoi Valós konvertálása egésszé csonkolással. $itor Egész konvertálása valóssá. $realtobits Valós konvertálása 64 bites reprezentációra. $bitstoreal Bitminta konvertálása valósra. $time Visszaadja az aktuális szimulációs időt (skálázott 64 bites érték). $stime Visszaadja az aktuális szimulációs időt 32 bites formátumban. $realtime Visszaad egy olyan valós értéket, ami a hívó modul időegysége szerint skálázott. 43

44 FÜGGVÉNYEK CÉL: Procedurális utasítások és értékadások kiértékelését valósítja meg. Modulban deklarálható Kifejezésekben hívható Használhat lokális változókat Nem tartalmazhat időzítés vagy eseményvezérlő utasításokat Legalább egy bemeneti változója kell legyen 44

45 PÉLDA MULTIPLEXER MEGVALÓSÍTÁSÁRA FÜGGVÉNYHÍVÁSSAL module mux4_df_fc (a, b, c, d, select, y_out); input a, b, c, d; input [1:0] select; output y_out; assign y_out = mux (a, b, c, d, select); function mux; input a, b, c, d; input [1:0] select; case (select) 2'b00: mux = a; 2'b01: mux = b; 2'b10: mux = c; 2'b11: mux = d; default: mux = 'bx; endcase endfunction endmodule Megjegyzés: A 2 b00 jelölés kétbites értéket jelöl. 45

46 PÉLDA AUTONÓM LFSR - PSZEUDÓ VÉLETLEN GENERÁTOR module Autonomous_LFSR (Clock, Reset, Y); parameter Length = 8; input Clock, Reset; Y[7] output [Length-1: 0] Y; reg [Length-1: 0] Y; c[1] c[0:7] = [1100_1111] y c[7] Y[0] h91 h h8c h46 (posedge Clock) begin if (!Reset) Y = 8 b1001_0001; else Y = LFSR_Value (Y); end 46

47 PÉLDA AUTONÓM LFSR - FÜGGVÉNY DEKLARÁCIÓ ÉS HASZNÁLATA function [Length-1: 0] LFSR_Value; parameter Length = 8; parameter [1:Length-1] Tap_Coefficient = 7 b1001_111; input [Length-1: 0] LFSR_state; integer Cell_ptr; begin for (Cell_ptr = Length -2; Cell_ptr >= 0; Cell_ptr = Cell_ptr -1) if (Tap_Coefficient [Cell_ptr + 1] == 1) // A visszacsatolások helyén LFSR_Value [Cell_ptr] = LFSR_state [Cell_ptr + 1] ^ LFSR_state [0]; // XOR else LFSR_Value [Cell_ptr] = LFSR_state [Cell_ptr +1]; // Egyszerű shift LFSR_Value [Length - 1] = LFSR_state [0]; end endfunction endmodule 47

48 PÉLDA AUTONÓM LFSR c[0:7] = [1100_1111] Y[7] c[1] c[7] Y[0] h91 h h8c h46 48

49 TASZKOK Modulon belül deklarálható. Viselkedési leíráson hívható. Végrehajtása után a vezérlést a következő utasításra adja. Kifejezéseken belül nem használható. A taszkoknak paraméterek átadhatók. A 'return' után az eredmények elérhetők. Lehetnek lokális változói. Tartalmazhat időzítés és eseményvezérlő utasításokat. Rekurzívan hívható (saját magából, vagy egy másik taszkból, melyet önmaga hívott). (Közös memória - Statikus változók - Potenciális lehetőség mellékhatásokra). 49

50 PÉLDA A TASZKOK HASZNÁLATÁRA module Autonomous_LFSR3 (Clock, Reset,Y); parameter Length = 8; parameter [1:Length-1] Tap_Coefficient = 7'b1001_111; input Clock, Reset; output [Length-1: 0] Y; reg [Length-1:0] Y; integer Cell_ptr; (posedge Clock) begin if (!Reset) Y = 8'b1001_0001; // Reset állapot 8'h91 else Update_LFSR; end 50

51 PÉLDA A TASZKOK HASZNÁLATÁRA task Update_LFSR; reg [Length-1:0] LFSR_state; begin LFSR_state = Y; for (Cell_ptr = Length -2; Cell_ptr >= 0; Cell_ptr = Cell_ptr -1) if (Tap_Coefficient [Cell_ptr +1] == 1) // A visszacsatolások helyén Y [Cell_ptr] = LFSR_state [Cell_ptr+1] ^ LFSR_state [0]; else Y [Cell_ptr] = LFSR_state [Cell_ptr +1]; Y [Length-1] = LFSR_state [0]; end endtask endmodule 51

52 END OF Part 4b 52