Kombinatorische Logik in Verilog
Im letzten Kapitel haben wir bereits eine kombinatorische Schaltung in Verilog beschrieben:
den Volladdierer, mit zwei assign-Anweisungen. Für einen einzelnen Volladdierer reicht das.
Für größere Schaltungen brauchen wir ein paar weitere Werkzeuge: Signale mit mehreren Bits, eine lesbare Möglichkeit,
eine Wahrheitstabelle zu beschreiben, und eine Möglichkeit, große Schaltungen aus kleinen zusammenzusetzen.
In diesem Kapitel lernen wir diese Werkzeuge an zwei neuen Schaltungen kennen: einem 7-Segment-Decoder, der eine Zahl in das Muster für eine Ziffernanzeige umwandelt, und einem Ripple-Carry-Addierer, den wir aus unseren Volladdierern bauen. Zum Schluss sehen wir uns den häufigsten Fehler bei der Beschreibung kombinatorischer Logik an.
Vektoren und Zahlen
Bisher waren alle unsere Signale ein einzelnes Bit. In Verilog kann ein Signal auch ein Vektor aus mehreren Bits sein:
1
2
wire [3:0] value; // 4 Bit: value[3] (MSB) ... value[0] (LSB)
wire [6:0] seg; // 7 Bit
Die wichtigsten Operationen auf Vektoren:
Schreibweise | Bedeutung | Beispiel |
| ein einzelnes Bit (Bit-Select) | das dritte Bit von rechts |
| mehrere Bits (Part-Select) | die beiden oberen Bits |
| Verkettung - setzt Signale nebeneinander |
|
| Wiederholung | das Bit x viermal |
Zahlen werden mit ihrer Breite und Basis geschrieben: 4’hA ist die 4-Bit-Zahl A (hexadezimal, also 10),
7’b0111111 ist eine 7-Bit-Binärzahl und 8’d200 die Dezimalzahl 200 mit 8 Bit.
Die Breite ausdrücklich anzugeben vermeidet Überraschungen - Verilog schneidet Zahlen mit falscher Breite stillschweigend
ab oder erweitert sie.
Zwei Wege, kombinatorische Logik zu beschreiben
Den ersten Weg kennen wir schon: eine kontinuierliche Zuweisung mit assign. Sie beschreibt eine Leitung, die ständig mit
dem Ergebnis eines Ausdrucks verbunden ist - genau wie ein Gatter, dessen Ausgang immer seinen Eingängen folgt.
Der zweite Weg ist ein always-Block:
1
2
3
always @(*) begin
// Anweisungen
end
Das @() bedeutet: Führe den Block erneut aus, sobald sich *irgendeines der darin gelesenen Signale ändert.
Der Block verhält sich also ebenfalls wie kombinatorische Logik. Darin dürfen wir if, case und andere Anweisungen verwenden,
was komplexe Logik viel lesbarer macht als ein langer boolescher Ausdruck.
Eine Sache verwirrt fast jeden Anfänger: Ein Signal, das in einem always-Block zugewiesen wird, muss als reg deklariert sein.
Trotz des Namens ist ein reg nicht automatisch ein Register. In einem always @(*)-Block wird daraus ganz gewöhnliche
kombinatorische Logik - der Name bedeutet nur, dass das Signal in einem prozeduralen Block zugewiesen wird.
Beispiel 1: Ein 7-Segment-Decoder
Eine 7-Segment-Anzeige besteht aus sieben Balken, genannt a bis g:
Um eine Ziffer anzuzeigen, muss eine bestimmte Kombination von Segmenten leuchten. Bei einer 8 leuchten alle sieben, bei einer 1 nur b und c. Unser Decoder erhält eine 4-Bit-Zahl von 0 bis F und gibt die sieben Segmentsignale aus. Das ist eine kombinatorische Schaltung mit 4 Eingängen und 7 Ausgängen - also sieben Wahrheitstabellen mit je 16 Zeilen.
Mit assign müssten wir sieben boolesche Gleichungen aufstellen und vereinfachen. Mit einer case-Anweisung können wir die
Wahrheitstabelle direkt hinschreiben:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 7-Segment-Decoder für die Hexadezimalziffern 0..F
// Reihenfolge der Segmente: seg = {g, f, e, d, c, b, a}, 1 = Segment leuchtet
module seven_seg (
input wire [3:0] value,
output reg [6:0] seg
);
always @(*) begin
case (value)
4'h0: seg = 7'b0111111;
4'h1: seg = 7'b0000110;
4'h2: seg = 7'b1011011;
4'h3: seg = 7'b1001111;
4'h4: seg = 7'b1100110;
4'h5: seg = 7'b1101101;
4'h6: seg = 7'b1111101;
4'h7: seg = 7'b0000111;
4'h8: seg = 7'b1111111;
4'h9: seg = 7'b1101111;
4'hA: seg = 7'b1110111;
4'hB: seg = 7'b1111100;
4'hC: seg = 7'b0111001;
4'hD: seg = 7'b1011110;
4'hE: seg = 7'b1111001;
4'hF: seg = 7'b1110001;
default: seg = 7'b0000000;
endcase
end
endmodule
Jede Zeile der case-Anweisung ist eine Zeile der Wahrheitstabelle: Beim Eingang 4’h2 leuchten die Segmente g, e, d, b und a -
das ist eine 2. Die Bits von seg sind von g (Bit 6) bis a (Bit 0) geordnet.
Wer macht aus dieser Tabelle Gatter? Das Synthesewerkzeug. Es leitet die booleschen Gleichungen ab und vereinfacht sie - genau die Arbeit, die wir in Teil 1 mit der booleschen Algebra von Hand erledigt haben. Für unseren Decoder erzeugt das Open-Source-Synthesewerkzeug Yosys etwa 30 Gatter.
Note | Viele echte Anzeigen haben eine gemeinsame Anode: Ein Segment leuchtet, wenn sein Signal 0 ist, nicht 1.
Für solche Anzeigen wird der Ausgang einfach invertiert: assign seg_n = ~seg;. |
Den Decoder testen
Die Testbench legt nacheinander alle 16 Werte an:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
`timescale 1ns / 1ps
module seven_seg_tb;
reg [3:0] value;
wire [6:0] seg;
integer i;
seven_seg dut (.value(value), .seg(seg));
initial begin
$dumpfile("seven_seg.vcd");
$dumpvars(0, seven_seg_tb);
for (i = 0; i < 16; i = i + 1) begin
value = i;
#10;
$display("value=%h seg(gfedcba)=%b", value, seg);
end
$finish;
end
endmodule
Statt 16 Zeilen aus Nullen und Einsen zu lesen, lassen wir ein kleines Skript die Segmentmuster aus der Simulationsausgabe zeichnen. Das ist das Ergebnis der Simulation:
Alle 16 Ziffern sehen richtig aus - einschließlich der Kleinbuchstaben b und d, die nötig sind, damit man sie nicht mit 8 und 0 verwechselt.
Beispiel 2: Hierarchie - ein Ripple-Carry-Addierer
Echte Entwürfe bestehen nicht aus einem großen Modul, sondern aus vielen kleinen Modulen, die zusammengesetzt werden - genau wie in Teil 1, wo wir einen Addierer aus Volladdierern gebaut haben. In Verilog können wir ein Modul innerhalb eines anderen Moduls verwenden. Das nennt man Instanziierung, und wir haben es bereits in der Testbench des letzten Kapitels getan.
Ein 4-Bit-Addierer besteht aus vier Volladdierern, wobei der Übertragsausgang jeder Stufe mit dem Übertragseingang der nächsten Stufe verbunden ist:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 4-Bit-Ripple-Carry-Addierer aus vier Volladdierern
module ripple_adder4 (
input wire [3:0] a,
input wire [3:0] b,
input wire cin,
output wire [3:0] sum,
output wire cout
);
wire [3:1] c; // interne Überträge zwischen den Stufen
full_adder fa0 (.a(a[0]), .b(b[0]), .cin(cin), .sum(sum[0]), .cout(c[1]));
full_adder fa1 (.a(a[1]), .b(b[1]), .cin(c[1]), .sum(sum[1]), .cout(c[2]));
full_adder fa2 (.a(a[2]), .b(b[2]), .cin(c[2]), .sum(sum[2]), .cout(c[3]));
full_adder fa3 (.a(a[3]), .b(b[3]), .cin(c[3]), .sum(sum[3]), .cout(cout));
endmodule
Jede Zeile erzeugt einen Volladdierer mit einem eigenen Namen (fa0 bis fa3). Die internen Leitungen c[1] bis c[3]
verbinden die Überträge. Da der Übertrag von Stufe zu Stufe „durchrieselt“ (englisch: to ripple), heißt diese Schaltung
Ripple-Carry-Addierer.
Parameter und generate
Für 4 Bit sind vier Zeilen noch in Ordnung. Für 32 Bit wäre es mühsam und fehleranfällig. Verilog hat dafür zwei Werkzeuge: Ein Parameter macht die Breite einstellbar, und eine generate-Schleife erzeugt die Instanzen automatisch:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// N-Bit-Ripple-Carry-Addierer, die Volladdierer werden in einer Schleife erzeugt
module ripple_adder #(
parameter N = 8
) (
input wire [N-1:0] a,
input wire [N-1:0] b,
input wire cin,
output wire [N-1:0] sum,
output wire cout
);
wire [N:0] c; // c[0] = Übertrag hinein, c[N] = Übertrag heraus
assign c[0] = cin;
assign cout = c[N];
genvar i;
generate
for (i = 0; i < N; i = i + 1) begin : stage
full_adder fa (
.a(a[i]), .b(b[i]), .cin(c[i]),
.sum(sum[i]), .cout(c[i+1])
);
end
endgenerate
endmodule
Die for-Schleife im generate-Block wird nicht zur Laufzeit ausgeführt wie eine Schleife in Software. Sie wird vor
der Simulation oder Synthese aufgelöst: Sie erzeugt einfach N Volladdierer, genau so, als hätten wir sie von Hand hingeschrieben.
Ein 32-Bit-Addierer ist jetzt nur noch ripple_adder #(.N(32)) add32 (…).
Den Addierer testen
Bei einem 8-Bit-Addierer können wir noch alle Kombinationen testen - das sind die \(2^{17} = 131072\) Kombinationen
aus dem letzten Kapitel. Das Referenzmodell ist wieder einfach der +-Operator:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
`timescale 1ns / 1ps
module ripple_adder_tb;
localparam N = 8;
reg [N-1:0] a, b;
reg cin;
wire [N-1:0] sum;
wire cout;
integer i, j, k;
integer errors = 0;
ripple_adder #(.N(N)) dut (.a(a), .b(b), .cin(cin), .sum(sum), .cout(cout));
initial begin
// erschöpfender Test: 256 * 256 * 2 = 131072 Kombinationen
for (i = 0; i < (1 << N); i = i + 1)
for (j = 0; j < (1 << N); j = j + 1)
for (k = 0; k < 2; k = k + 1) begin
a = i; b = j; cin = k;
#1;
if ({cout, sum} !== a + b + cin) begin
if (errors < 10)
$display("ERROR: %0d + %0d + %0d = %0d", a, b, cin, {cout, sum});
errors = errors + 1;
end
end
if (errors == 0) $display("PASSED: all %0d combinations correct", (1 << (2*N)) * 2);
else $display("FAILED: %0d errors", errors);
$finish;
end
endmodule
Die Simulation dauert weniger als eine Sekunde:
PASSED: all 131072 combinations correct
Übrigens: In einem echten Entwurf würde man einfach assign {cout, sum} = a + b + cin; schreiben. Das Synthesewerkzeug
kennt viele Addiererstrukturen und wählt eine passende aus. Wir bauen den Addierer hier selbst, um Hierarchie zu üben -
und weil es zeigt, was hinter dem + steckt. Seine Schwäche ist ebenfalls sichtbar: Im schlimmsten Fall muss der Übertrag
durch alle N Stufen laufen, die Verzögerung wächst also mit der Breite. Schnellere Addierer, wie der Carry-Lookahead-Addierer,
berechnen die Überträge parallel.
Die klassische Falle: ungewollte Latches
Es gibt einen Fehler, den fast jeder beim Einstieg in Verilog macht. Sehen wir uns einen Multiplexer an, der einen von drei 8-Bit-Eingängen auswählt:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// FALSCH: 3-zu-1-Multiplexer - der Fall sel = 2'b11 fehlt
module mux3 (
input wire [1:0] sel,
input wire [7:0] a, b, c,
output reg [7:0] y
);
always @(*) begin
case (sel)
2'b00: y = a;
2'b01: y = b;
2'b10: y = c;
endcase
end
endmodule
Der Code lässt sich ohne Fehler übersetzen. Aber sel hat 2 Bit und damit vier mögliche Werte - und für 2’b11 wird y
kein Wert zugewiesen. Was soll die Hardware in diesem Fall tun? Verilog legt es fest: y behält seinen alten Wert.
Einen Wert behalten heißt, ihn zu speichern - die kombinatorische Schaltung hat plötzlich ein Gedächtnis bekommen.
Die Simulation zeigt das deutlich:
Zwischen 20 und 40 ns ist sel = 3. Der Ausgang behält den Wert 20 - selbst als sich der Eingang b bei 30 ns auf 99 ändert.
Ein Latch ist ein einfaches Speicherelement, das über den Pegel eines Signals gesteuert wird, nicht über eine Taktflanke: Solange es freigegeben ist, folgt sein Ausgang dem Eingang, sonst hält es seinen letzten Wert. Die RS-Schaltung aus dem Kapitel über Taktgeber und Flipflops ist ein solches Latch. Den Unterschied zwischen Latches und Flipflops sehen wir uns im nächsten Kapitel genauer an.
Das Synthesewerkzeug reagiert genauso: Es baut für jedes Bit von y ein Latch. Yosys meldet das in seinem Log:
Latch inferred for signal `\mux3.\y' ...
und die synthetisierte Schaltung enthält 8 Latches ($DLATCH_N), eines pro Ausgangsbit.
Das ist ein Problem: Latches sind pegelgesteuert, können Timing-Probleme verursachen und werden auf FPGAs schlecht unterstützt -
und vor allem wollte sie hier niemand haben.
Die Abhilfe ist einfach: Jeder Ausgang muss auf jedem Pfad durch den always-Block einen Wert bekommen.
Entweder mit einem default-Zweig:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// RICHTIG: Jeder Pfad weist y einen Wert zu
module mux3 (
input wire [1:0] sel,
input wire [7:0] a, b, c,
output reg [7:0] y
);
always @(*) begin
case (sel)
2'b00: y = a;
2'b01: y = b;
2'b10: y = c;
default: y = 8'h00;
endcase
end
endmodule
oder indem man am Anfang des Blocks einen Standardwert zuweist, der dann bei Bedarf überschrieben wird:
1
2
3
4
5
6
7
8
always @(*) begin
y = 8'h00; // Standardwert
case (sel)
2'b00: y = a;
2'b01: y = b;
2'b10: y = c;
endcase
end
Damit erzeugt Yosys keine Latches mehr. Deshalb hat auch unser 7-Segment-Decoder einen default-Zweig,
obwohl alle 16 Werte abgedeckt sind: Es ist eine gute Gewohnheit, die vor diesem Fehler schützt.
Die Regeln für kombinatorische always-Blöcke in Kürze:
Verwende
always @(*), damit kein Eingang vergessen wird.Weise jedem Ausgang auf jedem Pfad einen Wert zu - mit
defaultoder einem Standardwert am Anfang.Verwende die blockierende Zuweisung
=. (Die nicht-blockierende Zuweisung<=lernen wir im nächsten Kapitel kennen, bei den Flipflops.)
Note | Selbst ausprobieren: Mit Yosys lässt sich jedes Modul auf Latches prüfen:
yosys -p "read_verilog mux3_latch.v; synth -top mux3; stat" gibt die Zellen der synthetisierten Schaltung aus.
Taucht $DLATCH auf, fehlt ein Pfad. |
Zusammenfassung
Vektoren, Verkettung und Zahlen mit Breitenangabe sind die Grundbausteine für Signale mit mehreren Bits.
Kombinatorische Logik lässt sich mit
assignoder mit einemalways @(*)-Block beschreiben;case-Anweisungen beschreiben Wahrheitstabellen direkt.Module lassen sich in anderen Modulen instanziieren;
parameterundgeneratemachen sie konfigurierbar.Ein
always @(*)-Block, in dem ein Ausgang nicht auf jedem Pfad zugewiesen wird, erzeugt ein ungewolltes Latch.
Im nächsten Kapitel wenden wir uns der sequentiellen Logik zu: Flipflops, Register, Zähler - und die Ampel aus dem Kapitel über endliche Automaten.
(Erstellt mit Claude AI)