Beschreibungsmöglichkeiten in Verilog

Transkript

1 Fachgebiet Rechnerarchitektur Fachbereich Informatik Prof. Dr. R. Hoffmann 4/2005, 4/2007 Beschreibungsmöglichkeiten in Verilog Inhalt 1 Grundsätzliche Möglichkeiten 1.1 Strukturbeschreibung (Structural Modeling) 1.2 Prozedurale Beschreibung, Verhaltensbeschreibung, Algorithmische Beschreibung (Procedural Modeling, Behavioral Description) 2 Beschreibung von Schaltnetzen und Schaltwerken 2.1 Beschreibung von Schaltnetzen Verbindungsnetze aus Gattern und Primitiven (Gatternetz, Net) Beschreibung durch (logische) Gleichungen, Zuweisungen an Wire Beschreibung durch einen zyklischen Prozess, der durch Änderungen der Eingänge getriggert werden 2.2 Beschreibung von synchronen Schaltwerken Zähler Zähler mit Ausgabesignalen 1

2 1 Grundsätzliche Möglichkeiten 1.1 Strukturbeschreibung (Structural Modeling) Diese Form dient dazu, vorgefertigte Bausteine oder Module miteinander zu einer Struktur zu verbinden. Verwet werden Primitive wie Gates, Buffer, Transistoren oder selbstdefinierte Module. Die Verbindung der Module erfolgt über explizit oder implizit erklärte Wires. Durch die Verwung identischer Namen in den Parameterlisten der Modul-Instanzen werden implizit Wire-Verbindungen hergestellt. Beispiel Multiplexer select a and asel b not snot and bsel or y module mux(y,a,b,select); output y; input a,b,select; not n1 (snot, select); and a1 (asel, a, select); and a2 (bsel, b, snot); or or1 (y, asel, bsel); Von den Modulbeschreibungen not, and, or werden die Bausteine (Instanzen) mit den Namen n1, a1, a2, or1 erzeugt. Zur Verbindung werden hier die impliziten Wires snot, asel, bsel benutzt. 1.2 Prozedurale Beschreibung, Verhaltensbeschreibung, Algorithmische Beschreibung (Procedural Modeling, Behavioral Description) Diese Beschreibungsform ist orientiert an der klassischen sequentiellen Programmierung und am Ausführungsmodell des Simulators. Sie kann auch dazu benutzt werden, von der Hardware-Implementierung zu abstrahieren, z.b. um nur das Verhalten zu spezifizieren. In der Regel werden zyklische Prozess (always) oder einmalige Prozesse (initial) als Rahmen für die Anweisungen benutzt. Einzelne Anweisungen oder Blöcke von Anweisungen (/) werden meist durch Events gestartet. Die Abarbeitungsreihenfolge ist sequentiell oder nebenläufig parallel (z.b. fork/join, mehrere always-blöcke). Innerhalb von Prozessen dürfen nur Blocking-Zuweisungen (r = x) oder Non-Blocking- Zuweisungen (r <= x) an Register verwet werden. Dauerhafte Zuweisungen (assign) an Wire-Variablen sind dort nicht zulässig. Die Register-Variablen (reg) werden in Anhängigkeit von ihrer Verwungsart unterschiedlich interpretiert: 1. (temp) Hilfsvariable zur Berechnung, keine physikalische Bedeutung. 2

3 2. (tempwire) Sie dienen zur prozeduralen Beschreibung von Schaltnetzen anstelle von permanenten Zuweisungen (wire/assign). Zur Dokumentation dieser Verwung sollte man den Kommentar "tempwire" (für temporary wire, Hilfsvariable für wire) benutzen, insbesondere dann, wenn reg-variablen auch mit einer anderen Bedeutung im Programm verwet werden. 3. (memory) Sie dienen zur asynchronen Speicherung von Werten. Durch die Zuweisung r = x wird der Wert x der speichernden Variablen r zugewiesen. Zur Dokumentation dieser Verwungsart sollte man den Kommentar "memory" oder "store" benutzen, um den Charakter der Speicherung zu Ausdruck zu bringen. In der Hardware entspricht diese Anwung einem Latch, einem RS-FF oder einer RAM- Speicherzelle. 4. (sync) Sie dienen zur Beschreibung taktgesteuerten synchronen Registern und synchronen Automaten. In diesem Fall erfolgt die Zuweisung unter der Bedingung eines Events, insbesondere unter dem Einfluß einer Taktflanke (@(posedge clock) r <= x). Hierbei ist die Non-Blocking-Zuweisung (<=) zu bevorzugen, weil sie die klare Absicht zum Ausdruck bringt, daß mehre solcher Anweisungen synchron parallel ausgeführt werden sollen. Zur Dokumentation sollte man den Kommentar "sync" bei der Deklaration hinzusetzen, falls es im Programmstext auch andere Verwungsarten für reg gibt. Beispiele: // Einmaliger Prozess module hello; initial $display("hello Verilog"); // Einmaliger Prozess mit repeat module rep; reg clk; //boole initial clk=0; repeat(5) $display("time= %t clk=%b",$time,clk); #10 clk=~clk; // Zyklischer Prozess mit synchroner Non-Blocking-Anweisung clock) r <= r+1; 2 Beschreibung von Schaltnetzen und Schaltwerken 2.1 Beschreibung von Schaltnetzen Verbindungsnetze aus Gattern und Primitiven (Gatternetz, Net) Auf dem Niveau der Logikebene werden aus einfachen Gattern (and, or, xor, nand, nor, xnor), Treibern (buf, not, pulldown, pullup,...) und Transistoren (nmos, pmos, cmos,...) Schaltungen als Strukturen (vergl. Abschnitt 1.1) miteinander verbunden. 3

4 2.1.2 Beschreibung durch (logische) Gleichungen, Zuweisungen an Wire In der folgen Beschreibung ist z als output und gleichzeitig implizit als wire erklärt. Durch assign wird z dauerhaft das Ergebnis (x+1) zugewiesen, es erfolgt also eine Verbindung oder Verdrahtung. module incr(z,x); input [1:0] x; output [1:0] z; // wire [1:0] z; // explizite Dekl. kann hier entfallen assign z=x+1; // Alternative: wire [1:0] z=x+1; module testbench(); wire [1:0] z; reg [1:0] h; // store incr incr1(z,h); initial h=0; #10 h=1; #2 h=2; Die Signalweiterleitung über die Verbindung kann auch zeitverzögert erfolgen, in der folgen Anweisung beträgt die Verzögerungszeit 15 Einheiten. assign #15 z=x+1. Innerhalb von Modulen können auch Funktionen benutzt werden, um z.b. wie hier den Wert x+1 als Funktionswert (ohne Zeitverzögerung) zu berechnen. module testbench(); function [1:0] incr; input [1:0] x; incr=x+1; function wire [1:0] z; reg [1:0] h; // store assign z=incr(h); initial h=0; #10 h=1; #2 h=2; Prozedurale Beschreibung durch einen zyklischen Prozess, der durch Änderungen der Eingänge getriggert wird Die folge Beschreibung mit always erzeugt das gleiche äußere Verhalten wie die obige Beschreibung durch Gleichungen mit wire und assign unter Es wird eine Hilfsvariable vom Typ reg benutzt, die hier gleichzeitig mit dem Datenausgang verbunden ist. Bei der Synthese wird dasselbe Ergebnis erzielt, wie durch die Beschreibung unter // description with data change trigger module incr(z,x); input [1:0] x; output [1:0] z; reg [1:0] z; //temp z=x+1; // bei Änderung von x 4

5 2.2 Beschreibung von synchronen Schaltwerken Synchrone Automaten werden am besten mit synchronen (Non-Blocking) Zuweisungen beschrieben. Dazu zwei Beispiele Zähler Der folge Zähler zählt mit der positiven Taktflanke. Der Typ reg wird hier zur Modellierung eines synchronen flankengesteuerten Flipflops benutzt. //sync. counter module counter(z, clk); input clk; output [1:0] z; reg [1:0] z; // sync reg initial z=0; clk) z <= z+1; module testbench(); wire [1:0] z; reg clk; parameter thalf=5; parameter k=4; counter c1(z, clk); //periods initial clk=0; #(thalf); repeat(k*2+1) #(thalf) clk=~clk; In der Hardware wird sich der Ausgang eines Flipflops erst nach der Zeit t clock2output, gezählt ab der positiven Taktflanke, verändern. Diese Verzögerungszeit kann wie folgt simuliert werden: parameter tclock2output=2; initial z=0; clk) #tclock2output z <= z+1; Zähler mit Ausgabesignalen In dem folgen Beispiel wird ein Zähler beschrieben, dessen Zustände umcodiert werden und als Y ausgegeben werden. Es handelt sich um einen Moore-Automaten. Die Zuordnung der Ausgangssignale zu den Zuständen (Ausgangsfunktion) erfolgt am besten in einem getrennten Abschnitt. Für einfache Ausgangsfunktionen empfiehlt sich die Beschreibung der Ausgangsfunktion mit Assign-Zuweisungen: module Counter(Clock,Reset,Incr,Decr,Z,Y); input Clock, Reset, Incr, Decr; output [1:0] Z; reg [1:0] Z; output [2:0] Y; wire [2:0] Y; assign Y = (Z==0)?3: (Z==1)?4: (Z==2)?5:2'bx; // Ausgangsfunktion Y=g(Z) Clock) 5

6 case (Z) 0: if (Reset) Z <= 0; else if (Incr) Z <= 1; else if (Decr) Z <= 2; 1: if (Reset) Z <= 0; else if (Incr) Z <= 2; else if (Decr) Z <= 0; 2: if (Reset) Z <= 0; else if (Incr) Z <= 0; else if (Decr) Z <= 1; 2'bx: if (Reset) Z <= 0; case Die Ausgangsfunktion kann mit Hilfe einer Verilog-Funktion berechnet werden. Dabei steht der Funktionsname als temporäre Variable zur Verfügung, außerdem können weitere temporäre Variablen innerhalb der Funktion benutzt werden: function [2:0] g; input [1:0] Z; case (Z) 0: g=3; 1: g=4; 2: g=5; default: g=3'bx; case function assign Y = g(z); Eine Mischung von dauerhaften Zuweisungen mit synchronen Anweisungen ist in Verilog nicht möglich Automaten mit Ausgabesignalen und Mikrooperationen Zustandsautomaten erzeugen in der Regel Ausgabesignale, die den Zuständen zugeordnet sind. Bei Mealy-Automaten hängen die Ausgaben zusätzlich von den Inputs ab. Zusätzlich oder alternativ zu den Ausgabesignalen können synchrone Mikrooperationen in den Zuständen aktiviert werden. Man kann sich vorstellen, daß die Mikrooperationen in einem zugeordneten Operationswerk ausgeführt werden. Für den allgemeinen Fall muß man ein Beschreibungsform haben, die es erlaubt (1) die Kontrollzustände s des Automaten synchron zu verändern, (2) direkte Ausgaben y(s, x) zu erzeugen und (3) Mikrooperationen etwa der Form ra <= ra+rb in den Zuständen auszulösen. 6

7 1. Möglichkeit Programmteil 1: berechnet den neuen Zustand des Automaten und die Mikrooperationen durch synchrone Zuweisungen Programmteil 2: berechnet die Ausgangssignale durch logische Gleichungen (Zuweisungen an wire) // 1. Neuer Zustand und sync Mikrooperationen reg state, ra, rb; clock) case(state) 0: state <= 1; ra <= ra +rb; 1: state <= case // 2. Ausgabe wire y = f(state,x) 2. Möglichkeit Programmteil 1: wie 1. Möglichkeit Programmteil 2: berechnet die Ausgangssignale prozedural. // 2. Ausgabe reg y; // tempwire x) y = f(state,x) 3. Möglichkeit Der Programmteil 1 wird in zwei Teile A und B aufgespalten. Der Programmteil 2 steht separat wie unter 1. oder 2. Für das synchrone Zustandsregister state wird eine Hilfvariable nextstate als tempwire deklariert. Der erste Teil A weist den neu berechneten Folgezustand an das eigentliche synchrone Register zu. clock) state <= nextstate Zusätzlich können hier die synchronen Mikrooperationen stehen. Der zweite Teil B berechnet den Folgezustand prozedural. reg nextstate; // tempwire x) nextstate = f(state, x). 4. Möglichkeit Für große Entwürfe kann diese Beschreibungsform am flexibelsten sein, wobei eine gewisse Unübersichtlichkeit der Preis ist. Testausgaben auf die neuen Master-Werte sind einfach möglich. Die Register werden in Slave (state, ra, rb,..) und Master (nextstate, nextra, nextrb,..) aufgespalten. Die Ausgangssignale werden als reg y // tempwire erklärt. Im Programmteil 1 finden die synchronen Zuweisungen an die Slaves statt. Im Programmteil 2 werden prozedural die Folgezustände (nextstate), die Folgewerte der Register (nextra, nextrb) und die 7

8 Ausgangssignale berechnet. Dadurch ist es leichter möglich, konsistente Änderungen durchzuführen, die den Zuständen zugeordnet sind (Folgezustand, Mikrooperationen, Ausgabesignale). // Deklarationen reg y; // tempwire Ausgabe reg nextstate, nextra, nextrb; // Master tempwire reg state, ra, rb; // Slave syncreg // Programmteil 1 clock) state <= nextstate; ra <= nextra; rb <= nextrb; // Programmteil 2 x, ra, rb) nextstate = f(state, x); nextra = ra + rb; y = g(state, x, ra, rb) 8