Hardware/Software Co-Design

Transkript

1 Hardware/Software Co-Design Kapitel : Logiksynthese und VHDL-Einführung Mario Schölzel

2 Geschichte von VHDL VHDL = VHSIC Hardware Description Language VHSIC = Very-High Speed Integrated Circuits Entwickelt Anfang der 98er Jahre im Auftrag des Verteidigungsministeriums der USA Ziel war eine Hardwarebeschreibungssprache für Bausteine mit folgenden Eigenschaften: Technologieunabhängige Beschreibung Beschreibung auf unterschiedlichen Abstraktionsebenen (Logikeben, RT-Ebene, ) Beschreibung aus unterschiedlichen Sichten (Verhaltenssicht, Struktursicht) Validierung in einem Simulator

3 Sichten Strukturelle Beschreibung eines Bausteins ist gekennzeichnet durch: Angabe der enthaltenen Sub-Bausteine mit ihren Ein- /Ausgängen Verschaltung der Sub-Bausteine Verhaltensorientierte Beschreibung eines Bausteins ist gekennzeichnet durch: Funktionale Beschreibung des Verhaltens mittels nebenläufiger Prozesse Dadurch Beschreibung der Änderung von Signalen in Abhängigkeit anderer Signale

4 Verwendung von VHDL Modellierung von Verhalten und Struktur zur Simulation Modellierung von Verhalten zur Synthese Algorithmen Boolesche Funktionen, Zustandsautomaten, Verhalten System Prozessor Logik Schalter Struktur Netlisten Physisch Abstraktionen / Ebenen nach Gajski (Y-Chart)

5 Beschreibung eines Bausteins Beschreibung der Schnittstelle: entity Baustein_Name is [generic (Parameterliste) ;] [port (Ein-/Ausgabesignale);] end [Baustein_Name]; Beschreibung der Implementierung: architecture Archiktektur_Name of Baustein_Name is [Deklarationsteil] begin VHDL-Anweisungen end [Baustein_Name]; Beispiel (Verhaltensbeschreibung eines Halbaddierers): library ieee; use ieee.std_logic_64.all; entity HA is port ( a : in std_logic; b : in std_logic; s : out std_logic; c : out std_logic ); end HA; architecture behvha of HA is begin s <= a xor b; c <= a and b; end behvha; nebenläufige Signalzuweisung

6 Simulation des Halbaddierers

7 Signale und Variablen Ein Signal dient der Kommunikation zwischen Prozessen/Komponenten Deklaration eines Signals: signal sname {,sname}: Datentyp; Deklaration in Architekturen, Prozessen, Funktionen/Prozeduren Signalzuweisung: Signal_Name <= Ausdruck Ausdruck muss vom gleichen Typ wie das Signal sein Verhalten: Zuweisung wird gepuffert und erst "später" ausgeführt; wichtig zur Simulation parallelen Verhaltens Beispiel : SIGNAL a, b, c: bit; a <= b; c <= a; Variablen speichern Werte innerhalb eines Prozesses Deklaration einer Variablen variable vname {,vname}: Datentyp; Deklaration nur in Prozessen, Funktionen/Prozeduren Variablenzuweisung: Ausdruck muss gleichen Typ wie die Variable sein Verhalten: Zuweisung wird sofort ausgeführt Beispiel: Var_Name := Ausdruck VARIABLE a, b, c: bit; a := b; c := a;

8 Strukturierung des VHDL-Codes Design besteht in der Regel aus mehreren Komponenten (Bausteinen) In einer VHDL-Datei können mehrere Bausteine beschrieben werden Im ganzen Design verwendete Datentypen, Operatoren Funktionen/Prozeduren und Komponenten können in packages organisiert werden Deklaration eines Packages package package_name is [Deklarationen]; end package package_name; Definition der Schnittstelle package body package_name is [Funktionen/Prozeduren/Bausteine] end package body; Einbinden einer Bibliothek: Implementierung => Bibliothek library library_name; use library_name.package_name.all Bibliothek work enthält übersetze Quellen des aktuellen Projekts Eigene Packages werden auch in Bibliothek work abgelegt werden

9 Beispiel für eigene Bibliothek Deklaration des eigenen packages lib im aktuellen Projekt package lib is [Deklarationen]; end package lib; package body lib is [Funktionen/Prozeduren/Bausteine] end package body; Einbinden in Quellcode des aktuellen Projekts library work; use work.lib.all

10 Datentypen Datentypen definieren eine Menge von Werten und zulässige Operationen auf diesen Werten. Unterscheidung in: Skalare Datentypen Integer-Datentypen Real-Datentypen Physikalische Datentypen (enthalten Dimensionsangaben) Aufzählungstypen Zusammengesetzte Datentypen Felder Verbunde VHDL ist eine streng getypte Sprache Zuweisung von a an b nur möglich, wenn a hat gleichen Typ wie b Typ von a ist Subtyp von b Deklaration von Datentypen im Deklarationsteil eines Packages Deklarationsteil einer Architektur

11 Integer-Datentyp Integer-Datentypen haben einen zusammenhängenden Wertebereich ganzer Zahlen Formal existiert ein anonymer Datentyp universal_integer, der alle ganzen Zahlen enthält Deklaration nicht anonymer Integer-Datentypen type Bezeichner is range Integer_Literal to Integer_Literal; type Bezeichner is range Integer_Literal downto Integer_Literal; Deklarierte Operationen: Relationale Operationen: =, /=, <, <=, >, >= Arithmetische Operationen: +, -, *, / (ganzzahlige Division) Potenzierung: ** Absolutwert: abs Modulo: mod Rest nach ganzzahliger Division: rem

12 Aufzählungstypen Deklaration type Bezeichner is (Element {, Element}); Reihenfolge der Aufzählung definiert totale Ordnung auf den Elementen Beispiel: Deklaration der Zustände eines endlichen Automaten: type state is (idle, start, stop);

13 Attribute auf skalaren Datentypen Attribute auf skalaren Datentypen T: T'base: Basisdatentyp von T T'high: maximaler Wert T'low: minimaler Wert T'left: Wert der linken Bereichsgrenze T'right: Wert der rechten Bereichsgrenze T'ascending: ist true, gdw. Wertebereich aufsteigend sortiert ist

14 Vordefinierte Datentypen Im package standard deklarierte skalare Datentypen type boolean is (false, true); type bit is ('', ''); type character is (nul, soh,, ' ', '!', '"',, 'a', 'b','c', ) type integer is range to ; type real is range -.E8 to.e8; type std_ulogic is ('U','X','','','Z','W','L','H','-') subtype std_logic is resolved std_ulogic; Im package standard deklarierte Subtypen und Felder subtype natural is integer range to integer'high; subtype positive is integer range to integer'high; type string is array (positive range <>) of character; type bit_vector is array (natural range <>) of bit;

15 Beschränkte Felder Bei der Deklaration werden Bereichsgrenzen festgelegt Deklaration: type Bezeichner is array (Wertebereich {,Wertebereich}) of Datentyp_name; Beispiel: type byte is array (7 downto ) of bit; type wort is array ( to 4) of byte; type brett is array ( to 9, to 9) of integer; signal a: byte; Zugriff auf Feldelemente: a <= ('', '', '', '', '', '', '', ''); a <= (7 downto 5 => '', others => ''); a(7) <= ''; a <= ( => '', downto => '', => '');

16 Unbeschränkte Felder Bereichsgrenzen werden erst bei der Instanziierung einer Variablen/eines Signals festgelegt Deklaration: type Bezeichner is array (Disk_Typ range <> {,Disk_Typ <>}) of Datentyp_name; Beispiele (aus den packages standard und std_logic_64): type string is array (positive range <>) of character; type bit_vector is array (natural range <>) of bit; type std_ulogic_vector is array (natural range <>) of std_ulogic; type std_logic_vector is array (natural range <>) of std_logic; Instanziierung signal Z_Bus: bit_vector( downto ); signal Z_Bus: std_logic_vector( to ); Zugriff auf Feldelemente wie bisher

17 Hierarchie und Strukturbeschreibung Eine Architektur kann ausschließlich aus Komponenten beschrieben werden; dadurch: rein strukturelle Beschreibung der Architektur möglich Hierarchische Organisation der Beschreibung Komponenten sind Bausteine, deren Verhalten bereits spezifiziert wurde Zu verwendende Komponenten werden in der Deklarationssektion einer Architektur bekannt gemacht durch: component Baustein_Name is [generic (Parameterliste) ;] [port (Ein-/Ausgabepins);] end component;

18 Beispiel Volladdierer (Struktur- Sicht) library ieee; use ieee.std_logic_64.all; entity FA is port ( a : in std_logic; b : in std_logic; ci : in std_logic; s : out std_logic; co : out std_logic ); end FA; architecture structfa of FA is component HA is port ( a : in std_logic; b : in std_logic; s : out std_logic; c : out std_logic ); end component; signal c: std_logic; signal c: std_logic; signal zs: std_logic; cin a b HA zs c HA c s OR c begin ha: HA port map ( a => a, b => b, s => zs, c => c ); ha: HA port map ( a => ci, b => zs, s => s, c => c ); co <= c or c; end structfa;

19 Simulationsergebnisse Volladdierer

20 Explizite Prozesse Prozesse dienen der verhaltensorientierten Beschreibung einer Architektur Ein Prozess wird aktiviert, sobald sich ein Signal aus seiner Sensitivitätsliste ändert Prozess-Anweisung process [(Sensitivitätsliste)] [is] Deklarationsteil begin Ausführungsteil end [process] [Marke]; Ausführungsteil ist eine Folge von sequentiell ausgeführten Anweisungen Verschiedene Prozesse werden aber nebenläufig (ohne festgelegte Reihenfolge) ausgeführt

21 Beispiel Volladdierer (Verhaltenssicht) library ieee; use ieee.std_logic_64.all; entity FA is port ( a : in std_logic; b : in std_logic; ci : in std_logic; s : out std_logic; co : out std_logic ); end FA; architecture behavfa of FA is begin fulladder: process (a, b, ci) begin s <= a XOR b XOR ci; co <= (a AND b) OR (ci AND (a XOR b)); end process; end behavfa; cin a b HA zs c HA c s OR c

22 Implizite Prozesse Implizite Prozesse werden durch nebenläufige Signalzuweisungen im Anweisungsteil einer Architektur erzeugt Nebenläufige Signalzuweisung: target <= waveformelem {, waveformelem} unaffected; Waveformelem ist value_expr [after time_expr] null [after time_expr] Alternative Prozess-Anweisung process (Sensitivitätsliste) is begin target <= waveform end process; Dabei enthält Sensitivitätsliste alle Signale aus value_expr

23 Beispiel library ieee; use ieee.std_logic_64.all; entity FA is port ( a : in std_logic; b : in std_logic; ci : in std_logic; s : out std_logic; co : out std_logic ); end FA; architecture behavfa of FA is begin s <= a XOR b XOR ci; co <= (a AND b) OR (ci AND (a XOR b)); end behavfa; cin a b HA zs c HA c s OR c

24 Ausführungsteil in Prozessen Der Ausführungsteil in einem Prozess ist eine Folge von Anweisungen Anweisungsfolge wird sequentiell abgearbeitet Anweisungen können sein: Signal-/Variablenzuweisungen if-anweisung case-anweisung Schleifen for while loop wait-anweisung

25 Syntax: if Bedingung then {sequentielle_anweisung} {elsif Bedingung then {sequentielle_anweisung}} [else {sequentielle_anweisung}] end if; if-anweisung Beispiele: If Bedingung then sequentielle Anweisungen End if; If Bedingung then sequentielle Anweisungen End if;... If Bedingung n then sequentielle Anweisungen End if; If Bedingung then sequentielle Anweisungen elsif Bedingung then sequentielle Anweisungen elsif Bedingung then... elsif Bedingung n then sequentielle Anweisungen End if;

26 Syntax: Beispiel: case-anweisung case Ausdruck is when Auswahl => {sequentielle_anweisung} {when Auswahl => {sequentielle_anweisung} } end case; case Ausdruck is when Wert_ => Anweisungen when Wert_ Wert_ Wert_4 => Anweisungen when Wert_5 to Wert_6 => Anweisungen when Wert_7 Wert_8 to Wert_ => Anweisungen... when Wert_n => Anweisungen when others => Anweisungen End case; Fehlt die others-anweisung, dann müssen alle möglichen Fälle explizit aufgezählt werden

27 Schleifen Syntax loop: loop Anweisung... exit when Bedingung... Anweisung end loop Syntax for: for Bezeichner in disk_werteberich loop Anweisungen end loop Beispiel: for k in to 5 loop... end loop Syntax while while Bedingung loop Anweisungen end loop Beispiel while k < 5 loop Anweisungen; k := k + ; end loop

28 Die wait-anweisung Darf in Prozessen verwendet werden Syntax der wait-anweisung: wait [on Signal_Name {, Signal_Name}] [until Bedingung] [for Zeit]; wait on hält einen Prozess an, bis eine Änderung in einem der angegebene Signale auftritt wait until hält einen Prozess an, bis die Bedingung wahr wird Es ergibt sich folgende Äquivalenz: wait on s wait until s'event wait for weckt einen Prozess nach der angegebenen Simulationszeit auf

29 Sensitivitätsliste Prozess ohne wait mit nicht leerer Sensitivitätsliste: P: process(clk, res) begin if res = '' then out <= ''; elsif clk = '' and clk'event then out <= not in; end if; end process; Semantisch äquivalenter Prozess mit wait und leerer Sensitivitätsliste: P: process begin if res = '' then out <= ''; elsif clk = '' and clk'event then out <= not in; end if; wait on clk, rst; end process;

30 Simulationsprinzip VHDL verwendet das Prinzip der Co-Routinen. D.h.: Jeder Prozess gibt an statisch definierten Punkten (wait-anweisung) die Kontrolle an den Simulationskern zurück. Dieser aktiviert dann einen weiteren Prozess oder beendet die Simulation. Prozesse mit nicht-leerer Sensitivitätsliste enthalten am Ende eine implizite wait-anweisung Beispiel: Ereignisse aus den Sensitivitätslisten von p und p sind aufgetreten Reihenfolge der Aktivierung von p und p nicht festgelegt 4. Simulationskern. p.. p wait() wait()

31 Beispiel Prozess ohne Sensitivitätsliste: CLOCK_GEN: process begin clk <= ''; 4 wait for 5 ns; 5 clk <= '' 6 wait for 5 ns; 7 end process; clk ns 5 ns ns 5 ns ns

32 Simulationsprinzip Für die Simulation muss auf der untersten Ebene jeder Baustein verhaltensorientiert beschrieben sein Wird in einem Prozess keine wait-anweisung ausgeführt, gerät die Simulation in eine Endlosschleife Initialisierung Aktualisierung der Signale Simulationszyklus Ausführung der aktiven Prozesse Simulationsende

33 Initialisierungsphase Jedem Signal wird ein Wert zugewiesen, abhängig von seinem Datentyp Simulationsuhr wird auf gesetzt Alle Prozesse des zu simulierenden Bausteins werden gestartet; d.h. sie werden bis zum ersten wait ausgeführt

34 Exkurs: Wertzuweisung an Signale Jedes Signal besitzt eine Transaktionsliste Wertzuweisung sig <= sig_val after time_val; zum Zeitpunkt curr_time erzeugt Eintrag (cur_time + time_val, sig_val) in Transaktionsliste Erst nach Abschluss eines kompletten Simulationszyklus werden Signalwerte in der Aktualisierungsphase aktualisiert: signal Zeit Wert 5 ns ns 4 Transaktionsliste 5 ns 6

35 Aktualisierungsphase Weitersetzen der aktuellen Simulationszeit t_current auf nächsten Zeitpunkt t_next, an dem ein Ereignis stattfindet. Dazu Betrachtung von Transaktionsliste der Signale Weckliste der Prozesse (wegen wait for time_val Anweisung) Ausführen aller Signalzuweisungen, die bei t_next ausgeführt werden müssen Ändert das den Wert eines Signals aus einer Sensitivitätsliste, dann wird der zugehörige Prozess geweckt und in der folgenden Ausführungsphase ausgeführt Deltazyklen entstehen, wenn t_next = t_current ist

36 Ausführungsphase/Stoppregeln Alle in der letzten Aktualisierungsphase geweckten Prozesse werden ausgeführt Ausführung in einer nicht festgelegten Reihenfolge Da aber Signalwerte sich während dieser Ausführungsphase nicht ändern (passiert nur in der Aktualisierungsphase) hat die Ausführungsreihenfolge keinen Einfluss auf die Ergebnisse Simulation endet, falls Transaktionsliste und Weckliste nach der Ausführungsphase leer oder Vorgegebene Simulationszeit ist erreicht Delta-Zyklus (Simulationszeit unverändert) Delta-Zyklus (Simulationszeit unverändert) Prozesse auswerten Signale aktualisieren Prozesse auswerten Signale aktualisieren aktueller Simulationszeitpunkt nächster Simulationszeitpunkt

37 Beispiel () Beispiel für Trennung der Auswertungsphase und Signalaktualisierung: architecture behv of exmp is signal a,b: std_logic; begin TAUSCHE: process(a,b) begin a <= b after ns; b <= a after ns; end process; end architecture;

38 Beispiel () Was passiert jetzt? architecture behv of exmp is signal a,b: std_logic; begin TAUSCHE: process(a,b) begin a <= b after ns; b <= a after ns; end process; end architecture;

39 Synthese aus VHDL Code Verhalten Logik Struktur Gatter (NAND, NOR), Flip-Flops Zustandsautomaten zur Modellierung sequentieller Logik, Aussagenlogische Formeln, Wahrheitswertetabellen zur Modellierung Boolescher Funktionen Physisch Abstraktionen / Ebenen nach Gajski (Y-Chart)

40 Kombinatorische Logik Ausgaben hängen funktional von den Eingaben ab. x x x z z = f (x,,x n ) z z m = f m (x,,x n )

41 Modelle für kombinatorische Logik Verhalten Wahrheitswertetabelle: b b d d z Struktur Gatternetzliste b d NAND NOR NOR z Aussagenlogische Ausdrücke d b NAND AND BDDs KV-Diagramme

42 Beschreibung kombinatorischer Schaltungen mit VHDL Ziel: Modellierung einer kombinatorischen Schaltung, die den Wert eines Ausgabesignals (Leitung) erzeugt Wichtig: Ausgabesignal ist funktional abhängig von Eingaben Änderung irgend eines Eingangssignals muss Berechnungsprozess aktivieren (jedes Eingangssignal in Sensitivitätsliste) Aktualisierung jedes Ausgangssignals bei jeder Aktivierung des Berechnungsprozesses (jedes Ausgangssignal muss immer geschrieben werden) Modellierung mit: Nebenläufiger Signalzuweisung oder Prozess

43 Nebenläufige Signalzuweisung Nebenläufige Signalzuweisung: Es können keine Signale in der Sensitivitätsliste vergessen werden Schreibt immer ein Signal Beispiel: library IEEE; use IEEE.STD_LOGIC_64.all; entity bist is port(b,b,d,d: in std_logic; z: out std_logic); end bist; architecture conc_sig of bist signal s,s,s,s4: std_logic; begin s <= b nand d; s <= d nand b; s <= s nor s; s4 <= s and s; z <= s4 nor s; end architecture; b d d b NAND NAND NOR AND NOR z

44 Beispiel: Kombinatorischer Prozess Kombinatorischer Prozess: Sensitiv auf alle Signale, die im Prozess gelesen werden Schreibt bei jeder Aktivierung Ausgangssignal Beispiel: architecture proc of bist begin process(b,b,d,d) variable s,s: std_logic; begin s := b nand d; s := d nand b; s := s nor s; s := s and s; z <= s nor s; end process; end architecture; b d NAND NOR NOR z d b NAND AND

45 Beispiel: Kombinatorischer Prozess Beispiel: entity x is port(a,b,c: in std_logic; Z : out std_logic); end x; architecture behav of x begin process(a,b,c) begin if C = then Z <= A; else Z <= B; end if; end process; end architecture; Synthese

46 Sequentielle Logik Keine funktionale Abhängigkeit von den Eingaben wegen internem Speicher x x x FF z z z = f (FF,,FF k,x,,x n ) z m = f m (FF,,FF k,x,,x n )

47 Speicherelemente Flankengesteuerte Flip-Flops (D-Flip-Flop) Verhalten flankengesteuerte Flip-Flops (D- Flip-Flop) D Dateneingang Q Datenausgang clk Takteingang Zustandsgesteuerte Flip-Flops (Latch) Verhalten zustandsgesteuerte Flip-Flops (D- Latch) D Dateneingang Q Datenausgang clk Takteingang D FF clk Q D Latch clk Q Q D Takt t Takt t+ Takt t+ clk Q D Takt t Takt t+ Takt t+ clk

48 Beschreibung von Speicherelementen in VHDL Beschreibung von D-Flip-Flops ohne set/clear durch Prozesse mit spezieller Struktur: process begin wait until clockedge; -- Hier Beschreibung der synchronen Logik end process; end architecture; clockedge ist dabei: clock_name = logic- clock_name = logic- rising_edge(clock_name) falling_edge(clock_name) -- nur für std_logic/std_ulogic -- nur für std_logic/std_ulogic Für Signale, die unter der Kontrolle der wait-anweisung geschrieben werden, werden Flip-Flops synthetisiert Für Variablen, die unter der Kontrolle der wait-anweisung geschrieben werden, werden Flip-Flops synthetisiert, falls: die Variable gelesen werden kann, bevor sie geschrieben wird Wird die Variable immer definiert, bevor sie gelesen wird, dann wird kein speicherndes Element für die geschriebene Variable benötigt

49 Beispiel: Flip-Flop aus einem Signal entity ff is port( clk: in bit; currstate: in integer range to 5; nextstate: out integer range to 5 ); end ff; currstate_ D Q nextstate_ architecture infer of ff begin process begin wait until clk = ''; nextstate <= currstate; end process; end architecture; currstate_ clk currstate_ clk D clk D clk QN Q QN Q QN nextstate_ nextstate_ currstate_ D Q nextstate_ clk QN

50 Beispiel: Flip-Flop aus einer Variablen Flip-Flop wird auch für temp erzeugt: process variable temp : integer range to 5; begin wait until clk = ''; nextstate <= temp; temp := currstate; end process; Für temp wird kein Flip-Flop erzeugt: process variable temp : integer range to 5; begin wait until clk = ''; temp := currstate; nextstate <= temp; end process; Schaltbild für den oberen Fall?

51 Antwort D clk Q QN nextstate_ D clk Q QN nextstate_ D clk Q QN nextstate_ D clk Q QN nextstate_ D clk Q QN currstate_ D clk Q QN currstate_ D clk Q QN currstate_ D clk Q QN currstate_ clk FFs für Variable temp FFs für Signal nextstate

52 Flip-Flops mit synchronem set/clear process begin wait until clk = ''; if rst = '' then counter <= ; else counter <= counter + ; end if; end process; end architecture;

53 Flip-Flops mit asynchronem set/clear Beschreibung von Flip-Flops mit asynchronem set/clear durch Prozesse mit spezieller Struktur: process(sensitivitätsliste) begin if condition_ then -- Asynchrone Logik elsif condition_n then -- Asynchrone Logik elsif clock_edge then -- Synchrone Logik end if; end process; end architecture; clockedge ist dabei: clock_name = clk_val and clock_name'event rising_edge(clock_name) -- nur für std_logic/std_ulogic falling_edge(clock_name) -- nur für std_logic/std_ulogic Sensitivitätsliste enthält alle gelesenen Signale des asynchronen Teils und clock_name

54 Latches Beschreibung von Latches durch Prozesse Zu einem Signal wird ein Latch generiert, wenn es in dem Prozess einen Pfad gibt, auf dem dieses Signal nicht definiert wird (und der Prozess kein Flip-Flop für das Signal erzeugt) Zu einer Variablen wird ein Latch generiert, wenn es in dem Prozess einen Pfad gibt, auf dem dieses Signal nicht definiert wird und es einen Pfad gibt, auf dem die Variable gelesen wird, bevor sie definiert wird Beispiel: process(clk, curr_state) begin if clk = '' then next_state <= curr_state; end if; end process;

55 Beispiel: Sequentielle Schaltung und Delta-Zyklus Reg ist sequentielle Logik, die ausgehende Signale nur ändert, wenn Aktivierung wegen clk-signal stattfand. CL ist kombinatorische Logik, die immer aktiviert wird, wenn sich eines ihrer Eingangssignale ändert. clk clk clk clk clk clk clk clk clk lreg rreg lreg rreg lreg rreg lreg rreg lreg rreg lreg rreg lreg rreg lreg rreg lreg rreg CL CL CL CL CL CL CL CL CL Zeit t: clk hat sich geändert Zeit t, Delta : Prozess Reg ist aktiviert und ändert Ausgangssignal Zeit t, Delta : Prozess Reg ist aktiviert und ändert Ausgangssignal Geänderte Signale aktualisieren Zeit t, Delta : Prozess CL ist aktiviert und ändert Ausgangssignale Geänderte Signale aktualisieren Zeit t, Delta : Prozess Reg ist aktiviert und ändert kein Ausgangssignal Zeit t, Delta : Prozess Reg ist aktiviert und ändert kein Ausgangssignal Keine Signale mehr gändert, Simulationszeit auf t+ setzen.

56 Modelle für sequentielle Logik Verhalten Struktur Moore-Automat: Moore-Automat: Endlicher Automat mit Ausgabe in den Zuständen a FF z a Zustandsübergangsfunktion d FF Ausgabefunktion l z a m FFk z m Mealy-Automat: Endlicher Automat mit Ausgabe an den Kanten Mealy-Automat: a FF z a Zustandsübergangsfunktion d FF Ausgabefunktion l z a m FFk z m

57 Moore-Automat Moore-Automat (Q,E,A,l,d,q) Q endliche Menge von Zuständen E Eingabealphabet A Ausgabealphabet d : Q E Q ist die Zustandsübergangsfunktion l: Q A ist die Ausgabefunktion q ist der Startzustand Beispiel (Zähler):

58 Verhalten Moore-Automat Eine Situation (q, a, b) besteht aus Zustand z Î Q Eingabe a Î E * Ausgabe b Î A * Die Relation Í (Q E* A*) (Q E* A*) ist die Menge aller möglichen Situationsübergänge eines Moore-Automaten, wobei ((q, aa, b), (q, a, bb)) Î gdw. d(q,a) = q und l(q ) = b * Menge der möglichen Läufe Zur Eingabe a =a a a a n erzeugt ein Moore-Automat die Ausgabe b b b b n, falls eine Folge von Situationsübergängen (q, a a a a n,e) (q, a a a n, b ) (q, a a n, b b ) (q, e, b b b b n ) existiert. Akzeptierte Sprache eines Moore-Automaten A L(A) = {(a,b) ((q,a, e), (z, e, b)) Î * und q ist Startzustand}

59 Beispiel (,,e) (,,) (,,) (,,) (,,) (,,) (,,) (, e,)

60 Mealy-Automat Mealy-Automat (Q,E,A,l,d,q) Q endliche Menge von Zuständen E Eingabealphabet A Ausgabealphabet d : Q E Q ist die Zustandsübergangsfunktion l: Q E A ist die Ausgabefunktion q ist der Startzustand Beispiel (Zähler): / / / / / / / /

61 Verhalten Mealy-Automat Eine Situation (q, a, b) besteht aus Zustand z Î Q Eingabe a Î E * Ausgabe b Î A * Die Relation Í (Q E* A*) (Q E* A*) ist die Menge aller möglichen Situationsübergänge eines Mealy-Automaten, wobei ((q, aa, b), (q, a, bb)) Î gdw. d(q,a) = q und l(q,a) = b * Menge der möglichen Situationsübergänge Zur Eingabe a =a a a a n erzeugt ein Moore-Automat die Ausgabe b b b b n, falls eine Folge von Situationsübergängen (q, a a a a n,e) (q, a a a n, b ) (q, a a n, b b ) (q, e, b b b b n ) existiert. Akzeptierte Sprache eines Mealy-Automaten A L(A) = {(a,b) ((q,a, e), (q, e, b)) Î * }

62 Beispiel / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / (,,e) (,,) (,,) (,,) / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / (,,) (,,) (,,) (, e,)

63 Moore- und Mealy-Automat Ein Moore-Automat A und ein Mealy-Automat B sind äquivalent, gdw. L(A) = L(B) Jeder Moore-Automat kann in einen äquivalenten Mealy-Automat transformiert werden. Jeder Mealy-Automat kann in einen äquivalenten Moore-Automaten transformiert werden.

64 library IEEE; use IEEE.STD_LOGIC_64.ALL; VHDL-Beschreibung Moore- entity moorecounter is Port ( direction : in STD_LOGIC; clk : in STD_LOGIC; rst : in STD_LOGIC; result : out STD_LOGIC_VECTOR( downto ) ); end moorecounter; architecture Behavioral of moorecounter is signal state : STD_LOGIC_VECTOR( downto ); begin process(clk, rst) begin if rst='' then state <= ""; elsif clk = '' and clk'event then case direction & state is when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when others => state <= ""; end case; end if; end process; Automat result <= state; -- oder explizite Definition eines -- komb. Prozesses der sensitiv auf state ist end Behavioral;

65 library IEEE; use IEEE.STD_LOGIC_64.ALL; VHDL-Beschreibung Mealy- entity mealycounter is Port ( direction : in STD_LOGIC; clk : in STD_LOGIC; rst : in STD_LOGIC; result : out STD_LOGIC_VECTOR( downto ) ); end mealycounter; Automat architecture Behavioral of mealycounter is signal state : STD_LOGIC_VECTOR( downto ); begin process(clk, rst) begin if rst='' then state <= ""; elsif clk = '' and clk'event then case direction & state is when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when "" => state <= ""; when others => state <= ""; end case; end if; end process; process(direction, state) begin case direction & state is when "" => result <= ""; when "" => result <= ""; when "" => result <= ""; when "" => result <= ""; when "" => result <= ""; when "" => result <= ""; when "" => result <= ""; when others => result <= ""; end case; end process; end Behavioral;