Wichtige Eigenschaften von VHDL

Сomentários

Transcrição

Wichtige Eigenschaften von VHDL
Praktium Systementwurf mit VHDL
HDL Design Lab
Lehrstuhl für Entwurfsautomatisierung
Technische Universität München
1
Das Projekt: Verschlüsselung — Entschlüsselung
2
Hardware-Emulation
Signalgenerator
Hardware
Oszillograph
3
Hardware-Emulation
Signalgenerator
Hardware
Oszillograph
Hardware-Replika
Software-Modell
(VHDL)
Computer
4
Hardware-Emulation
Signalgenerator
Hardware
Oszillograph
Hardware-Replika
Software-Modell
(VHDL)
Testumgebung (Software, VHDL)
Computer
5
Modellierung Digitaler Systeme
• Wozu dienen Hardware-Beschreibungssprachen wie VHDL?
Zur Beschreibung von Hardware-Systemen
durch Software-Modelle
• Definition (nach IEEE-Wörterbuch):
Ein Modell ist eine idealisierte Darstellung eines Systems.
Die Vollständigkeit und Detailtreue eines Modells werden
durch die zu untersuchenden Eigenschaften,
den Wissensstand und die Modellumgebung bestimmt.
• Modelle können unvollständig oder ungenau sein und
zu falschen Aussagen führen, wenn sie außerhalb ihres
vorgesehenen Anwendungsbereichs eingesetzt werden.
• Mit formalen Sprachen wie VHDL beschriebene Modelle
besitzen eine eindeutige Interpretation und
werden deshalb Formale Modelle genannt.
6
Anwendungsbereiche Digitaler Systeme
• Wozu werden Modelle gebraucht?
– Als Prototypen zur Spezifikation der Anforderungen
– Zur Überprüfung des (zeitlichen) Verhaltens
durch Simulation und formale Verifikation
– Zur automatisierten Synthese
– Zur Dokumentation
– Zur Wiederverwendung (Design Reuse)
– Zum Datenaustausch
zwischen Komponentenanbieter und Entwickler, sowie
zwischen verschiedenen Entwurfssystemen
• Welche Ziele werden bei der Modellbildung verfolgt?
– Minimierung von Entwurfskosten und Entwurfszeit
– Vermeiden von Fehlern beim Entwurf
– Vermeiden unnötiger Entwurfszyklen, Redesigns
7
VHDL
• V
H
D
L
VHSIC (Very High Speed Integrated Circuit)
Hardware
Description
Language
• Verbreitete Programmiersprache
mit Erweiterungen zur Beschreibung von Hardware:
nebenläufige Prozesse, Zeitmodell
• Hierarchische Modellierung
• Verschiedene Entwurfsstile
• Seit 1987 durch IEEE- und ANSI-Standard genormt.
Hier wird VHDL-87 verwendet (VHDL-93 enthält Erweiterungen).
• Verilog ist eine andere häufig verwendete HDL.
• Erweiterung für Analog- und Mixed-Signal-Schaltungen:
VHDL-AMS
8
Literatur
• Peter J. Ashenden
The Designer‘s Guide to VHDL
Morgan Kaufman Publishers, 1996
9
Der Entwurfsraum
Zweistufiger Syntheseprozess unter Verwendung einer Zellbibliothek
Entwurfssicht
Abstraktionsniveau
Verhalten
Struktur
Geometrie
Architektur
SystemSpezifikation
SystemPartitionierung
Bauplan
(floorplan)
Register
Transfer
Algorithmus
Modul-Netzliste
(ALU, Mux, Register)
Makro-Zellen
(IP-Blöcke)
Logik
Boolesche
Gleichungen
Gatter-Netzliste
(Gatter, FlipFlops)
Standardzellen
Bibliothekszellen
Schaltkreis
Differentialgleichungen
Transistor-Netzliste
Maskendaten,
Polygone
10
Modellierungsraum
Funktionssicht
Struktursicht
ProzessorMemorySwitch
Algorithmen
RegisterTransfers
Boolesche
Gleichungen
RegisterTransfers
Gatter
Differentialgleichungen
Transistoren
Polygone
Geometriesicht
Y-chart nach
Gajski & Kahn
Standardzellen
Makrozellen
Chip-, Floorplan
11
Der Entwurfsprozess
Anforderungen
Systemmodell
Algor. Synthese
Verhaltensmodell
Simulation
RT-Synthese
RT-Modell
Testrahmen
Simulation
(test
bench)
Logiksynthese
ASIC oder
FPGA
Gatter-Modell
Simulation
Layoutsynthese
Signallaufzeiten
12
Register-Transfer-Beschreibung
Auf RT-Ebene werden Aktivitäten (Funktionen, Operationen) als Transfers
von Datenwerten zwischen Registern beschrieben, die Taktzyklen
zugeordnet sind (Verhaltenssicht, Datenfluß).
Clock
Ctrl In
Operationen und Register
werden meist zu Datenpfaden
zusammengefaßt, die durch
KontrollKontrolleinheiten gesteuert
einheit
werden (Struktursicht). Eine
RT-Schaltung besteht typi(Zustandsscherweise aus Modulen
automat)
(z.B. Addierer, Multiplizierer,
Register, Zustandsautomaten),
Ctrl Out
die durch Signalnetze verbunden sind.
Data In
Control
Register
Speicher
ALU
+/*
Status
Register
Data Out
Charakteristisch für RT-Beschreibungen ist auch, daß Operationen
nicht auf einzelne Logikwerte (Bits), sondern auf Mengen von Logikwerten angewandt werden. Diese werden zu Worten gruppiert,
deren 0-1-Muster als (alpha)numerische Werte interpretiert werden.
13
Simulation
Simulation dient der Verifikation von Entwurfsschritten.
Simulation ist notwendig, weil bei der automatisierten Synthese
nicht alle Anforderungen exakt erfüllt werden (können) und
weil Syntheseprogramme fehlerhaft sein können.
Durch Simulation werden insbesondere folgende Fragen
beantwortet:
• Simulation von Verhaltensmodellen
– Erfüllt das Verhaltensmodell die (VHDL-)Syntax?
– Erfüllt das Verhaltensmodell die spezifizierten
Anforderungen (die Spezifikation)?
– Welche Eigenschaften besitzt das modellierte System?
• Simulation von Strukturmodellen
– Erfüllt das Strukturmodell die (VHDL-)Syntax?
– Besitzt das Strukturmodell (die RT- oder die GatterNetzliste) dieselbe Funktion wie das Verhaltensmodell?
– Erfüllt das Strukturmodell die zeitlichen Anforderungen?
14
Gliederung dieser Einführung in VHDL
1) Formaler Aufbau von VHDL-Modellen
2) Testumgebungen
VHDL-Modelle, die Eingangssignale zum Testen eines
Modells bereitstellen
3) Zeitmodelle in VHDL
Nachbildung des Zeitverhaltens der modellierten Hardware
4) Modellierung von Zustandsautomaten in VHDL
Systematische Beschreibung digitaler Systeme
15
Gliederung dieser Einführung in VHDL
1) Formaler Aufbau von VHDL-Modellen
2) Testumgebungen
VHDL-Modelle, die Eingangssignale zum Testen eines
Modells bereitstellen
3) Zeitmodelle in VHDL
Nachbildung des Zeitverhaltens der modellierten Hardware
4) Modellierung von Zustandsautomaten in VHDL
Systematische Beschreibung digitaler Systeme
16
Formaler Aufbau von VHDL-Modellen
Formaler Aufbau von
VHDL-Modellen
17
Modellieren von Schnittstellen (Interfaces)
Eine Entity beschreibt eine Schaltung(skomponente) aus externer
Sicht, d.h. Anzahl und Typ ihrer Ein- und Ausgänge (ports).
Beispiel:
A
B
D0
D1
DEK2X4 D2
EN
D3
2x4Dekoder
Name der entity
Liste von port-Namen
reservierte Zeichen
entity DEK2X4 is
port (A, B, EN: in bit;
D: out bit_vector(0 to 3));
end DEK2X4;
reservierte Worte
port-Modus
port-Typ
18
Modellieren von Schnittstellen (Interfaces)
Eine Entity beschreibt eine Schaltung(skomponente) aus externer
Sicht, d.h. Anzahl und Typ ihrer Ein- und Ausgänge (ports).
Beispiel:
A
B
D0
D1
DEK2X4 D2
EN
D3
2x4Dekoder
Name der entity
EN
A
B
D0
D1
D2
D3
0
-
-
1
1
1
1
1
0
0
0
1
1
1
1
0
1
1
0
1
1
1
1
0
1
1
0
1
1
1
1
1
1
1
0
Liste von port-Namen
reservierte Zeichen
entity DEK2X4 is
port (A, B, EN: in bit;
D: out bit_vector(0 to 3));
end DEK2X4;
reservierte Worte
port-Modus
port-Typ
19
Modellierung von Schaltungsverhalten oder -struktur
• Architectures
– beschreiben aus interner Sicht,
welche Funktion eine entity hat und wie sie realisiert wird
– sind Implementierungen einer entity
– können mehrfach pro entity
(mit derselben Funktion) auftreten
• Architectures können in verschiedenen Modellierungsstilen
beschrieben werden:
– Verhaltensmodelle beschreiben das Verhalten
(die Funktion) einer Schaltung(skomponente),
d.h. die Werte der Ausgangssignale als Funktion der Werte
der Eingangssignale.
– Strukturmodelle beschreiben eine
Schaltung(skomponente) als eine hierarchische Struktur von
Subkomponenten, die durch Signale verbunden sind
(hierarchisch strukturierte Netzliste).
20
Verhaltensmodell des 2x4-Dekoders
entity DEK2X4 is
port (A, B, EN: in bit;
D: out bit_vector(0 to 3));
end DEK2X4;
architecture VERHALTEN_1 of DEK2X4 is
begin
VERH_1_DEK: process(A,B,EN)
begin
if EN='1' then
-- '1' ist eine Konstante vom Typ bit
D(0) <= not (not A and not B);
D(1) <= not (not A and B);
D(2) <= not (A and not B);
D(3) <= not (A and B);
else -- EN='0' ist ein Kommentar
D <= "1111"; -- Konstante vom Typ bit_vector
end if;
end process VERH_1_DEK;
end VERHALTEN_1;
21
Prozesse
Ein Prozess beschreibt das Verhalten (die Funktion) einer
Schaltung(skomponente) als eine Sequenz von Anweisungen.
Wie in einer herkömmlichen Programmiersprache sind alle Datenund Anweisungstypen verfügbar wie z.B. Konstanten, Variable,
Felder, Records, Zuweisungen, Verzweigungen, Schleifen.
Prozesse werden durch Namen (process labels) identifiziert und
können eine Empfindlichkeitsliste (sensitivity list) besitzen. Ein
Prozess wird aktiviert, wenn sich der Wert eines Signals in seiner
sensitivity list ändert.
Zum Speichern des Prozesszustands dienen Variable. Sie können
nur innerhalb von Prozessen deklariert und benutzt werden.
Signale entsprechen Drähten zwischen Hardware-Blöcken und
dienen zur Kommunikation zwischen nebenläufigen Prozessen.
Sie halten Werte wie die Variablen, haben aber ein Zeitverhalten.
Innerhalb von Prozessen dürfen Signale nicht deklariert werden.
Mit der end-Anweisung wird der Prozess suspendiert.
22
Verhaltensmodell eines 4fach-Multiplexers
entity MUX4 is
port(X: in bit_vector(3 downto 0);
SEL: in bit_vector(1 downto 0);
Z: out bit);
end MUX4;
architecture VERH_MUX4 of MUX4 is
begin
MUX4_proc: process(X,SEL)
variable TMP:bit; -- Variable ohne Zeitverhalten
begin
X(0)
SEL
case SEL is
X(1)
when "00" => TMP:=X(0);
Z
X(2)
when "01" => TMP:=X(1);
X(3)
when "10" => TMP:=X(2);
when "11" => TMP:=X(3); -- Zuweisungen an Variable
end case;
-- alle Alternativen sind aufzuführen!
Z <= TMP after 5 ns; -- Zuweisung an Signal
end process MUX4_proc; -mit Verzögerung
end VERH_MUX4;
23
Datenfluß-Modelle
• Datenfluß-Modelle (oder funktionale Modelle) sind
Verhaltensmodelle, bei denen die zu beschreibende Funktion
der Schaltung(skomponente) eine einfache Transformation von
Eingangssignalen in Ausgangssignale ist.
• VHDL stellt dafür Kurzschreibweisen bereit, die nebenläufigen
Signalzuweisungen (concurrent signal assignments).
• Die Bearbeitung von Signalzuweisungen außerhalb von
Prozessen ist daher unabhängig von der Reihenfolge,
in der sie aufgeschrieben sind.
• Jede nebenläufige Signalzuweisung bildet einen eigenen
Prozess, der genau dann aktiviert und ausgeführt wird,
wenn sich der Wert von mindestens einem Signal auf der
rechten Seite des Zuweisungszeichens ändert.
24
Datenfluß-Modell eines Halbaddierers
entity HALF_ADDER is
port(A, B: in bit;
SUM, CARRY: out bit:='0'); -- Voreinstellungen
end HALF_ADDER;
architecture CONCURRENT_HA of HALF_ADDER is
constant S_delay: time:=8 ns; -- benannte Konstanten
constant C_delay: time:=4 ns;
begin
SUM
<= A xor B after S_delay; -- nebenläufig!
CARRY <= A and B after C_delay; -- nebenläufig!
end CONCURRENT_HA;
25
Datenfluß-Modelle: Selektive Signalzuweisungen
• Selected signal assignment (z.B. 4fach-Multiplexer):
architecture VERH2_MUX4 of MUX4 is
begin
with SEL select –- Auswahlsignal
Z <= X(0) after 5 ns when "00";
X(1) after 5 ns when "01";
X(2) after 5 ns when "10";
X(3) after 5 ns when "11";
end VERH2_MUX4;
X(0)
X(1)
X(2)
X(3)
SEL
Z
• Diese Anweisung entspricht einem case-Konstrukt.
• Für sämtliche möglichen Kombinationen des Selektors muß ein
Signalwert zugewiesen werden.
• Falls nicht alle Kombinationen definiert sind, muß zwingend unter einer
letzten Bedingung when others ein Wert zugewiesen werden.
26
Datenfluß-Modelle: Bedingte Signalzuweisungen
• Conditional signal assignment (z.B. 4fach-Multiplexer):
architecture VERH3_MUX4 of MUX4 is
begin
Z <= X(0) after 5 ns when SEL="00" else
X(1) after 5 ns when SEL="01" else
X(2) after 5 ns when SEL="10" else
X(3) after 5 ns when SEL="11";
end VERH3_MUX4;
• Diese Anweisung entspricht einem if-then-else-Konstrukt.
• Es können beliebig viele Bedingungen abgefragt werden. Die Priorität
der Bedingungen entspricht ihrer Reihenfolge. Das Zeitverhalten
unterscheidet sich von der selektiven Signalzuweisung.
• Im Gegensatz zur selektiven Signalzuweisung können bei der
bedingten Signalzuweisung unterschiedliche Signale in den einzelnen
Bedingungen kombiniert werden.
27
Verhaltensmodelle
Bei Verhaltensmodellen (behavioral architectures) ist zwischen
zwei Formen zu unterscheiden:
• Algorithmische Modelle
– beschreiben die Funktion (das Verhalten) einer
Schaltung(skomponente) wie in einer (herkömmlichen)
Programmiersprache durch eine Sequenz von
Anweisungen, die in einem Prozess zusammengefaßt sind
– sind nur zur Simulation des Schaltungsverhaltens geeignet
• Datenflußmodelle
– beschreiben die Schaltungsfunktion als Datenfluß zwischen
kommunizierenden Prozessen (nebenläufig, zeitlich parallel)
– sind besonders geeignet zur Beschreibung auf der RegisterTransfer-Ebene
– können als Ausgangspunkt für eine automatisierte
Synthese der Schaltungsstruktur verwendet werden
28
Die Struktur einer Schaltung
Schaltplan (schematic diagram) des 2x4-Dekoders
DEK2X4
& D(0)
G0
A
1
IA
AQ
B
1
IB
BQ
EN
& D(1)
G1
& D(2)
G2
& D(3)
G3
33
Modellieren der Schaltungsstruktur
Beispiel:
2x4Dekoder
architecture STRUKTUR of DEK2X4 is
component INV
port(A: in bit; Z: out bit);
end component;
component NAND3
port(A,B,C: in bit; Z: out bit);
end component;
signal AQ,BQ: bit;
begin -- Netzliste (nebenläufig!)
-- component-Instanzierungen
IA: INV port map(A,AQ);
IB: INV port map(B,BQ);
G0: NAND3 port map(AQ,BQ,EN,D(0));
G1: NAND3 port map(AQ,B,EN,D(1));
G2: NAND3 port map(A,BQ,EN,D(2));
G3: NAND3 port map(A,B,EN,D(3));
end STRUKTUR;
34
Modellieren von Teilschaltungen
entity INV is
port (A: in bit; Z: out bit);
Komponenten
end INV;
INV und
NAND3
architecture ARCH_INV of INV is
des 2x4begin -- Verhaltensbeschreibung
Dekoders
Z <= not A after 12 ns;
end ARCH_INV;
Beispiel:
entity NAND3 is
port (A,B,C: in bit; Z: out bit);
end NAND3;
architecture ARCH_NAND3 of NAND3 is
begin -- Verhaltensbeschreibung
Z <= not(A and B and C) after 8 ns;
end ARCH_NAND3;
35
Hierarchische Modellierung der Schaltungsstruktur
Beispiel:
Komponente
NAND3
des 2x4Dekoders
A
B
C
X
Y
Z
architecture STRUK_NAND3 of NAND3 is
component AND2
port(E1,E2: in bit; A: out bit);
end component;
component INV
port(A: in bit; Z: out bit);
end component;
signal X, Y: bit;
begin
M1: AND2 port map(A,B,X);
M2: AND2 port map(C,X,Y);
M3: INV port map(Y,Z);
end STRUK_NAND3;
library MyLib;
configuration NAND3_CONF of NAND3 is
for STRUK_NAND3 –- Name der architecture
for all:AND2
use entity
MyLib.AND2(TimAr);
end for;
AUTOMATIC
IN
XILINX
TOOLS!
for M3:INV use entity WORK.INV(ARCH_INV); end for;
end for;
end NAND3_CONF;
36
Configurations (Binden architecture an entity)
entity
AUTOMATIC IN XILINX TOOLS!
architecture
Verhaltensbeschreibung
architecture
GatterNetzliste
configuration
Für eine entity kann eine von mehreren architectures
ausgewählt werden. Dadurch kann beispielsweise eine
Verhaltensbeschreibung leicht (ohne Eingriff in die
Quelltexte) durch eine Strukturbeschreibung ersetzt
werden.
architecture
RTBeschreibung
37
Libraries & Packages
• Die Library (Bibliothek) WORK wird beim Übersetzen automatisch
eingebunden. In ihr legt der VHDL-Compiler alle übersetzten
Design Units (Entities, Architectures, Configurations) ab, die
dann ohne explizite Angabe der Library benutzt werden können.
• Das Package STANDARD mit den grundlegenden Datentypen
wird ebenfalls automatisch eingebunden.
• Eine Library kann PACKAGE Design Units enthalten,
in denen TYPE-, SUBTYPE- und FUNCTION-Deklarationen
zusammengefasst werden. Das ermöglicht die Verwendung
dieser Deklarationen in verschiedenen Modellen ohne
wiederholte (und fehlerträchtige) erneute Deklaration.
• Syntax:
library IEEE; -- Einbinden der library IEEE
use IEEE.STD_LOGIC_1164.all;
41
Datentypen, Subtypen (package STANDARD)
package STANDARD is -- wird automatisch geladen
-- enthält u.a. die Datentypen
type boolean is (false,true);
type bit is ('0','1');
type character is (...);
type integer is ...;
subtype natural is integer
range 0 to integer'high;
subtype positive is integer
range 1 to integer'high;
type real is ...;
type time is ... units fs; ps=1000 fs; ...;
type string is
array (positive range <>) of character;
type bit_vector is
array (natural range <>) of bit;
-- Die zugehörigen Operatoren sind auch definiert.
end standard;
42
Neunwertige Logik (IEEE package STD_LOGIC_1164)
package STD_LOGIC_1164 is
-- ist gespeichert in der library mit dem Namen IEEE
type STD_LOGIC
is ('U', -- nicht initialisiert (Voreinstellung)
'X', -- Signalkonflikt zwischen '0' und '1'
'0', -- aktive '0' (durch Gatter getrieben)
'1', -- aktive '1' (durch Gatter getrieben)
'Z', -- hochohmig (tri-state Ausgang)
'W', -- Signalkonflikt zwischen 'L' und 'H'
'L', -- passive '0' (pull-down Widerstand)
'H', -- passive '1' (pull-up Widerstand)
'-' -- don't care, Wert ist bedeutungslos und
);
-kann zur Logikminimierung dienen
type STD_LOGIC_VECTOR
is array (natural range <>) of STD_LOGIC;
-- definiert sind auch die Logikoperatoren
-and, nand, or, nor, xor, xnor, not
end STD_LOGIC_1164;
43
Ausgewählte Attribute von Signalen
signal S; variable T: time;
S'event
Diese Funktion liefert den Booleschen Wert true,
wenn im aktuellen Simulationszyklus beim Signal S
ein Event auftritt, sonst false.
S'last_event Diese Funktion liefert die Simulationszeit, seit beim Signal S
das letzte Event auftrat. Das Ergebnis ist also 0 fs,
wenn S'event true ist.
S'last_value Wert von S, unmittelbar bevor das letzte Event auftrat.
S'stable(T)
Boolesches Signal, das den Wert true annimmt, wenn
beim Signal S für T Zeiteinheiten kein Event aufgetreten ist.
Wenn (T) fehlt, werden 0 fs angenommen.
S'delayed(T) Signal vom selben Typ und mit denselben Werten wie S,
aber um T Zeiteinheiten verzögert.
Wenn (T) fehlt, werden 0 fs angenommen.
45
Parametrisierung von Modellen
entity NANDg is -- generisches NAND-Gatter
generic(Wb:positive:=3; -- Wortbreite
Vz:time:=8 ns); -- Verzögerungszeit
port(X: in bit_vector(Wb-1 downto 0); Y: out bit);
end NANDg;
architecture NANDg_Verh of NANDg is
begin
NANDg_proc: process(X)
begin
Y <= '0' after Vz;
-- Voreinstellung
for K in X'range loop -- Attribut des Signals X
-- K = Wb-1, Wb-2, Wb-3, ..., 1, 0
if X(K)='0' then Y <= '1' after Vz;
end if;
end loop;
end process NANDg_proc;
end NANDg_Verh;
47
Schaltungsstruktur mit generischem NAND-Gatter
Beispiel: 2x4-Dekoder
architecture STRUKTgen of DEK2X4 is
component NANDg
generic(Wb:positive; Vz:time);
port(X: in bit_vector(Wb-1 downto 0); Y: out bit);
end component;
signal AQ,BQ: bit;
begin
IA: NANDg generic map(1,6 ns) port map(X(0)=>A,Y=>AQ);
IB: NANDg generic map(1,6 ns) port map(X(0)=>B,Y=>BQ);
G0: NANDg port map(X(2)=>AQ,X(1)=>BQ,X(0)=>EN,
Y=>D(0));
G1: NANDg port map(X(2)=>AQ,X(1)=>B, X(0)=>EN,
Y=>D(1));
G2: NANDg port map(X(2)=>A, X(1)=>BQ,X(0)=>EN,
Y=>D(2));
G3: NANDg port map(X(2)=>A, X(1)=>B, X(0)=>EN,
Y=>D(3));
end STRUKTgen;
48
Beispiel: Generischer n-Bit-Zähler
entity genCntr is
generic ( N : positive := 8 );
port ( CLOCK, RESET : in bit;
COUNTER : out integer range 0 to 2**N-1 );
end genCntr;
architecture arch_genCntr of genCntr is
signal intCntr : integer range 0 to 2**N-1;
begin
process (CLOCK)
begin
if CLOCK'event and CLOCK = '1';
if RESET = '1' or intCntr = 2**N-1 then
intCntr <= 0;
else
intCntr <= intCntr + 1;
end if;
end if;
end process;
COUNTER <= intCntr;
end arch_genCntr;
49
Beispiel: Generischer n-Bit-Zähler
entity genCntr is
generic ( N : positive := 8 );
port ( CLOCK, RESET : in bit;
COUNTER : out integer range 0 to 2**N-1 );
end genCntr;
architecture arch_genCntr of genCntr is
signal intCntr : integer range 0 to 2**N-1;
begin
process
begin
wait until ( CLOCK'event and CLOCK = '1' );
if RESET = '1' or intCntr = 2**N-1 then
intCntr <= 0;
else
intCntr <= intCntr + 1;
end if;
end process;
COUNTER <= intCntr;
end arch_genCntr;
50
Generics, Attribute & Assertions am Beispiel: D-FlipFlop
entity DFF is
generic(Tpd,Tsu,Thld:time); -- Verzögerung, Setup, Hold
port(Clk,D: in bit; Q: out bit);
end DFF;
architecture ArchDFF of DFF is
begin –- drei kommunizierende Prozesse
Q <= D after Tpd when Clk='1' and Clk'event;
ChkSetup: process –- Prüfen der Setup-Zeit
begin
–- Test bei steigender Clk-Flanke
wait until Clk='1';
assert D'last_event>=Tsu report "setup violation";
end process ChkSetup;
ChkHold: process –- Prüfen der Hold-Zeit
begin
–- Test nach Ablauf der Hold-Zeit
wait until Clk'delayed(Thld)='1';
assert D'delayed'last_event>=Thld report "hld viol.";
end process ChkHold;
end ArchDFF;
51
Testrahmen (test benches)
Testrahmen
(test benches)
52
Testrahmen
entity TB is -- leer
TB
end TB; -- ohne Inputs, Outputs
architecture STIMULI of TB is
component DEK2X4
port(A,B,EN: in bit;
D: out bit_vector(0 to 3));
end component;
signal X,Y,E: bit:='0';
R: bit_vector(0 to 3):="1111";
begin
UUT: DEK2X4 port map(X,Y,E,R);
...
end STIMULI;
X
Y
E
A
B
EN
UUT
DEK2X4
D0 D1 D2 D3
R0 R1 R2 R3
53
Testrahmen – Stimuli
architecture STIMULI of TB is
component DEK2X4
port(A,B,EN: in bit; D: out bit_vector(0 to 3));
end component;
signal X,Y,E: bit:='0';
R: bit_vector(0 to 3):="1111";
begin -- Datenflußbeschreibung (nebenläufig!)
-- Instanzierung der “unit under test"
UUT: DEK2X4 port map(X,Y,E,R);
-- Stimuli = Input-Signalverläufe (waveforms)
X <= '0'
, '1' after 5 ns,
'0' after 10 ns, '1' after 15 ns,
'0' after 20 ns, '1' after 25 ns,
'0' after 30 ns, '1' after 35 ns;
Y <= '0'
, '1' after 10 ns,
'0' after 20 ns, '1' after 30 ns;
E <= '0'
, '1' after 20 ns;
end STIMULI;
...
54
Testrahmen – Signalverläufe
X
1
0
0
1
0
1
0
1
0
1
Y
1
0
0
0
1
1
0
0
1
1
E
1
0
0
0
0
0
1
1
1
1
R0
1
0
R1
1
0
R2
1
0
R3
1
0
0
0
0
0
0
5
10
15
20
25
30
35
40
ns
55

Documentos relacionados