Hardwarebeschreibungssprachen

Hardwarebeschreibungssprachen (HBS)
Vertiefungsrichtung	II/IHS
Vorlesung
Vorlesender	Dr.-Ing. Steffen Arlt
Abschluß
Art	k.A.

Vorteile der Nutzung von Hardwarebeschreibungssprachen, Erlernen der syntaktischen Grundelemente von VHDL, Überblick über gängige Simulations- und Synthesewerkzeuge, Unterschiede zur Hardwarebeschreibungssprache Verilog, Simulation von VHDL-Designs, Synthesegerechte VHDL-Modellierung, Alternative Beschreibungskonzepte (System C)

Prüfung

Klausur
Termin
Datum:	25.02.2011
Zeit:	09:00 - 10:30
Ort:	Sr HU 211/212

Am Ende des Semester gibt es eine Klausur die über 90 Minuten geht. Es sind alle selbst erstellten Unterlagen und die vorgefertigten in der Klausur zugelassen.

Klausur HBS WS2010/11

Inhalt:

Beschreibungssprachen
- Warum HDL?
- Y-Diagramm
- Unterschiede zwischen VHDL 87 und VHDL 93
- Unterschied zwischen Signal und Variable
- case-Anweisung
- Verzögerungsmodell
- nicht synthesefähige Anweisungen
- Flankendetektor
- 32 Bit Vektor zu null setzten
- Process vervollständigen (war ein FlipFlop)
- korrigieren eines Codes
- Beschreibung eines Automatengraphen in VHDL

Zu den meisten Punkten sollten auch immer Beispiele angegeben werden.

Vorlesungsmitschriften

1. Vorlesung

Motivation

Lücke zwischen Integrationsdichte und Design
Steigende Komplexität
- 1970 Intel CPU 4004
  - 4 Bit, 10µm, 600mm 2 , 0, 74MHz, 2, 25k Transistoren
- 1997 Intel CPU Pentium 2
  - 32 Bit, 0, 35µm, 203mm 2 , 300MHz, 7.500k Transistoren
- 2005 Intel CPU Pentium 4 6xx
  - 64 Bit, 0, 09µm, 135mm 2 , 3587, 8MHz, 169.000k Transistoren
Abstraktion, Generik
Time to Market
Intellectual Properties (IP) & Reuse
Regularität
Information Hiding
Modularität

Was ist eine HDL?

Modellierungssprachen für die Simulation und Implementierung elektronischer Schaltungen

Dokumentationsmittel speziell auf höherem Abstraktionsniveau
Übliche HDLs: VHDL, ABEL, Verilog, Altera-HDL, UDL/I
Unterschiede zu Hochsprachen wie C, C++, Pascal:
- Beschreibung von Parallelität¨at
- strukturelle Beschreibung (Entwurf des Steuer- und Datenﬂusses)
- Existenz entsprechender Datentypen f¨ur die Modellierung von Signalvektoren und Signalpegeln

Anwendungen

Spezifikation

Verifikation, Modellierung ⇒ Simulation
Synthese
Dokumentation

Historie VHDL

VHSIC Very High Speed Integrated Circuits - Programm des DoD ` VHDL- Hardware Description Language

1981 erste Anforderungen
1983-1985 VHDL-Entwicklung von Intermetrics, IBM, TI
1987 IEEE Standard 1076-1987 VHDL-87
1991 IEEE Standard 1164 (neunwertige Logik)
1993 IEEE Standard 1076-1993 VHDL-93
1995 IEEE Standards 1076.3 1076.4

Historie Verilog

1985 Verilog- Spache und Simulator von Gateway Automation entwickelt
1985-1989 wachsende Zunahme der Verwendung von Verilog bei ASIC-Herstellern
1989 Verilog wird von Cadence ¨ubernommen
1990 Formulierung von Open Verilog International (OVI)
1995 IEEE Standard 1364

Kurzvergleich

VHDL bietet mehr lexikalische Elemente (erweiterte Typdeﬁnitionen, Variablen)
Vorteile von Verilog liegen bei der Simulation von Netzlisten mit Timingmodellen, ist an C angeleht, keine strenge Typprüfung
Die Favorisierung einer Sprache ist bei den heute verfügbaren Simulations- und Synthesewerkzeugen nicht mehr notwendig
Europa: ca. 90% Nutzung von VHDL
USA: ca.50% Nutzung von VHDL
Verilog oft effizienter als VHDL

2. Vorlesung

3. Vorlesung

4. Vorlesung

5. Vorlesung

Operatoren

logische Operatoren: and, or, nand, nor, xor, xnor, not

relative Operatoren: =, /=, <, <=, >, >=

arithmetische Operatoren: sign + - , +, -, &, *, /, mod, rem, **, abs()

Bsp.: <source lang="vhdl">

 5 mod 3 = 2

- 5 mod 3 = 1

 5 mod (-3) = -1

- 5 mod (-3) = -2

 5 rem 3 = 2

- 5 rem 3 = -2

 5 rem -3 = 2

- 5 rem -3 = -2 </source> Shift Operatoren: SLL, SRL, SLA, SRA, ROL, ROR

Nebenläufige Anweisungen

<source lang="VHDL"> architecture <concurrent decluration part> begin --concurrent VHDL begin concurrent part process (...) sequential decluration part begin sequential VHDL end process end --concurrent VHDL end </source>

process
bedingte Signalzuweisung (condition signal assignment)

<source lang="VHDL"> <sig_id> <= <waveform>/sig_value when <condition> else <condition> </source>

Bsp.: <source lang="VHDL"> q <= a when addr = "oo" else -- Vergleichbar if-then, elsif- else Konstruktion

    b when addr = "11" else
    c;					-- alternative: unaffected;

</source>

selektive Signalzuweisung (selected signal assignment)

<source lang="VHDL"> with addr select -- entspricht einem Multiplexer (HBS 4-12) q = a when "00", b when "11", c when others; </source>

case-Konstrukt

<source lang="VHDL"> architecture Mux1 of MUX is -- Skizze (HBS 4-12) begin y <= (I(0) and not E and not S)

             or (I(1) and not E and S);

end Mux1;

architecture Mux2 of Muc is begin y <= (I(0) and not E) when s = '0' else (I(1) and not E); end Mux2;

architecture rtl1 or test is signal a,b,c,d,e : std_logic; begin d <= a and (b or c); e <= a or b; end rtl1;

architecture rtl2 of test is begin process (a,b,c) variable var: std_logic; begin var := b or c; d <= a and var; end process; process (a,b) begin e <= a or b; end process; end rtl2; </source>

<source lang="VHDL"> process (a) wait until a = 1; wait on a; wait for 10ns;

wait for 2* period; wait until a = 1 for 10ns; </source>

Bsp.: Verzögerungsmodell <source lang="VHDL"> process (a) -- Skizze (HBS 4-13) begin c1 <= not a; end process;

process begin c2 <= not a; wait on a; end process;

process begin wait on a; c3 <= not a; end process;

process begin wait until a = '1'; c4 <= not a; end process;

process begin c5 <= not a; wait until a = '1' for 10ns; end process; </source>

Sequentielle Statements

<source lang="VHDL"> if addr = "00" then q <= a; elsif addr = "11" then q <= c; end if;

case addr is when "00" => q <= a; when "11" => q <= b; when others => q <= c; end case;

type alu_mod is (addr, sub, idle); -- Null-Anweisung variable sel: alu_mod; case sel is when add = c := a + b; when sub = c := a - b; when idle => null; end case; </source>

6. Vorlesung

Schleifen

"loop"
Abbruch exit, next

bedingungslose Schleife

Bsp.: <source lang="vhdl"> elementar_loop : loop if i = 31 then exit; else i := i+1; q(i) <= '0'; end if; end loop elementar_loop; </source>

for-Schleifen

while-Schleifen

<source lang="vhdl"> <label> : while <condition> loop . . . end loop; </source> Bsp.: <source lang="vhdl"> while i<5 loop q(i) <= data_in(i) i := i + 1; end loop; </source>

optionales & zusätzliches

Unterprogramme (Subprograms)

function, procedure
Operatoren, Datentypen, Konstanten, Konvertierung
lokal (in einer architecture), global (package)
rein sequenzielles VHDL
laut IEEE_1076.6 sind Signaldeklarationen nicht synthesefähig
Rekursion - nicht synthesefähig!

Funktionen

mehrere Übergabeparameter
ein Rückgabewert

<source lang="vhdl"> function <func_id> (<parameter_list>) return <type_id> is <variable. constant, type declaration>; begin <ssequential statements> return <id>; end [<func_id>];

Bsp.: <source lang="vhdl"> funtion vec2int (v:std_logic_vector) return integer is variable tmp: integer := 0; begin for i in v'range loop tmp : = tmp*2; if v(i) = '1' then tmp := tmp + 1; end if; end loop; return tmp; end vec2int;

(int_var := vec2int(vec_var)) </source>

function overloading

<source lang="vhdl"> type tri_logic is ('0', '1', 'K'); function and (in_1: tri_logic; in_2: tri_logic) return tri_logic is begin if in_1 = '1' and in_2 = '1'then return '1'; elsif in_1 = '0' or in_2 = '0' then return '0'; else return 'K'; end if; end and; </source>

Zustände von Funktionen: pure, impure

Prozeduren

liefern keine Rückgabewerte: $\Rightarrow$ nicht in Ausdrücken
mehrere Ü-Parameter möglich (in, out, inout)
[in = ro]
[out = wo]
[inout = r/w]

<source lang="vhdl"> procedure <proc_id> (<param_list>] is <declaration> begin <sequ. VHDL> end [<proc_id>]; </source>

Bsp.: <source lang="vhdl"> procedure std_logicvec2int (v: in std_logic_vector; f: out boolean; result: out int) is variable tmp : integer := 0; begin result := 0; f := true; for i in v'range loop result := result*2; if v(i) = '1' then result := result + 1; f := false; end if; end loop; end std_logic2int; </source>

Assertion

Überprüfung von Bedingungen und Angaben von errors, warnings
Meldung wenn Bedingung "false"
default Meldung: "Assertion violution"

<source lang="vhdl"> assert <not condition> [report]["<text>"][severity]]serverity_level] { <note|warning|failure> </source>

default für severity_level ist error

Bsp.: <source lang="vhdl"> assert (a = '1' and b = '1') report "a and b not equal '1' at same time" severity warning; </source>

7. Vorlesung

Interne Behandlung von Signalen und Variablen

<source lang="vhdl"> sig <= <waveform>, ... waveform = <expr.>[after time] | unaffected </source>

Transaktionslisten

(current_time + time, value)
delta - Delay: 1/unendlich, Summe = (1/unendlich)

wählt Aktion2 <source lang="vhdl"> signal x : std_logic := 0; process (...) begin x <= '1'; if (x = '1') then -- Aktion1 else -- Aktion2 end if; end process </source>

wählt Aktion1 <source lang="vhdl"> process (...) variable x : std_logic := 0; begin x := '1'; if (x = '1') then -- Aktion1 else -- Aktion2 end if; end process; </source>

Simulationsablauf

Initialisierung

Wertzuweisungen
Simulationtime = 0
alle Prozesse anstarten

Aktualisierung

Bestimmung von next_time und next_event aus der Transaktions + Weckliste
current_time auf next_time
=> Ausführen der Transaktionen, Wertzuweisungen + Aktivierung von Prozessen
Löschen der aktiven Transaktionen

Ausführen der Prozesse

aller aktivierten Prozesse
Weränderung erst nach Prozess-Stop

(Schleife aus Aktualisierung & Ausführen von Prozesse)

Simulationsende

alle Transktionslisten leer
keine Events mehr ausführen
Signale stabil
Zeitlimit

Bsp.: <source lang="vhdl"> constant check_periode : time := 250ns; begin process begin clk <= 0; wait for clock_period/2; clk <= 1; wait for clock_periode/2; end process; </source>

Alternativ <source lang="vhdl"> clk <= not clk after 125ns; </source>

Verzögerungsmodelle bei Signalzuweisungen

Bsp.: <source lang="vhdl"> begin a <= '0', '1' after 10ns, 'o' after 30ns, '1' after 50ns, '0' after 58ns; b <= '0', '1' after 15ns; c <= inertial a and b after 12ns; d <= transport a and b after 12ns; e <= reject 8ns inertial not a after 10ns;

process(clk) variable num, sum integer range 0 to 15 := 0; begin if (clk = '1' and clkevent) then veq_q0 <= sum; num := num + 1; sum := num + 1; veq_q1 <= sum; end if; end process;

signal num, sum : integer range 0 to 15 := 0; process(clk) begin if (clk = '1' and clkevent) then veq_q0 <= sum; num <= num + 1; sum <= num + 1; veq_q1 <= sum; end if; end process; </source>

8. Vorlesung

Entwurfsbeispiele

Latch (HBS_5-3)

Definition: Ein Latch (engl. für Schnappschloss, Auffangregister), oder auch als zustandsgesteuertes Flipflop bezeichnet, ist eine bestimmte Ausführung eines elektronischen 1-Bit-Datenspeichers und bildet(e) die Grundlage für weite Bereiche der Digital-Hardware, insbesondere innerhalb CPU- und Peripherie-Chips.

Im Gegensatz zu taktflankengesteuerten Flipflops ist ein Latch während der gesamten aktiven Taktphase transparent, d. h. Eingangsänderungen können den Ausgang sofort beeinflussen.

<source lang="vhdl"> entity LATCH is port (d, en : in bit; q : out bit); end LATCH; architecture test1 of LATCH is beagin process (en, d) begin if en = '1' then q <= d; -- else -- q <= q; end if; end process; end test1;

architecture test2 of LATCH is begin process (clk, d) begin case clk is when '1' => q <= d; when '0' => null; end process; end test2;

architecture test3 of LATCH is signal temp : bit; begin process (en, d) begin if en = '1' then q <= temp; else temp <= d; end if; end process; end test3;

architecture test4 of LATCH is begin process (en, d) variable temp : bit; begin temp := 0; if en = '1' then temp <= d; end if; q <= temp; end process; end test4;

architecture test5 of LATCH is begin process (en, d) variable temp : bit; begin temp := 0; if en = '1' then temp <= d; else temp := not temp; end if; q <= temp; end process; end test5; </source>

FLipFlops

Definition: Ein Flipflop (engl. flip-flop), meist auch bistabile Kippstufe oder bistabiles Kippglied genannt, ist eine elektronische Schaltung, die zwei stabile Zustände einnehmen und diese speichern kann.

Das Flipflop ist eine einfache elektronische Schaltung, welche eine Datenmenge von einem Bit über eine lange Zeit speichern kann. Es ist fundamentaler Bestandteil vieler elektronischer Schaltungen (sequentieller Schaltkreise) – von der Quarzuhr bis zum Mikroprozessor. Daneben ist es in vieltausend- bis milliardenfacher Ausführung in Computerspeicherchips (statischen Speicherbausteinen) enthalten.

Asynchrones Reset D-Flip Flop

<source lang="vhdl"> Library ieee; use ieee.std_logic_1164.all; entitiy FF is port (clk : in std_logic; reset : in std_logic; d : in std_logic; q : out std_logic); end FF; architecture rtl of FF begin process (clk, reset) begin if reset = '0' then q <= 0; elsif (clk = '1' and clk'event) then q <= d; end if; end process; end rtl; </source>

Alternative für Simulation <source lang="vhdl"> wait until clk'event and clk = '1' if rising_edge(clk) (falling) </source>

Synchrones Reset Preset D-FlipFlop

<source lang="vhdl"> architecture rtl2 of FF is begin process(clk) begin if (clk = '0' and clk'event) then if (reset = '0' then q <= '0': elsif preset = '0' then q <= '1'; elsif enable = '1' then q <= d; else null; end if; end if; end process; end rtl2; </source>

Zähler

Johnson-Zähler

<source lang="vhdl"> Library ieee; use idee.std_logic_1164.all; entity johnson is port (clk : in std_logic; sum : out std_logic_vector (3 downto 0); end johnson; architecture rtl of johnson is begin process(clk) variable count : std_logic_vector (3 downto 0); begin if (clk = '1' and clk'event) then for i in 3 downto 1 loop count(i) := count(i-1); end loop; count(0) := not count(3); end if; sum <= count; end process; end rtl; </source>

9. Vorlesung

Schieberegister

<source lang="vhdl"> library ieee; use ieee.std_logic_1164.all; entity shiftreg is port (ld_shift, clk : in std_logic; ld_val : in std_logic_vector (4 downto 0); ser_out : out std_logic); end shift_reg;

architecture rtl of shift_reg is signal temp : std_logic_vector (4 downto 0); begin process (clk) begin if (clk = '1' and clk'event) then if ld_shift = '1' then tmp <= ld_val; else tmp (4 downto 0) <= temp (3 downto 0) & '0'; end if; end if; end process; end rtl; </source>

Beispiel zwei fehlt...

Finite State Machines (FSM)

Automaten

Automatenentwurf

Zustandskodierung binär hot one

FlipFlops {ld n} n

k komplexer i.a. einfach

"1001" -> FSM -> 1

Skizze

<source lang="vhdl"> library ieee; use ieee.std_logic_1164.all; entity detect_fsm is port(x, rst ,clk : in std_logic; y : out std_logic); end detect_fsm;

architecture rtl of detect_fsm is type state_type is (z0, z1, z2, z4); signal next_state, current_state : state_type; begin next_state_process: process (current_state, x) begin case current_state is when z0 => if x = '1' then next_state <= z1; end if; z1 => if x = '0' then next_state <= z2; end if; z2 => if x = '0' then next_state <= z3; else next_state <= z1; end if; when others => if x = '1' then next_state <= z1; else next_state <= z0; end if; end case; end process next_state process; output_process : process (current_state, x) begin if (current_state = z3 and x = '1') then y <= 1; else y <= 0; end if; end process output_process; clk_process: process(clk, rst) begin if (rst = '1') then current_state <= z0; elsif (clk = '1' and clk'event) then current_state <= next_state; end if; end process clk_process, end rtl; </source>

<source lang="vhdl"> architecture rtl2 of detect_fsm is type state_type is (z0, z1, z2, z4); signal state : state_type; begin process (rst, clk) begin if (rst = '1' then state <= z0; y<= 0; elsif (clk = '1' and clk'event) then case state is when z0 => if x = '1' then state <= z1; end if; when z1 => if x = '0' then state <= z2; end if; when z2 => if x = '0' then state <= z3; else state <= z1; end if; when others => if x = '1' then state <= z1; y <= 1; else state <= z0; end if; end case; end process; end rtl2; <source>

mit one hot Codierung <source lang="vhdl"> architecture rtl3 of detect_fsm is signal z0, z1, z2, z4 : std_logic; begin process (rst, clk) begin if (rst = '1' then z0 <= '1'; z1 <= '0'; z2 <= '0'; z3 <= '0'; y <= '0'; elsif (clk = '1' and clk'event) then z0 <= (z0 or z3) and not x; z1 <= x; z2 <= zi and not x; z3 <= z2 and not x; y <= z3 and x; end if; end if; end process; end rtl3; </source>

7-Segment-Anzeige

BCD a b c d e f g 0 0000 0 0 0 0 0 0 1 . . . 9 1001 0 0 0 0 1 0 0

6. Testbenches

drei Skizzen

10. Vorlesung

Testumgebung für einen MUX

<source lang="vhdl"> library ieee; use ieee.std_logic_1164.all; entity mux is port (in 0, in 1, sel : in std_logic; z : out std_logic); end mux;

architecture rtl of mux is begin with sel select z <= in 0 when '0'; in1 when others; end rtl;

entity tb is end tb

architecture tb_version1 of tb is component mux port (in 0, in 1, sel : in std_logic; 2 : out std_logic); end component,

signal in 0, in 1, sel z : std_logic; type sample is record in0 : std_logic; in1 : std_logic; sel : std_logic; end record;

type samples_array is array (natural rang <>) of sample; constant test_data : sample_array := (('0','0','0',),('0','0','1'),('0','1','0'),('0','1','1'),('1','0','0'),('1','0','1'),('1','1','0'),('1','1','1')); begin dut: mux port map(in0 => in0, in1 => in1, sel => sel, z => z); process begin for i in test_data'range loop in0 <= test_data(i).in0; in1 <= test_data(i).in1; sel <= test_data(i).sel; wait for 10 ns; end loop; wait end process;

process begin wait for 5ns; assert z = '0' report "wrong result" severity note; wait for 10ns; assert z = '0' report "wrong result" severity note; wait for 10ns; assert z = '0' report "wrong result" severity note; wait for 10ns; assert z = '1' report "wrong result" severity note; wait for 10ns; assert z = '1' report "wrong result" severity note; wait for 10ns; assert z = '0' report "wrong result" severity note; wait for 10ns; assert z = '1' report "wrong result" severity note; wait for 10ns; assert z = '1' report "wrong result" severity note; wait for 10ns; wait; end process; end tb_version1; </source>

VERILOG

Ripple Carry Counter

<source lang='verilog'> module ripple_carry_counter (q, clk, reset); output [3:0] q; input clk, reset; T_FF tff0 (q [0], clk, reset); T_FF tff1 (q [1], q [0], reset); T_FF tff2 (q [2], q [1], reset); T_FF tff3 (q [3], q [2], reset); end module

module T_FF(q, clk, reset); output q; input clk, reset; wire d; D_FF dff0 (q, d, clk, reset); not n1 (d, q); end module

module D_FF (q, d, clk, reset); output q; input d, clk, reset; reg q;

always @(posedge reset or negedge dk) if (reset) q = 1'b0; else q = d; end module </source>

Materialien

Das vollständige Skript der aus dem Downloadbereich:

Skript

Beschreibung zum FPGA-Board für das Praktikum:

FPGA Board

Die Praktikumsanleitung zum Versuch Stoppuhr:

Stoppuhr

Die Praktikumsanleitung zum Versuch Signalgenerator:

Signalgenerator

Literaturhinweise

Hunter, R.D., Johnson, T.T.: Indruction to VHDL. Springer US 1995
Sjoholm, St., Lindh, L.: VHDL for Designers. Prentice Hall 1996
Reichardt, J.: VHDL-Synthese. Oldenbourg 2003
ältere Vorlesungsmitschrift