Einführung in Verilog HDL

Transkript

1 Einführung in Verilog HDL Technische Grundlagen der Informatik II Sommersemester 2009 Version 3/2009 Fachgebiet Rechnerarchitektur, Fachbereich Informatik, TU Darmstadt Versionen 4/2004, 4/2005 M. Halbach, R. Hoffmann, 4/2006 M. Halbach 4/2007, 10/2007, 4/2008, 3/2009 R. Hoffmann

2 Inhalt: Verilog HDL Hardware-Beschreibungssprachen Syntax-Schreibweise Beschreibungsarten Konstanten und Variablen Operatoren graue Farbe: Zusatzinformation für Fortgeschrittene Modul: Definition, Zuweisungen, Statements Delay Control, Event Control Verilog-Programmbeispiele ANHANG 1: Vertiefungen ANHANG 2: Simulation ANHANG 3: Weitere Programmbeispiele V-2

3 Hardware-Beschreibungssprachen Zweck Spezifikation im Entwurfsprozeß für den manuellen Entwurf automatische Hardware-Synthese Simulation Dokumentation des entworfenen Systems entnommen aus Werbebroschüren für Xilinx Spartan -3E FPGAs, 2005 bzw. Altera Cyclone Series, August 2004 Kommunikation zwischen Software- und Hardware-Spezialisten Veranschaulichung von Hardware-Strukturen und Algorithmen in der Lehre Sprachen Frühe Sprachen CDL: Computer Description Language) CHU ca CASSANDRE: Mermet ca HDL (Hardware-Description-Language), R. Hoffmann VHDL ( ,IBM, TI, Intermetrics), VERILOG HDL(1984, Gateway Design Automation) SystemC, System Verilog V-3

4 Eigenschaften von Hardware- Beschreibungssprachen Techn. Grundlagen der Informatik 2, SS 09, R. Hoffmann, TUD Beschreibungsarten strukturell (Komponenten mit ihren Verbindungen) algorithmisch (ablauforientiert) Abstraktionsniveaus Schalter, Transistor, Wire Gatter, Komponenten Automaten Algorithmen (Funktionelle Ebene) Low High V-4

5 Eigenschaften von Hardware- Beschreibungssprachen (2) Techn. Grundlagen der Informatik 2, SS 09, R. Hoffmann, TUD Parallelverarbeitung Grundprinzip: Alle Komponenten arbeiten gleichzeitig parallel parallele Prozesse synchrone/asynchrone Parallelität Parallele Übertragung von Signalwerten über Verbindungsleitungen im Zeitraster, mit Zeitverzögerungen Hardware-Datentypen Signale, Wires Taktsignale synchrone Register, asynchrone Speicher und Latches Ereignisse (Flanken) Datenformate, Signalwerte Bitvektoren, Bitmatrizen Mehrwertige Logik (0, 1, Hochohmig, Kurzschluss, Pullup,...) V-5

6 Verwendete Syntax-Ausdrücke [ ] optional (0 oder 1 mal) { } wiederhole beliebig oft (0 bis n mal) ( ) wiederhole mindestens einmal (1 bis n) ( ) normale Klammer-Zeichen id Bezeichner mehrere Auswahlmöglichkeiten ::= Hilfsbezeichnerdefinition V-6

7 Beschreibungsarten Strukturbeschreibung und Algorithmische Beschreibung, am Beispiel eines Halbaddierers

8 Halbaddierer: Funktionsweise Inputs: a, b Outputs Summe s Übertrag c (carry) a b a b c s c s V-8

9 Strukturbeschreibung mit Gatter-Bausteinen module hadd3(a, b, c, s); input a, b; output c, s; xor xor1(s, a, b); and and1(c, a, b); c s // Baustein aktueller Name (Verbindung) endmodule a b Kennzeichen: Verbindung expliziter Modul-Instanzen. V-9

10 mit logischen Operatoren module hadd2(a, b, c, s); input a, b; output c, s; assign s = a ^ b; assign c = a & b; endmodule a b // ^ exklusiv-oder // & und Kennzeichen: Verbindung impliziter Modul- Instanzen. c s Die Operatoren werden durch den Übersetzer durch primitive Moduln ersetzt. V-10

11 mit hochsprachlichen Operatoren module hadd1(a, b, c, s); input a, b output c, s; // sind hier implizit wire assign {c,s} = a + b; // {, } Konkatenation endmodule a b Kennzeichen: Verbindung impliziter Modul- Instanzen. c HA s Die Operatoren durch den Übersetzer auf primitive Moduln abgebildet. Dabei kann der hochsprachliche Operator auf einfachere Operatoren/Moduln übersetzt werden. V-11

12 Algorithmische Beschreibung auch bezeichnet als prozedurale / funktionale / Verhaltens Beschreibung module input output c, s; hadd1(a, b, c, s); a, b // sind hier implizit wire or b) // immer bei Änderung {c,s} = a + b; endmodule Bemerkung: wird auch als kombinatorischer always-block bezeichnet. Kennzeichen: Das Verhalten wird prozedural beschrieben. Vorstellung: Das Verhalten wird simuliert. V-12

13 Konstanten und Variablen Techn. Grundlagen der Informatik 2, SS 09, R. Hoffmann, TUD

14 Konstanten Zahlen Zeichenketten, siehe Anhang Parameter Compilerdirektive graue Farbe: Zusatzinformation für Fortgeschrittene V-14

15 Zahlen, binär codiert Ohne Festlegung der Bitbreite Syntax: Basis Zahl Basis 'b (binär, 2) 'o (oktal, 8) 'd (dezimal, 10), 'h (hexadezimal, 16) Mit Festlegung der Bitbreite Syntax: Bitbreite Basis Zahl 'b0010 4'b10 V-15

16 Zahlen-Beispiele 'b00010 // binär 147 // dezimal 'h7ff // hexadezimal 'o422 // oktal 5'b10 // 5-bit binär 'd3 // 5-bit dezimal -5'b11 // negative 5-bit Binärzahl (2er Komplement) V-16

17 Variablentypen wire wand, wor reg (hat verschiedene Bedeutungen) Hardwareunabhängige Datentypen integer (z. B. für Zählschleifen) real time (für Zeitmarken) V-17

18 Mögliche Werte für wire, wand, wor, reg 0 logische Null (false) 1 logische Eins (true) x undefiniert, unbekannt z hochohmig (Tristate) V-18

19 wire zur Datenweiterleitung Nur zum Transport, keine Speicherung! Zur Verbindung von Primitiven und Modulinstanzen Eine Verbindungsleitung wire a; Leitungsbündel wire [4:2] b; Zusatzinfomation: wire mit Verzögerung wire [1:0] #(2) wires_with_2_clocks_delay; V-19

20 and, or and ergibt 0 if mindestens eine 0 1 if beide Inputs 1 x sonst or ergibt 1 if mindestens eine 1 0 if beide Inputs 0 x sonst Tabellen dazu siehe Anhang V-20

21 reg (mehrdeutig) Vier mögliche Bedeutungen 1. (temp) Hilfsvariable, dient nur zur Berechung, hat keine physikalische Entsprechung, wird bei der Synthese wegoptimiert 2. (tempwire) zur prozeduralen Beschreibung von Schaltnetzen, verwendet anstelle von wire/assign 3. (memory) zur asynchronen Speicherung (entspricht Latch/RS-FF) 4. (sync) Synchrones Register Wenn die Bedeutung nicht eindeutig klar ist, dann zusätzliche Kommentare verwenden!! V-21

22 Bitvektoren und Bitmatrizen Speicher oder Registersätze werden als Vektoren aus Registern deklariert Deklaration reg a; // 1 Bit breites Register reg [7:0] b; // 8 Bit breites Reg. (Bit 7 = MSB) reg [0:7] b; // 8 Bit breites Reg. (Bit 0 = MSB) reg [7:0] d [0:10]; // 11 8-Bit-Register reg c [0:15]; // 16 1-Bit-Register V-22

23 Operatoren Techn. Grundlagen der Informatik 2, SS 09, R. Hoffmann, TUD

24 Dyadische arithmetische Operatoren + Addition - Subtraktion * Multiplikation / Division % Modulo reg und wire: Operatoren werden vorzeichenlos interpretiert im neuen Standard auch mit Vorzeichen definierbar real und integer: mit Vorzeichen Falls irgendein Bit eines Operanden undefiniert ( x ) ist, ist der Wert des Gesamtergebnisses ebenfalls undefiniert! V-24

25 Monadische arithmetische Operatoren Minus (Vorzeichenwechsel) +Plus (Vorzeichen bleibt erhalten) V-25

26 Vergleichsoperatoren Ergebnis 0, 1 oder x > größer >= größer oder gleich < kleiner <= kleiner oder gleich == gleich!= ungleich Ergebnis 0 oder 1 === bitweise identisch (auch x, z)!== mindestens ein Bit nicht identisch V-26

27 Logische Operatoren für Abfragen Für Operanden mit 1 Bit Breite (true/false)! cond nicht cond1 && cond2 und cond1 cond2 oder Bedingte Wertberechnung result = cond? truevalue : falsevalue // if cond=true then result = truevalue // else result = falsevalue V-27

28 Bitweise Verknüpfung ~ Negation (not) & und (and) oder (or) ^ exklusiv-oder (xor) ~& nicht-und (nand) ~ nicht-oder (nor) ~^ oder ^~ gleich, Äquivalenz (xnor) in Klammern stehen die Namen der entsprechenden Primitiven (Grund-Gatter- Bausteine) V-28

29 Monadische Reduktion Reduktion: alle Bits des Vektors X werden miteinander durch die Operation verknüpft, Ergebnis ist ein Bit & A und (and) A oder (or) ^ A exklusiv-oder (xor) ~& A nicht-und (nand) ~ A nicht-oder (nor) ~^ A gleich (xnor) z. B. 'b 'b1 &b[2:0] b[2] & b[1] & b[0] V-29

30 Shifts x << n shift x nach links um n Bits x >> n shift x nach rechts um n Bits V-30

31 Konkatenation {, } Aneinanderreihung von Bits oder Bitvektoren { a, b[2:1], c[9:3] } V-31

32 Replikation { Rep-Anzahl { expr }} statt {b, b, b} einfacher {3{b}} z. B. sign-extension B[15:0] = {{8{A[7]}}, A[7:0]} Ergebnis: A 7 A 7 A 7 A 7 A 7 A 7 A 7 A 7 A 7 A 6 A 5 A 4 A 3 A 2 A 1 A 0 V-32

33 Modul Modul-Definition Modul-Instanziierung Parallele Ausführung Zuweisungen

34 Modul-Definition Beispiel module hadd2(a, b, c, s); input a, b; output c, s; xor xor1(s, a, b); // assign s = a ^ b; assign c = a & b; endmodule Syntax module modulid ( [ portid {, portid} ] ); { input output inout [ [ range ] ] portid {, portid } ; } { declaration } // Instanziierung von Moduln { parallel_statement } // initial, always, assign endmodule V-34

35 Modul-Instanziierung (Declaration) Beispiele xor xor1(s, a, b), xor2(t, c, d); hadd add1(.a(a),.s(sum)); //.formalerparam(aktuellerparam) Syntax moduleid [ #( parameter {, parameter } ) ] { instance_name ( port_connections ), } instance_name ( port_connections ) ; port_connections ::= [ value ] {, [ value ] }.port ( value ) {,.port ( value ) } V-35

36 Parallele Ausführung aller Parallel_Statements eines Moduls initial sequential_statement einmalig ausgeführt zur Initialisierung, für seq. Abläufe always sequential_statement (Endlos-)Schleife, meist Eventgetriggert assign wireid = expression ; permanente Zuweisung (Verdrahtung) continuous assignment V-36

37 Zuweisungen continuous assignments (assign) procedural assignments

38 continuous assignments: assign Verwendung Unmittelbare Weiterleitung von Signalwerten Eingänge werden kontinuierlich ausgewertet und der Ausgang wird automatisch aktualisiert dient der Beschreibung von Schaltnetzen (reine Kombinatorik) z. B. assign out = in1 in2; assign [#delay] wireid = expression ; V-38

39 procedural assignments Nur innerhalb initial - oder always -Blöcken für reg-variablen zulässig Zwei Formen Blockierend, asynchron regid = expression Nicht-blockierend, synchron regid <= expression V-39

40 procedural assignments Blockierend, asynchron regid = expression Blockierende Zuweisungen erfolgen nacheinander (in der durch den Ablauf vorgegebenen Reihenfolge) a=3; b=7; a=b; b=a; (Ergebnis: a=b=7) Anwendung Zwischenspeichern von temporären Werten, die in der Hardware oftmals Signalen entsprechen. Beachte: Die Kommentierung solcher reg-variablen als Hilfsvariablen ist hilfreich für das Verständnis und die Dokumentation der Beschreibung. Dadurch wird die Konfusion mit synchronen Registern vermieden. V-40

41 procedural assignments Nicht-Blockierend, synchron regid <= expression Auswertung (Masterphase) Alle rechten Seiten der Anweisungsgruppe werden quasi-parallel berechnet und zwischen gespeichert. (Slavephase) Alle zwischen gepeicherten Werte werden quasi-parallel den Registern zugewiesen. Implizit werden Hilfsvariablen reserviert. Die synchrone Arbeitsweise wird emuliert. V-41

42 Beispiel: Vertauschen von Werten clk) begin a <= b; b <= a; end Beispiel: Werte vor dem Takt: a=3, b=7 Werte nach dem Takt: a=7, b=3 V-42

43 Beispiel: JK-Flipflop module jkff(clk, j, k, q, _q); input clk, j, k; output q, _q; reg q; // syncreg initial q = 1'b0; clk) q <= (j &!q) (!k & q); assign _q =!q; endmodule Q + = J.Q + K.Q V-43

44 Statements Techn. Grundlagen der Informatik 2, SS 09, R. Hoffmann, TUD

45 Block Beispiel begin: Schleife integer i; for (i=0; i<5; i = i + 1) end Syntax begin [ : blkid { declaration } ] { sequential_statement } end V-45

46 Bedingte Ausführung: if, case if ( expr ) sequential_statement [ else sequential_statement ] case casex casez ( expr ) ( expr {, expr } : sequential_statement ) [ default: sequential_statement ] endcase Es wird kein break benötigt! V-46

47 Beispiel case, 4-Kanal Multiplexer module mux4_case(a, b, c, d, select, y, ena); input a, b, c, d, ena; input [1:0] select; output reg y; // tempwire // y ist Hilfsvariable, kein Hardware-Register b, c, d, select) // bei Änderung von... if (ena) case (select) 0: y = a; 1: y = b; 2: y = c; 3: y = d; default: y = 1'bx; // undefined endcase else y = 1'bz; // hochohmig endmodule V-47

48 Schleifen forever sequential_statement for ( assignment; condition_expression; assignment ) sequential_statement while ( condition_expression ) sequential_statement repeat ( amount_expression ) sequential_statement V-48

49 Timing Control Delay Verzögerungszeit Event Ereignis Wait Warten auf Bedingung, s. Anhang V-49

50 Delay Control Beispiele b = #8 a; a wird sofort ausgewertet, zwischengespeichert und nach 8 Zeiteinheiten zugewiesen #8 b = a; erst wird 8 Zeiteinheiten gewartet, dann ausgewertet und zugewiesen Syntax #delay sequential_statement regid = #delay expr; mit delay ::= number ( expr ) V-50

51 Event Control Ausführung erst nach dem Eintreffen eines Ereignisses Ereignis: Wertänderung von (input, inout, wire oder reg) oder benannter Event Am Modulbeginn Deklaration event eventid ; Auslösen durch -> eventid V-51

52 Event Control (2) Definition event event ::= Identifier [ posedge negedge ] expr Warten auf Event, danach ( event { or event } ), sequential_statement Beispiel: Clock) begin end expr auswerten, nach event zuweisen regid ( event { or event } ) expr ; V-52

53 Verilog-Beispielprogramme Techn. Grundlagen der Informatik 2, SS 09, R. Hoffmann, TUD

54 Beispiele Parity Full Adder Counter, synchron Zustandsmaschine Ampel weitere Beispiele s. Anhang 3 V-54

55 Modul Parity module parity (x, odd, even); input [8:0] x; output odd, even; assign odd = ^x; // Exor Reduktion assign even = ~^x; endmodule odd x 9 even V-55

56 Testumgebung Parity module testbed( ); reg [8:0] I; // Datenspeicher in Umgebung neu parity test(i, odd, even); // Instanz initial begin I=5; #25 I=2; #25; // Testablauf end initial #50 $finish; // nach 50 Zeiteinheiten Ende endmodule V-56

57 Halbaddierer HA (Wdh.) module hadd1(a, b, c, s); input a, b output c, s; // Signale assign {c,s} = a + b; // {, } Konkatenation endmodule a b HA c s V-57

58 Volladdierer FA soll aus HAs zusammengesetzt werden Eingabe drei Bits Daten (a, b) a b Carry-In-Bit (cin) FA cin Ausgabe zwei Bits Summenbit (s) cout s Carry-Out-Bit (cout) HA, HA? V-58

59 Wiederverwendung von Modulen module VolladdiererFA(a, b, cin, cout, s); FA a b input a, b, cin; output cout, s; wire s1; wire [1:0] c; HA c[1] s1 HA c[0] cin hadd2 a1(a, b, c[1], s1), a2(s1, cin, c[0], s); cout s assign cout = c[0] c[1]; endmodule V-59

60 Synchroner Zähler neu Eingabe Clock Reset Ausgabe Zählerzustand (Q), z. B. 2 Bit breit V-60

61 Modul Synchroner Zähler module Counter(Reset, Clock, Q); input output [1:0] Q; reg [1:0] Q; initial Q = 1; Reset, Clock; Clock) if (Reset) Q <= 0; else Q <= Q + 1; endmodule // output reg [1:0] Q V-61

62 Testumgebung Synchroner Zähler module testbed(); reg Reset, Clock; // mem, asyn wire [1:0] Q; Counter test (Reset, Clock, Q); initial repeat (7) begin Clock=0; #5 Clock=1; #5; // Taktgenerator end initial begin #2 Reset = 1; #10 Reset = 0; end initial #80 $finish; endmodule V-62

63 Zustandsmaschine/-automat Ampel module ampel(clk, schalte, rot, gelb, gruen); input clk, schalte; output rot, gelb, gruen; reg [2:0] state; initial state = 3'd0; clk) if (schalte) case (state) 3'b000: state <= 3'b010; 3'b010: state <= 3'b101; 3'b101: state <= 3'b011; 3'b011: state <= 3'b000; default state <= 3'b000; endcase assign {gruen, gelb} = state[2:1]; assign rot =!state[0]; endmodule V-63

64 Verilog 2001 Zusammenfassen von input x; wire x; input wire x output y; reg y; output reg y Deklarationen der Parameter direkt in den Portlisten module mm(input wire x, output reg y); task tt(input wire x, ouput wire y); function ff(input wire x); Generate: Erzeugung regelmäßiger Strukturen Sensitivitätsliste or x2) x2) Vorzeichenbehaftete Arithmetik: signed Multidimensionale Felder V-64

65 Weitere Informationen IEEE Standard Verilog Hardware Description Language, IEEE Std 1364 Übersichtsblatt (teilweise BNF-Notation) V-65

66 Kostenlose Programme Simulation Icarus Verilog GTKWave Synthese Altera Quartus Web Edition Xilinx ISE V-66

67 Ausgabe mit Icarus und GTKWave initial begin $dumpfile("ausgabe.vcd"); $dumpvars(0); end Aufruf: iverilog meine_datei.v vvp a.out winwave ausgabe.vcd gtkwave ausgabe.vcd (Windows) (X) V-67

68 ANHANG 1: Vertiefungen Konstanten: Zeichenketten Parameter Statement Compilerdirektive Wired And/Or Vergleichsoperatoren "a == b" und "a === b" case, casex, casez Block- oder Taskabbruch wait, fork, expliziter event wire-verzögerungen Unterprogramme: Task, Function V-68

69 Zeichenketten Durch doppelte Anführungszeichen eingeschlossen z. B. "Text" V-69

70 Parameter Statement Zuordnung von Konstanten zu symbolischen Namen parameter identifier = constant_expression ; Veränderung im aufrufenden Modul mit moduleid #( alle parameter ) instanz; defparam instance.identifier = constant_expression ; V-70

71 Parametrisierung module addierer(a, b, s); parameter n = 8; input [n 1 : 0] a, b; output [n 1 : 0] s; assign s = a + b; endmodule module multiadd(a, b, c, s); input [3 : 0] a, b, c; output [3 : 0] s; wire [3 : 0] s1; addierer #(4) x(a, b, s1), y(c, s1, s); endmodule V-71

72 Compilerdirektive Deklaration mit `define name wert Verwendung mit `name (wird ersetzt durch wert) z. B. `define schwelle 8 if (zaehler == `schwelle) V-72

73 and, or and ergibt 0 if mindestens eine 0 1 if beide 1 x sonst or ergibt 1 if mindestens eine 1 0 if beide 0 x sonst and 0 1 x z x x x 0 x x x z 0 x x x or 1 0 x z x x x 1 x x x z 1 x x x V-73

74 wand, wor wired and und wired or für Netze mit mehreren Quellen wand 0 1 x z x 1 x 0 x x x z 0 1 x z wor 0 1 x z x x x 1 x x z 0 1 x z V-74

75 Vergleichsoperatoren Ergebnisse von "a == b" und "a === b" a b == === 'bx 'bx 0 0 'bz 'bx 'bx 'bx 0 1 'bz 'bx 0 a b == === 'bx 0 'bx 0 'bx 1 'bx 0 'bx 'bx 'bx 1 'bx 'bz 'bx 0 'bz 0 'bx 0 'bz 1 'bx 0 'bz 'bx 'bx 0 'bz 'bz 'bx 1 V-75

76 case, casex, casez case exakter bitweiser Vergleich inkl. 'x' und 'z'- Werten casez 'z'-werte in der case- und den Vergleichs- Expressions werden als don't care behandelt casex 'z' und 'x'-werte werden als don't care behandelt V-76

77 Mögliche Werte bei case/casex/casez bei expr case casez casex 0 0 0, z 0, x, z 1 1 1, z 1, x, z x 0, 1, x, z z 0, 1, x, z 0, 1, x, z? 0, 1, x, z die aufgeführten Werte werden als Übereinstimmung gewertet angegeben ist nur der niedrigste Standard, z. B. bei Icarus ist bei case auch x und z möglich wenn keine Bedingung zutrifft, wird der default-teil verwendet V-77

78 Block- oder Taskabbruch disable taskid blockid ; z. B. initial begin: clock_loop clock = 0; forever begin #5 clock=1; #5 clock=0; end end initial #350 disable clock_loop V-78

79 Wait Statement Erst wenn Auswertung der Bedingung den Wert 'true' ergibt, erfolgt Ausführung wait ( expr ) sequential_statement V-79

80 fork Sequentielle Blöcke parallel durchführen Syntax: fork [ : blkid { declaration } ] { sequential_statement } join z. B. fork begin end // thread 1 begin end // thread 2 join // Aufspaltung in 2 threads // Zusammenführung V-80

81 Unterprogramme Tasks und Funktionen

82 Unterprogramme Task Ersatz für prozedurale Anweisungen Function Ersatz für einen Ausdruck (expression) task taskid ; { input output inout [ [ range ] ] portid {, portid } } ; { declaration } { sequential_statement } endtask Aufruf: taskid [ ( expr {, expr } ) ] ; function [ [ range ] type ] // default: 1 Bit functionid ; ( input [ [ range ] ] paramid ; ) { declarations } begin { sequential_statement functionid = expr ; } end endfunction V-84

83 Task Aufruf innerhalb von always-, initial-block nicht innerhalb von assign Ein-/Ausgabe-Parameter gleiche Reihenfolge beim Aufruf wie in der Definition Rekursiver Aufruf ist möglich, jedoch keine automatische Speicherverwaltung (d. h. nur statische Variablen) V-85

84 Beispiel Task Definition: Addition task add_values; output c_out; output [3:0] sum; input [3:0] data_a, data_b; input c_in; begin #5 { c_out, sum } <= data_a + (data_b + c_in); end endtask Aufruf add_values(cout, s, da, db, cin); V-86

85 Function überall verwendbar auch im assign-statement Deklaration: f(inputs) inputs, Parameterübergabe: by value Rückgabe über Zuweisung an Funktionsnamen f V-87

86 Einschränkungen für Functions Function soll in reine Logikfunktion umsetzbar sein Ausgabe muss sofort verfügbar sein deshalb nicht erlaubt: delay control (#) event control wait Rekursion V-88

87 Beispiel Function function [3:0] max; input [3:0] op_a, op_b; begin max = (op_a >= op_b)? op_a : op_b; end endfunction V-89

88 ANHANG 2: Simulation Einstellungen Ausgabemöglichkeiten

89 Testumgebung wird für die Simulation benötigt, nicht für die Synthese enthält den zu testenden Modul enthält Taktgenerator, z.b. reg clk; initial clk = 1'b1; always #1 clk =!clk; enthält Hilfsregister Initialisierungen Simulationsablauf (Testablauf) mit Beendigung ($finish) V-91

90 Zeiteinheit, Simulation beenden `timescale simul_zeiteinheit / anzeigetakt z. B. `timescale 1ns / 1ns Verzögerung #2 bedeutet dann 2 ns $finish z. B. initial #500 $finish; V-92

91 Ausgabe auf die Konsole $write ( formatstring {, varid } ) $display ( formatstring {, varid } ) wie $write, mit zusätzlichem Zeilenende $monitor ( formatstring {, varid } ) bei Änderung einer Variablen erfolgt eine Ausgabe V-93

92 Beispiele Beispiel: $write(" AC hat den Wert %h", ac); Beobachtung des Signals data $display ("Wertaenderung von data: %0b ", data, $time); V-94

93 formatstring ähnlich wie in C mit % %b %c %d %h %o %s %t display in binary format display in ASCII character format display in decimal format display in hex format display in octal format display in string format display in time format V-95

94 Längenangabe bei formatstring Ohne Längenangabe z. B. %b, entsprechend Bitbreite (rechtsbündig) mit Längenangabe 0 z. B. %0b, linksbündig ohne führende Nullen mit Längenangabe größer Bitbreite: zusätzliche Leerzeichen z. B. %12b V-96

95 Externe Daten einlesen $readmemb("dateiname_binär", memory [, startadresse [, endadresse]]) $readmemh("dateiname_hexadezimal", memory [, startadresse [, endadresse]]) Dateiinhalt: je Adresse ein Zahlenwert der angegebenen Basis mit Leerzeichen oder Zeilenumbruch voneinander getrennt Anzahl Einträge muss stimmen! V-97

96 Beispiel: Externe Daten einlesen Verilog-Fragment reg [7:0] mem [1:5]; initial $readmemh("init.txt", mem, 1, 3); Dateiinhalt init.txt Ergebnis mem[1] = 9, mem[2] = 8, mem[3] = 4 mem[4] und mem[5] sind nicht initialisiert V-98

97 Datenänderung aufzeichnen $dumpfile("dateiname.vcd"); $dumpvars(level); $dumpon; $dumpoff; mit level ::= 0 1 level = 1 nur Variablen des aktuellen Moduls protokollieren level = 0 alle Variablen (eigene und auch untergeordnete Module) protokollieren V-99

98 ANHANG 3: Weitere Beispiele Vorwärts/Rückwärts-Zähler Arithmetic and Logical Unit (ALU) mit Test-Umgebung (FSM) 8-Bit-Tri-State-Bus Beschreibung einer Volladdierer-Kette

99 Vorwärts/Rückwärts-Zähler Eingabe Clock (Takt) Reset (auf Null setzen) Incr (erhöhe um eins) Decr (verringere um eins) Ausgabe 2-Bit-Wert (Z) V-101

100 Modul Vorwärts/Rückwärts-Zähler neu module Counter(Clock, Reset, Incr, Decr, Z); input Clock, Reset, Incr, Decr; output reg [1:0] Z; // syncreg mit output Clock) begin if (Reset) Z <= 0; if (Incr) Z <= Z + 1; if (Decr) Z <= Z 1; end endmodule V-102

101 Testumgebung Vorwärts/Rückwärts-Zähler module testbed(); reg Clock, Reset, Incr, Decr; wire [1:0] Z; Counter test(clock, Reset, Incr, Decr, Z); initial Clock=0; always #1 Clock=~Clock; initial #16 $finish; initial // Reset, Incr, Decr: nächste Folie endmodule V-103

102 Zeitdiagramm Vorwärts/Rückwärts-Zähler initial begin #0 Reset=1; Incr=0; Decr=0; #2 Reset=0; Incr=1; // zählen #4 Decr=1; // Achtung auf die Konfliktmöglichkeit! #2 Incr=0; Decr=1; // unterschiedliche Interpretationen! end hier wird Decr interpretiert V-104

103 Vorwärts/Rückwärts-Zähler mit Konfliktauflösung module Counter(Clock, Reset, Incr, Decr, Z); input Clock, Reset, Incr, Decr; output [1:0] Z; reg [1:0] Z; initial Z = 0; Clock) begin if (Reset) Z <= 0; else if (Incr) Z <= Z+1; else if (Decr) Z <= Z-1; end endmodule V-105

104 Arithmetic and Logical Unit (ALU) Dateneingänge a, b Ergebnis y a 8 8 b Operation op op 2 ALU 1: y = a 8 2: y = nand (a, b) y sonst: y = 0 V-106

105 Definition der ALU module alutype(op, a, b, y); input [1:0] op; //alu function input [7:0] a,b; output [7:0] y; assign y = (op == 1)? a : (op == 2)? ~(a & b) : 0; endmodule V-107

106 Test-Umgebung Aufgabe: alle möglichen ALU-Operationen testen sync. Register clock stop ra rb Input-Operanden Steuerwerk Steuersignale Mikrooperationen alu alutype a b state rop Operation op ALU FSM y y:wire Test-Umgebung stwrw ry Ergebnis V-108

107 Test-Umgebung: Bausteine und Taktgenerator module stwrw(); reg [1:0] state; reg [7:0] ra, rb, ry; wire [7:0] y; reg [1:0] rop; reg stop; reg clock; // boole alutype alu(rop, ra, rb, y); initial begin clock = 0; stop = 0; end initial #5 repeat (40) #5 clock =!clock; initial wait clock) $finish; clock Steuerwerk state FSM stop Steuersignale Mikrooperationen rop Operation sync. Register ra rb alu alutype a b ALU op y y:wire Test-Umgebung stwrw ry Ergebnis V-109

108 Test-Umgebung: Zustandsautomat (FSM) initial state = 0; clock) case (state) 0: begin rop<=0; ry<=0; state <= 1; ra <= 2; rb <= ~0; end 1: begin rop<=1; ry<=y; state<= 2; end 2: begin rop<=2; ry<=y; state<= 3; end 3: begin rop<=0; ry<=y; state<= 0; stop<= 1; end endcase endmodule rop<=0; ry<=0; ra <= 2; rb <= ~0 rop<=1; ry<=y rop<=2; ry<=y rop<=0; ry<=y; stop<= 1 V-110

109 Die Zustände (Post- und Preconditions) rop=0: y=0 ry= ra=2 rb=11..1 stop=1 rop=1: y=ra=2 ry=0 ra=2 rb=11..1 rop=x: y=x ry=x ra=x rb=x stop=0 rop=0: y=0 ry=0 ra=2 rb= rop<=0; ry<=0; ra <= 2; rb <= ~0 rop<=1; ry<=y rop<=2; ry<=y x = undefined rop=2: y=nand(ra,rb)= ry=2 ra=2 rb= rop<=0; ry<=y; stop<= 1 V-111

110 Simulation (Test) 0ns 10ns 20ns 30ns 40ns 50ns stwrw.state stwrw.ra stwrw.rb stwrw.ry stwrw.y stwrw.rop stwrw.clock stwrw.stop FF 0 2 FD 0 2 FD stop=0 rop=0: y=0 ry=0 ra=2 rb=11..1 rop=1: y=ra=2 ry=0 ra=2 rb=11..1 rop=2: y= ry=2 ra=2 rb=11..1 rop=0: y=0 ry= ra=2 rb=11..1 stop=1 V-112

111 Beispiel 8-Bit-Tri-State-Bus module bustreiber(bus, send, dout, out); inout [7:0] bus; input send; input [7:0] dout; output [7:0] din; assign bus = send? dout : 8'bzzzzzzzz; assign din = bus; endmodule dout send din bus V-113

112 Beschreibung einer Volladierer-Kette Volladdierer aus Primitiven Vier-Bit-Addierer, aus 4 FA Generierung von Hardware-Strukturen V-114

113 Modul Volladdierer aus Primitiven module fulladder(sum, c_out, x, y, c_in); output sum, c_out; input x, y, c_in; wire a, b, c; xor (a, x, y); // bei den vorxor (sum, a, c_in); // definierten Gatterand (b, x, y); // primitiven sind and (c, a, c_in); // keine Bezeichner or (c_out, c, b); // notwendig endmodule V-115

114 Vier-Bit-Addierer, aus 4 FA module FourBitAdder (sum, c_out, x, y, c_in); output [3:0] sum; output c_out; input [3:0] x, y; input c_in; wire c1, c2, c3; fulladder fa0(sum[0], c1, x[0], y[0], c_in); fulladder fa1(sum[1], c2, x[1], y[1], c1); fulladder fa2(sum[2], c3, x[2], y[2], c2); fulladder fa3(sum[3], c_out, x[3], y[3], c3); endmodule V-116

115 Generierung von Hardware-Strukturen module NBitAdder #(parameter n = 4) (input [n : 1] a, input [n : 1] b, output c, output [n : 1] s); wire [n : 0] carry; assign carry[0] = 0; generate genvar i; for (i = 1; i <= n; i = i + 1) begin: fulladder_chain fulladder fa(a[i], b[i], carry[i 1], carry[i], s[i]); end endgenerate assign c = carry[n]; endmodule V-117