7 - Technische Universität Clausthal

techwww.in.tu.clausthal.de

7 - Technische Universität Clausthal

4.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 1/114

Entwurf digitaler Schaltungen (F7)

Kapitel 3, Teil 2

VHDL im Detail

Abschnitt 3.4 Beschreibungsschablonen für digitale

Schaltungen

Abschnitt 3.5 Schablonen für den Testrahmen

Prof. G. Kemnitz

Institut für Informatik, Technische Universität Clausthal

9. Juli 2013


4.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 1/114

Entwurfsempfehlungen

1.1 Kombinatorik-Packages

1.2 Bäume statt Ketten

1.3 Register & Latches

UART

2.1 Erstes Simulationsmodell

2.2 Taktausrichtung und Initialisierung

2.3 Synthesebeschreibung

CORDIC

3.1 Algorithmus

3.2 Erstes Simulationsmodell

3.3 Festkommazahlenformat

3.4 Algorithmus weiter optimieren


5. Entwurfsempfehlungen

FIR-Filter

4.1 Pipeline und Speicherengpass

4.2 FIR-Filter mit Blockspeichern

4.3 Der Weg zum 1. Simulationsmodell

4.4 Zahlendarstellung durch Bitvektoren

4.5 Ein- und Ausgabe über Signale

4.6 Beschreibung als Automat

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 2/114


5. Entwurfsempfehlungen

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 2/114

Entwurfsempfehlungen


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 3/114

5. Entwurfsempfehlungen

Beschreibungsschablonen für digitale Schaltungen

Die Beschreibungsstruktur eines Simulationsmodells sollte

verständlich, kompakt und selbst erklärend sein,

gleiche Beschreibungsbausteine mehrfach nutzen etc.

Beschreibungsschablonen sind mit Beispielinhalten

dekorierte Empfehlungen; Bisher eingeführte Schablonen:

Abtastprozess, kombinatorischer Prozess,

Testrahmen für Anweisungstests,

Str-Funktionen, Get-Prozeduren, ...

Dieser Abschnitt enwickelt Empfehlungen für die Strukturierung

von Funktionsbeschreibungen mit

anwendungsspezischen Datentypen,

Schleifen, Unterprogrammen und Packages


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 4/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Kombinatorik-Packages


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 5/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Kombinatorische Funktionen in Packages

Simulationmodell einer kombinatorischen Schaltung:

schwarzer Kasten mit Ein- und Ausgangssignalen

bei jeder Eingabeänderung wird die Ausgabe neu berechnet

Zuweisung mit/ohne Halte- und Verzögerungszeit

Kombinatorische Funktion:

Funktion zur Berechnung der Ausgaben aus den Eingaben

einer kombinatorischen Schaltung

Warum in VHDL-Package-Funktion auszulagern

übereinstimmender Beschreibungsteil in der Synthese- und in

den Simulationsbeschreibungen

separat testbar

kein Speicherverhalten beschreibar; Fehlertyp ungewolltes

Speicherverhalten ausgeschlossen


of. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 6/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

x 1

x 2 fkt(x 1 , x 2 ,...) tTyp

· · ·

· · · y

Entwurfseinheit(en)

- - Signalvereinbarungen

signal x1: ...;

signal x2: ...;

signal y: yTyp;

- - Simulationsmodell

y


5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Beispiel Prioritäts-Encoder

Zielfunktion:

für einen Eingabevektor x ist das höchstwertigste Bit zu

bestimmen, das 1 ist, plus 1-Bit-Gültigkeitsinformation

Ergebnistyp:

type tPEncOut is record

w: tUnsigned(3 downto 0);

g: std_logic;

end record;

Verbund aus einem Bitvektor für

die Bitnummer und einer

1-Bit-Gültigkeitsinformation

Prioritäts-

Encoder

x

x

w g

0000000000

0000 0

1 - - - - - - - - - 1001

1

01 - - - - - -- - - 1000

1

001 - - - - - -- 0111 1

0001

- - - - - 0 110

1

. . . . . . . . .

- beliebig (don’t care)

die Bitbreite des Eingabevektors braucht erst beim Aufruf

festgelegt zu werden

die Breite der Ergebnisbitnummer ist im Verbund festgelegt

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 7/114

w

g


5. Entwurfsempfehlungen 1. Kombinatorik-Packages

function PrioEnc(x:std_logic_vector)

return tPEncOut is

variable y: tPEncOut:=(w=>x"0", g=>'0');

begin

assert x'high


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 9/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Zweckmäÿige Denitionen auf Vorrat

eine Konstante für ungültig (invalidieren aller Bits)

constant XX_PEncOut: tPEncOut:=(w=>"XXXX", g=>'X');

Testfunktion auf ungültig:

function is_x(x: tPEncOut) return boolean is

begin

return is_x(x.w) or is_x(x.g);

end function;

Str-Funktion:

function str(x: tPEncOut) return string is

begin

return "(w=" & str(x.w) & ", g=" & str(x.g) & ")";

end function;

⇒WEB-Projekt: P3.4/PEnc_pack.vhdl


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 10/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Testrahmen für das Package

Dialogtest für die kombinatorische Funktion und für die

Hilfsfunktionen:

- Vereinbarungen im Testprozess

variable x: std_logic_vector(9 downto 0);

variable y: tPEncOut;

- Anweisungsfolge im Testprozess

loop

read("Bitte 10-Bit-STD_LOGIC_VECTOR eingeben:", x);

y := PrioEnc(x);

write("x=" & str(x) & " is_x(x)=" & str(is_x(x))

& " y=" & str(y));

end loop;


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 11/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Simulationsmodell des Prioritätsencoders

constant th: delay_length := 1 ns

constant td: delay_length := 3 ns

signal x: std_logic_vector(9 downto 0);

signal y: tPEncOut;

...

y


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 12/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Anwendung auf Register-Transfer-Beschreibungen

x

T

tX

f 1

tZ1

Package

z1

tZ1

f 2

z2 f 3 y

tZ2 tZ2 tZ2 tY

Simulationsmodell

package . . . is

[sub]type tX is . . .

[sub]type tZ1 is . . .

[sub]type tZ2 is . . .

[sub]type tY is . . .

function f1(x: tX) return tZ1 is . . .

function f2(x1: tZ2; x2: tZ2)

return tZ2 is . . .

function f3(x: tZ2) return tY is . . .

end package;

signal T: STD LOGIC;

signal x: tX;

signal z1: tZ1;

signal z2: tZ2;

signal y: tY;

. . .

Abtastprozess: process(T)

begin

if RISING EDGE (T) then

z1


of. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 13/114

5. Entwurfsempfehlungen 1. Kombinatorik-Packages

Eine Register-Transfer-Beschreibung stellte eine sequentielle

Schaltung als ein System aus Verarbeitungsfunktionen und

Abtastregistern dar.

Empfehlung:

Auslagerung der Verarbeitungsfunktionen und der Typenund

Konstantenvereinbarungen in Packages

Beschreibung der Register als Signalzuweisungen in

Abtastprozessen mit Funktionsaufrufen.

Vorteile:

Übersichtliche, gut strukturierte Prozessbeschreibungen.

Überwiegend Programmierung seperat testbarer

Unterprogramme.

Test und Fehlersuche überwiegend mit imperativen Mitteln

über Eingaben, Ausgabe und Zwischenergebnisse möglich.

Entwurfsbeispiele für mittlere bis groÿe Schaltungen folgen

später.


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 14/114

5. Entwurfsempfehlungen 2. Bäume statt Ketten

Bäume statt Ketten


5. Entwurfsempfehlungen 2. Bäume statt Ketten

Bäume statt Ketten

In parametrierten Schaltungsmodellen werden assoziative

Verknüpfung von n Operanden mit Schleifen beschrieben:

y = x n−1 ◦ x n−1 ◦ . . . ◦ x 1 ◦ x 0

Eine einfache Schleife erzeugt eine Kette:

type tVektortyp is (natural range ) of tTyp;

variable x, z: tVektortyp(n-1 downto 0);

...

begin

z(0):=x(0);

for idx in z'range loop

z(idx):=z(idx-1) ◦ x(idx);

end loop;

Nachteil: lineare Zunahme der

Verzögerung mit der Kettenlänge

x 0 z 0

x 1

z 1

x 2

z 2

· · ·

x n−1

z n+1

längster Signalpfad

assoziativer Operator

(+, ∨, ∧, ⊕, ...)

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 15/114


5. Entwurfsempfehlungen 2. Bäume statt Ketten

Assoziativ bedeutet, dass die Reihenfolge der Zusammenfassung

keinen Einuss auf das Ergebnis hat. Alternative zur Kette:

Zusammenfassen zuerst von Paaren von Eingabesignalen,

dann von Paare von Zwischenergebnissen ⇒ Baum

((x 1 ◦ x 0 ) ◦ (x 3 ◦ x 2 )) ◦ ((x 4 ◦ x 5 ) ◦ x 6 )

auch mit variabler Operandenanzahl beschreibbar:

type tVektortyp is (natural range ) of tTyp;

variable x: tVektortyp(n-1 downto 0);

variable z: tVektortyp(2*n-2 downto 0);

...

begin

z(x'range):=x;

for idx in 0 to n-1 loop

z(idx+n):=z(2*idx) ◦ z(2*idx+1);

end loop;

x 0 , z 0 z 7

z

x 1 , z 10

1

x 2 , z 2 z 8

z 12

x 3 , z 3

z 11

x 4 , z 4 z 9

x 5 , z 5

x 6 , z 6

Rückgabewert

lokale Variablen

Eingabe

Baumstruktur: logarithmische

Zunahme der Verzögerung mit der Operandenanzahl

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 16/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 17/114

5. Entwurfsempfehlungen 2. Bäume statt Ketten

Das Prinzip ist auch auf andere Reduktionsschemen anwendbar.

Carry-Save-Addierer: paarweise Zusammenfassung von drei

Eingängen zu zwei Zwischenwerte

x 0

x 1

x 2

x 3

x 4

x 5

x 6

x 7

x 8

x 9

z 0

s

s

s

s

s z 24

z 1 CSA z 10 CSA z 16 CSA

CSA z 22 CSA z 25

z c

c

c

2

z 11

z c

17

z c

20 z 23

z 3

s z 12

s z 18

z 21

z 4 CSA z 13 CSA z 19

z c

c

5

z 14

z 6

s z 15

CSA Carry-Save-Addierer

z 7 CSA

c

Pfad mit der längsten Verzögerung

z 8

z i Variable, in der der Wert gespeichert wird

z 9

für kleine Schaltungen schat es die Synthese selbst, Ketten

in Bäume umzuwandeln

bei groÿen Schaltungen ist es besser, optimierte Strukturen

zu generieren


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 18/114

5. Entwurfsempfehlungen 3. Register & Latches

Register & Latches


5. Entwurfsempfehlungen 3. Register & Latches

Register und Latches als nebenläuge Prozeduren

Simulationsmodell eines Registers

constant XX: tType:= ... ;

constant aw: tTyp := ...

signal T, I, E: in std_logic;

signal x, y: tTyp;

...

process(T, I)

begin

if I='1' then

y


5. Entwurfsempfehlungen 3. Register & Latches

Berechnung bei I = 0 und fallender Taktanke

if x'last_event>ts and E'last_event>ts then

y


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 21/114

5. Entwurfsempfehlungen 3. Register & Latches

Das Unterprogramm-Modell für eine Schaltung mit Gedächtnis

ist eine nebenläuge aufzurufende Prozedur mit

Signalen als Übergabeparameter,

einer internen Endlosschleife und

Datenspeicherung in Ausgabesignalen oder lokalen Variablen

procedure RegModell(signal T, I, E: std_logic;

signal x: std_logic_vector; aw: std_logic_vector;

signal y: out std_logic_vector; td, th, ts, tn:

delay_length:=0 fs) is

constant XX: std_logic_vector(y'range):=

(others=>'X');

begin

loop

-- alle Anweisungen aus dem Prozess

-- von if I='1' bis zum zugehörigen end if

wait on T, I;

end loop; end procedure;

⇒WEB-Projekt: P3.4/Reg_pack.vhdl


of. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 22/114

5. Entwurfsempfehlungen 3. Register & Latches

-

Plan beats no plan!

Bereits die Aufstellung der Zielfunktion für eine digitale

Schaltung ist idealerweise ein Prozess mit simulierbaren

Zwischenschritten.

Wie können diese Zwischenschritte aussehen

Welche VHDL-Beschreibungsmittel sind dafür zu empfehlen

Planung der zu simulierenden Testbeispiele

Demonstration an Beispielentwürfen:

UART (≈ 10 3 Gatter)

CORDIC (≈ 10 4 Gatter)

FIR-Filter (≈ 10 5 Gatter)

Point-of-Interest-Suche (≈ 10 6 Gatter)


6. UART

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 23/114

UART


6. UART

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 24/114

Entwurfsschritte

UART universal asynchron receiver transmitter

Ableitung der Algorithmen aus der Aufgabenstellung

Modellierung wie ein normales Programm mit Ein- und

Ausgaben

Aufteilung der Berechnungsschritte in Zeitschritte

Auslagerung von Typendenitionen und Unterprogrammen

in Packages

Steuerung der Zeitabläufe mit Signalen (Takt, Initialisierung,

Operationsstart etc.)

Umwandlung in eine synthesegeeignete

Beschreibungsstruktur.


6. UART

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 25/114

Serielle Übertragung

System 1

Sender TxD

Empfänger RxD

serielle Übertragung

von 1 nach 2

Pegelwandlevon

2 nach 1

Pegel-

wandler

System 2

RxD Empfänger

TxD Sender

RxD, TxD

1

0

TxD Sendesignal

Bezugspotenzial (3. Leitung)

x 0 x 1 x 2 x 3 x 4 x 5 x 6 x 7 P x 0

0 1 2 3 4 5 6 7 8 9 10 11

RxD

Empfangssignal

t

t Bit

a)

Stoppbit

Startbit

Datenbits

Paritätsbit

b)

a) Verbindung zweier Systeme über eine serielle Schnittstelle

b) Übertragung eines Datenpakets


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 26/114

6. UART 1. Erstes Simulationsmodell

Erstes Simulationsmodell


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 27/114

6. UART 1. Erstes Simulationsmodell

Ziel

Wunsch

Aufstellung einer formalen, simulierbaren

Funktionsbeschreibung

Kontrolle, ob die algorithmischen Ideen die Zielfunktion

nachbilden und ob sie realisierbar sind

Entwicklung von Testrahmen und Testbeispielen für den

späteren richtigen Entwurf

übersichtliche Beschreibungsform, leicht zu ändern und zu

debuggen


Start zum Simulationsbeginn; Endlosschleife

Beschreibung durch imperative Anweisungen,

Warteanweisungen, Signalauswertung und Signalzuweisung

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 28/114

6. UART 1. Erstes Simulationsmodell

Senderfunktion als nebenläuge Prozedur

Vorteile der Beschreibungsform: Kapselung, imperativ

procedure Sender(signal Start:std_logic;

signal x:tByte; signal TxD, busy out std_logic;

tbit:delay_length) is

variable P: std_logic;

begin

loop

...

end loop;

end procedure;

Schnittstellenverhalten

1

Start

0

1

Busy 0

x

10001011

TxD

1

0

Startflanke Daten Parität


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 29/114

6. UART 1. Erstes Simulationsmodell

Kontrolluss in der Endlosschleife

TxD


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 30/114

6. UART 1. Erstes Simulationsmodell

Funktionsmodell des Empfängers

procedure Empfaenger(signal RxD: std_logic;

signal y: out tByte; signal Ready, Err: out

std_logic; tbit: delay_length) is

variable P: std_logic;

begin

Ready


6. UART 1. Erstes Simulationsmodell

Kontrolluss in der Endlosschleife

wait until RxD='0';

Ready


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 32/114

6. UART 1. Erstes Simulationsmodell

Simulation

Testrahmen ist eine Entwurfseinheit ohne Anschlüsse

- Signalvereinbarungen im Testrahmen

signal x, y: tByte;

signal Start, Busy, TxD, RxD, Ready, Err: std_logic;

constant tbit: delay_length: 100 us;

Beschreibung des Testrahmens

- Funktionsmodell des Senders

Sender(Start, x, TxD, Busy, tbit);

- Funktionsmodell des Empfängers

Empfaenger(RxD, gnt, y, reg, err, 0.99*tbit);

- Funktionsmodell der Verbindung

RxD


6. UART 1. Erstes Simulationsmodell

Dialogprozess zur Erzeugung

der Testeingaben

Eingabe: process

variable vx: tByte;

variable dtStart:

delay_length;

begin

Start

Busy

TxD

1

0

1

0

x

1

0

10001011

Startflanke Daten Parität

Eingabesignale des Senders

read("Wartezeit bis Start=1 eingeben.", dtStart);

wait for dtStart; Start


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 34/114

6. UART 1. Erstes Simulationsmodell

Textausgaben wie beim Debuggen von Software sind auch

möglich; z.B. Ausgabe aller Signalaktivitäten des Readyund

des Error-Signals

Ausgabe: process(Ready, Err)

begin

write(str(now)&" : Ready=" & str(Ready) & " Err="

& str(Err) & " y=" & Str(y));

end process;

Zusammenfassung

Kapselung der Sender- und des Empfängerfunktion

Prozeduren gekapselt

weitgehende Anlehnung an den Softwareentwurf

einfach zu entwerfen

änderungsfreundlich

prüfgerecht, aber

nicht synthesefähig


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 35/114

6. UART 2. Taktausrichtung und Initialisierung

Taktausrichtung und Initialisierung


zusätzliche Schleife; geänderte Warteanweisungen

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 36/114

6. UART 2. Taktausrichtung und Initialisierung

Sender

Funktionsmodell mit

”warte für eine Taktperiode”

Initialisierung

S1: Wiederhole immer

TxD


6. UART 2. Taktausrichtung und Initialisierung

procedure Sender(signal T, I, Start, Start_del: std_logic;

signal x: tByte; signal TxD, busy: out std_logic) is

variable P: std_logic;

begin

S0: loop

S1: loop

RxD


of. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 38/114

6. UART 2. Taktausrichtung und Initialisierung

Änderungen:

zusätzliche Eingangssignale für den Takt und die

Initialisierung

dafür kein Übergabeparameter für die Dauer der Taktperiode

zusätzliche Schleife

Ersatz der Wartebedingung durch eine andere

Wartebedingung und eine bedingte Abbruchanweisung

Formale Nachbesserungen, die im Entwurfsprozess warten

können, bis die sonstigen Funktionsabläufe zufriedenstellend sind


6. UART 2. Taktausrichtung und Initialisierung

Empfänger

Bezugszeitpunkt für die Abtastzeitpunkte

ist die erste fallende

Flanke von RxD

16-fache Taktfrequenz +

reinitialisierbarere Taktteiler

Warteprozedur mit Zähler:

procedure Warte(signal T,I:

std_logic; ct: inout

tUnsigned(3 downto 0)) is

begin

loop

ct:=ct+"1";

wait on rising_edge(T) or I='1';

exit when I='1' or ct="0000";

end loop;

end procedure;

Ready


6. UART 2. Taktausrichtung und Initialisierung

variable ct: tUnsigned(3 downto 0);

begin

S0:loop

Ready


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 41/114

6. UART 2. Taktausrichtung und Initialisierung

Änderungen:

zusätzliche Eingangssignale für den Takt und die

Initialisierung

dafür kein Übergabeparameter für die Dauer der Taktperiode

zusätzliche Schleife

Ersatz der Wartebedingung durch eine Warteprozedur und

eine bedingte Abbruchanweisung für die Reinitialisierung

Formale Nachbesserungen, die im Entwurfsprozess warten

können, bis die sonstigen Funktionsabläufe zufriedenstellend sind

Ergebnis:

Funktionsbeschreibungen mit einem durch eine synchrone

Schaltung nachbildbaren Zeitverhalten

nicht synthesefähig


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 42/114

6. UART 3. Synthesebeschreibung

Synthesebeschreibung


auch mehrere Abtastprozesse

zusätzliche asynchrone Initialisierung

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 43/114

6. UART 3. Synthesebeschreibung

Synthesebeschreibung für sequentielle Schaltungen

x

T

tX

f 1

tZ1

Package

z1

tZ1

f 2

z2 f 3 y

tZ2 tZ2 tZ2 tY

Simulationsmodell

package . . . is

[sub]type tX is . . .

[sub]type tZ1 is . . .

[sub]type tZ2 is . . .

[sub]type tY is . . .

function f1(x: tX) return tZ1 is . . .

function f2(x1: tZ2; x2: tZ2)

return tZ2 is . . .

function f3(x: tZ2) return tY is . . .

end package;

signal T: STD LOGIC;

signal x: tX;

signal z1: tZ1;

signal z2: tZ2;

signal y: tY;

. . .

Abtastprozess: process(T)

begin

if RISING EDGE (T) then

z1


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 44/114

6. UART 3. Synthesebeschreibung

Entwurfsweg

Nachbildung des Programmablaufs durch einen

Kontrollussgraphen

Bezeichnung der Zustände und Nachbildung des

Zustandsraums durch ein Zustandssignal

Entwickung der Funktionen für den Zustandsübergang, die

Ausgabe und die gesteuerten Operationen

Beschreibung als Abtastprozess

Ergänzung der Abtastregister für alle asynchronen

Eingabesignale


Wartezustand ⇒ Kontrollusszustand

Schleifenvariable i ⇒ ein 3-Bit-Zähler

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 45/114

6. UART 3. Synthesebeschreibung

Kontrollussgraph des Senders

Wiederhole immer

T xD


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 46/114

6. UART 3. Synthesebeschreibung

Datentyp für den Automatenzustand

Aufzählungstyp für die Kontrollusszustände:

type tZTyp is (zStop, zStart, zDaten, zParitaet);

Ergebnistyp der Übergangsfunktion:

type tZustand is record

z: tZTyp; - Kontrollflusszustand

i: tUnsigned(2 downto 0); - Zähler

P: std_logic; - Paritätsbit

busy: std_logic;

- Status

end record;


6. UART 3. Synthesebeschreibung

Übergangsfunktion

function fz(Start:std_logic;

x: tByte; z_in: tZustand)

return tZustand is

variable z: tZustand:=z_in;

begin

case z.z is

when zStop =>

i


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 48/114

6. UART 3. Synthesebeschreibung

Ausgabefunktion

function f_TxD(x: tByte;

z_in: tZustand)

return std_logic is

begin

case z.z is

when zStart =>

return '0';

when zDaten =>

return x(int(z.i));

when zParitaet =>

return z.P;

when others =>

return '1';

end case;

end function;

sonst

zStop

busy


6. UART 3. Synthesebeschreibung

synthesefähige Gesamtbeschreibung

- Signalvereinbarung in der Entwurfseinheit

signal z: tZustand; signal x: tByte;

signal I, I_del, T, Start, Start_del, Busy, TxD: std_logic;

- Abtastprozess für asynchrone Eingabesignale

process(T) begin

Start_del '0', busy=>'1');

elsif rising_edge(T) then

z


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 50/114

6. UART 3. Synthesebeschreibung

Zusammenfassung:

Ersatz der Wartezustände durch Automatenzustände

Typenvereinbarungen für Funktionsrückgabewerte

Programmierung der Übergangs- und der

Ausgabefunktion(en) als VHDL-Funktionen

Gesamtbeschreibung:

ein Abtastprozess für die asynchronen Eingabesignale mit

nur dem Takt in der Weckliste

ein Abtastprozess für die Übergangsfunktion mit

Initialisierungssignal in der Weckliste

Der Entwicklungsuss mit mehreren simulierbaren

Zwischenergebnissen mag aufwändig erscheinen, vermeidet jedoch

eine langwierige planlose Fehlersuche und verbessert die

Vorhersagbarkeit des Entwurfsaufwandes und die Zuverlässigkeit

der entworfenen Schaltungen.


7. CORDIC

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 51/114

CORDIC


7. CORDIC

rof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 52/114

Entwicklung des Funktionsmodells eines

CORDIC-Rechenwerks

CORDIC Coordinate Rotation Digital Computer

Rechenwerk für Winkelfunktionen (sin, cos etc.)

Betrachtete Entwurfsschritte

Beschreibung des Algorithmus zuerst verbal, dann als

Simulationsmodell

Optimierung des Datentyps für die Zahlendarstellung

Optimierung des Rechen- und Hardwareaufwand

Die zu entwerfende Schaltung ist eine Zehnerpotenz gröÿer als

eine UART. Die weiteren Schritte bis zur synthesefähigen

Beschreibung sind analog zu denen für UART-Entwurf und

werden nicht noch einmal betrachtet.


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 53/114

7. CORDIC 1. Algorithmus

Algorithmus


7. CORDIC 1. Algorithmus

Mathematische Grundlage

Rotation eines Vektors in einem Koordinatensystem:

y i+1

1

y i

φ i

α

0

0 xi+1 x i 1

x i = cos (α)

y i = sin (α)

x i+1 = cos (α + φ i ) = cos (α) · cos (φ i ) − sin (α) · sin (φ i )

= x i · cos (φ i ) − y i · sin (φ i )

y i+1 = sin (α + φ i ) = cos (α) · sin (φ i ) + sin (α) · cos (φ i )

= x i · sin (φ i ) + y i · cos (φ i )

⎛ ⎞ ⎛

⎝ x i+1

⎠ = ⎝ cos (φ i) − sin (φ i )

y i+1 sin (φ i ) cos (φ i )

⎞ ⎛ ⎞

⎠ · ⎝ x i


y i

Beim CORDIC-Algorithmus wird der Drehwinkel aus einer festen

Anzahl konstanter Winkelschritte abnehmender Gröÿe

zusammengesetzt und schrittweise der zugehörige Sinus- und

Kosinus-Wert berechnet.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 54/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 55/114

7. CORDIC 1. Algorithmus

In jedem Schritt nächst kleinere Winkelkonstante addieren

oder subtrahieren

Iterationsziel: Annäherung der Winkelsumme an den

φ

Vorgabewert φ z

. . .

+φ 0 −φ 1 +φ 2 +φ 3

φ z

φ

+φ 0 −φ 1 −φ 2 +φ 3

. . .

0 1 2 3 . . .

Iterationsschritt

0 1 2 3 . . .

Iterationsschritt

φ z

zu jeder Winkeladdition/-subtraktion gehört eine

Matrixmultiplikation

(

xn

y n

)

=

(

cos (±φn−1 ) − sin (±φ n−1 )

sin (±φ n−1 ) cos (±φ n−1 )

)

·. . .·

(

cos (±φ0 ) − sin (±φ 0 )

sin (±φ 0 ) cos (±φ 0 )

) ( )

1

·

0


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 56/114

7. CORDIC 1. Algorithmus

Optimierung zur Hardware-Nachbildung

Hauptaufwand vier Multiplikationen je Rotation

Kosinus cos (φ i ) = cos (−φ i ) ausklammern:

( ) (

xn

= SCS·

y n

) (

) ( )

1 − tan (±φ n−1 )

1 − tan (±φ 0 ) 1

·. . .·

·

tan (±φ n−1 ) 1

tan (±φ 0 ) 1 0

Winkelvorzeichen unabhängigen Konstante:

SCS =

n−1


i=0

cos (φ i )

Winkelschritte so wählen, dass die Tangens-Konstanten

absteigende Zweierpotenzen sind

(

xn

y n

)

= SCS·

(

) ( ) ( ) ( )

1 ∓2 −n+1

1 ∓2 −1 1 ∓2 −0 1

·. . .·

·

·

±2 −n+1 1

±2 −1 1 ±2 −0 1 0

statt 4 · n Multiplikationen nur eine Multiplikation mit SCS


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 57/114

7. CORDIC 1. Algorithmus

Hardware-Algorithmus

signal φ, φ z , x, y: tDaten;

Wiederhole immer

Eingabe φ z ; φ


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 58/114

7. CORDIC 1. Algorithmus

Winkelkonstanten

i 0 1 2 3 4 5 6 i > 6

tan (φ i ) 2 −0 2 −1 2 −2 2 −3 2 −4 2 −5 2 −6 2 −i

φ i 0.785 0,464 0,245 0,124 0,062 0,031 0,015 ≈ 2 −i

Faktor für die Abschlussmultiplikation:

SCS =

n−1


i=0

cos ( arctan ( 2 −i)) ≈ 0,617


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 59/114

7. CORDIC 2. Erstes Simulationsmodell

Erstes Simulationsmodell


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 60/114

7. CORDIC 2. Erstes Simulationsmodell

Datentypen und Funktionen

Zahlentyp (später durch Bitvektortyp zu ersetzen) +

Vektortyp für die Konstantentabelle:

subtype tDaten is real range -2.0 to 2.0;

type tDatenArray is array (natural range ) of tDaten;

Überladen des sra-Operators (arithetische

Linksverschiebung) für tDaten:

function "sra"(a:tDaten; b:natural) return tDaten is

begin

return a/(2.0**b);

end function;

cos- und atan-Funktion ist in ieee.math_real deniert:

use ieee.math_real.cos;

use ieee.math_real.atan;


7. CORDIC 2. Erstes Simulationsmodell

Erzeugen der Konstantentabelle:

function AtanTab return tDatenArray is

variable Tab: tDatenArray(0 to 31);

begin

for idx in Tab'range loop

Tab(idx):=atan(1.0 sra idx);

end loop;

return Tab;

end function;

constant cAtanTab: tDatenArray:= AtanTab;

Berechnen der Konstanten SCS:

function SCS return tDaten is

variable w: tDaten:=1.0;

begin

for idx in Tab'range loop

w:=w*cos(cAtanTab(idx));

end loop;

return w;

end function;

rof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 61/114


of. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 62/114

7. CORDIC 2. Erstes Simulationsmodell

Testrahmen mit Dialogeingabe

signal cos, sin, phi: tDaten;

constant tp: delay_length:= 1 ns;

...

process

variable phi_z: tDaten;

begin

wait for tP; - Eingabebereitschaft

Wiederhole immer

CORDIC-

Algorithmus

Eingabe phi z;

phi


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 63/114

7. CORDIC 2. Erstes Simulationsmodell

Der CORDIC-Algorithmus selbst

...

for idx in cAtanTab'range loop

if phi_z>phi then

cos


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 64/114

7. CORDIC 2. Erstes Simulationsmodell

Was leistet das Simulationsmodell

Das Modell erlaubt:

Kontrolle des Algorithmus und der Konstanten

Festlegung der erforderlichen Anzahl von Interationsschritten

Kontrolle, dass die Wertebereiche ausreichen

Visualisierung der Signalverläufe

gezielte Ausgabe von Zwischenergebnissen zur Fehlersuche


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 65/114

7. CORDIC 3. Festkommazahlenformat

Festkommazahlenformat


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 66/114

7. CORDIC 3. Festkommazahlenformat

Was ist zu ändern

aller Operanden und Zwischenergebnisse liegen hier im

Bereich zwischen ±1,7.

16-Bit-Festkommaformat von 10,0...0 2 = −2 bis

01,1...1 2 = 2 − 2 −14 :

subtype tDaten is tSigned(15 downto 0);

Änderung in der Berechnung der Konstantentabelle (mit 2 14

multiplizieren, nach integer und weiter nach tSigned

konvertieren:

variable Tab: tWortArray(0 to 31); - mit tDaten als

Elementetyp

...

Tab(idx):=to_tSigned(integer(2.0**14*atan(1.0 sla idx));

Änderung bei der Berechnung der Konstanten SCS:

return to_tSigned(integer(2.0**14*w));


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 67/114

7. CORDIC 3. Festkommazahlenformat

Anpassen der Konstanten im Testrahmen:

Wert Gleitkommadarstellung tSigned, gedachtes Komma nach Bit 13

1 1.0 b"0100_0000_0000_0000"=x"4000"

0 0.0 b"0000_0000_0000_0000"=x"0000"

Mit dem überarbeiteten Simulationsmodell kann insbesondere

geprüft werden, ob eine 16-Bit-Rechengenauigkeit passend,

unzureichend oder überdimensioniert ist, und wieviele

Iterationschritte wirklich benötigt werden.

Das Zahlenformat beeinusst Rechengenauigkeit, Anzahl der

Berechnungsschritte und den Hardwareaufwand

Risiko Wertebereichsüberlauf

Probleme nacheinander angehen


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 68/114

7. CORDIC 4. Algorithmus weiter optimieren

Algorithmus weiter optimieren


7. CORDIC 4. Algorithmus weiter optimieren

Eleminieren der beiden Multiplikationen

der bisherige CORDIC benötigt drei Addierer/Subtrahierer,

zwei Blockshifter, Zähler und zwei Multiplizierer für

SCS· cos (...) und SCS· sin (...).

Alternative: Nachbildung der Multiplikation durch bedingte

Additionen; Kosten 16 zusätzliche Berechnungsschritte

Wiederhole immer

Eingabe, CORDIC-Schritte

. . .

Multiplikationen

wiederhole für alle Bits i von SCS

ja

SCS(i)=’1’

x


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 70/114

7. CORDIC 4. Algorithmus weiter optimieren

es gibt weitere Optimierungsmöglichkeiten: einsparbare

Register, einsparbare Zeitschritte

wenn alles ok.:

Ablaufsteuerung auf Signale (Takt, Init, Start etc.) umstellen.

Umwandlung in eine synthesegeeignete Beschreibung.


8. FIR-Filter

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 71/114

FIR-Filter


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 72/114

8. FIR-Filter 1. Pipeline und Speicherengpass

Pipeline und Speicherengpass


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 73/114

8. FIR-Filter 1. Pipeline und Speicherengpass

Pipeline-Verarbeitung

Arbeitsstationen

1 2 3 4

Fließband

fertig

4

Arbeits- 3

station 2

1

t P

Werkstück

Dauer eines Fließbandtakts

Fließbandtakt: 1 · t P

Fertigungszeit: 4 · t P

1 2 3 4 5 t

t P

Aufteilung einer Gesamtaufgabe in N P Arbeitsschritt.

Gesamtaufwand je Objekt: N P · t T (t T Periode Schritttakt)

Je Takt wird ein Objekt fertig.

Folgerung 1

Parallelverarbeitung ohne vielfachen Aufwand


8. FIR-Filter 1. Pipeline und Speicherengpass

Angewendet auf Hardware

t dR

t dS1 t dS2 t sR

t dS1

z y

t dS2

f 2 (z)

t sR

x x’

y’

f 1 (x’)

T

f(x’) = f 2 (f 1 (x’))

t dR Registerverzögerungszeit

Verzögerungszeit von f 1 (...)

Verzögerungszeit von f 2 (...)

Registervorhaltezeit

x Eingabesignal

z Zwischensignal

y Ausgabesignal

...’ abgetastetes Signal

t dR t dS1 t sR t dR t dS2 t sR

x x’

f 1 (x’)

z z’

f 2 (z’)

y’ y”

T

minimale Taktperiode

ohne Pipeline

t dR + t sR + t dS1 + t dS2

mit Pipeline

t dR + t sR + max(t dS1 , t dS2 )

Aufwand: ein zusätzliches Register je Pipeline-Stufe.

Viel billiger als mehrfache Hardware. Vorzuglösung für

Parallelverarbeitung.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 74/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 75/114

8. FIR-Filter 1. Pipeline und Speicherengpass

Pipeline in VHDL

t dR

t dS1

t sR

t dR

t dS2

t sR

x x’ z z’ y’ y”

f 1 (x’)

f 2 (z’)

T

process(T)

if rising_edge(T) then

x_del


of. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 76/114

8. FIR-Filter 1. Pipeline und Speicherengpass

Speicherengpass

Schnelle Verarbeitung verlangt schnelle Speicher als Quelle

und Empfänger der Daten.

Für gröÿere Datenobjekte Blockspeicher statt Register.

Die Zugriszeit auf Blockspeicher wächst mit der

Datenkapazität.

Groÿe Datendurchsätze verlangen mehrere parallele

Speicher, Mehrportspeicher, Erhöhung der Datenwortbreite

oder andere schaltungsaufwändige Maÿnahmen.

Der Entwurf von schnellen Verarbeitungswerken beginnt deshalb

in der Regel mit der Planung der Speicherstruktur, einer

Ablaufplanung der Speicherzugrie und einer Planung der

Verarbeitungs-Pipelines.


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 77/114

8. FIR-Filter 2. FIR-Filter mit Blockspeichern

FIR-Filter mit Blockspeichern


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 78/114

8. FIR-Filter 2. FIR-Filter mit Blockspeichern

FIR-Filter (FIR nite impulse response)

Filter mit endlicher Impulsantwort.

Grundalgorithmus der digitalen Signalverarbeitung.

Jeder Ausgabewert ist die gewichtete Summe einer Folge von

M Eingabewerten:

y n =

M−1


m=0

c m · x k mit k = n − m (1)

(x k Eingabewert; y n Ausgabewert; n Nummer des

Zeitschritts; c m Koezient; M Länge der Impulsantwort,

Gröÿenordnung 100).

Anwendung: Hochpass, Tiefpass, Glättungslter etc. (legt

der Vektor der Koezienten c m fest).

Aufwand: bis zu vielen Milliarden Multiplikationen,

Additionen und Speicherzugrien pro Sekunde.


n − 1 Additionen, natürlich als Baum mit CSA-Addierern.

HW-Aufwand etwa wie ein Multiplizierer. Verarbeitungszeit

ca. 2× Additionszeiten.

n Multiplikationen. Hoher Hardware-Aufwand.

Verarbeitungszeit ca. 2 . . . 3× Additionszeit.

n Lesezugrie für Daten und n Lesezugrie für Koezienten

(Konstaten). Wie realisieren n-Port-Speicher Für gröÿere

n sehr aufwändig!

rof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 79/114

8. FIR-Filter 2. FIR-Filter mit Blockspeichern

Rechenwerk für einen Ergebniswert

x n

c0

x n−1

c 1

x n−2

x n−3

c 3

*

*

c 2

*

*

+

+

+ y n


8. FIR-Filter 2. FIR-Filter mit Blockspeichern

Schieberegister als Datenspeicher

x + n

x n

x n−1

x n−2

c 0

*

c 1

*

c 2

*

c 3

*

x n−3

+

+

+

y n

Die Indexrechnung k = n − m in

y n =

M−1


m=0

c m · x k

ist beschreibbar durch Weiterrücken der Datenwerte in einem

Schieberegister. Erspart den n-Port-Blockspeicher.

Gibt es auch Lösungen, in der die Multiplikationen

nacheinander ausgeführt werden, um Hardware zu sparen

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 80/114


8. FIR-Filter 2. FIR-Filter mit Blockspeichern

Lösung mit Blockspeichern

Die Daten sollen in einem 1-Port-Speicher stehen, aus dem ein

Wert pro Takt gelesen werden kann. Was sollte in diesem Takt

(in der Regel) parallel erfolgen

Adressrechnung für Daten und Koezient.

Koezient Lesen.

Multiplikation.

Addition zum akkumulierten Ergebnis.

+1

+1

cAdr

xAdr

cROM

a ROM y

xRAM

x RAM y

a

w

mult

+

Akku

Ergebnis

M Takte, aber nur ein Multiplizierer.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 81/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 82/114

8. FIR-Filter 2. FIR-Filter mit Blockspeichern

Pipeline-Register ergänzen

+1

+1

AR

cAdr

xAdr

cROM

a ROM y

xRAM

x RAM y

a

w

OF

cDat

xDat

Register

cAdr Koeffizientenadressregister

xAdr Datenadressregister

cDat Koeffizientenregister

xDat Datenregister

mult

Mult

Prod

+

Add

Akku

Ergebnis

Koeffizientenspeicher

Datenspeicher

Pipeline-Phasen

AR Adressrechnung

OF Operanden lesen

Mult Multiplikation

Add Addition

Prod Produktregister

Akku Akkumulator (Summationsregister)

Blockspeicher

cROM

xRAM

Aufteilung in vier Schritte: AR, OF, ...

Einzelberechnung wird etwas langsamer, aber es wird

parallel an vier Ergebnissen gerechnet.


8. FIR-Filter 2. FIR-Filter mit Blockspeichern

Ablauf am Beispiel M = 4

RT-Op.

A

cAdr 1 2 3 0 1 2 3 0 1 2 3 0

xAdr 3 2 1 0 1 2 3 3 0 1 2 2

xRAM W(x 0 ) W(x 1 ) W(x 2 ) W(x 3 ) R(x 2 ) R(x 1 ) R(x 0 ) W(x 4 ) R(x 3 ) R(x 2 ) R(x 1 ) W(x 5 )

cDat

c 0 c 1 c 2 c 3 c 0 c 1 c 2 c 3

xDat

x 3 x 2 x 1 x 0 x 4 x 3 x 2 x 1

Prod

c 0 · x 3 c 1 · x 2 c 2 · x 1 c 3 · x 0 c 0 · x 4 c 1 · x 3 c 2 · x 2

∑ 1 ∑ 2 ∑ 1

Akku

c 0 · x 3 ... ...

y 0 c 0 · x 4 ...

Zustand Init Startzyklus

Normalzyklus Normal...

Register

cAdr Koeffizientenadressreg.

xAdr Datenadressregister

cDat Koeffizientenregister

A A b b b c B B B C B

Blockspeicher

Speicheroperationen

xDat

cROM Koeffizientenspeicher W(...) Speichern

Prod Datenregister

Produktreg. xRAM Datenspeicher R(...) Lesen

Akku Akku.-Reg.

Jede Spalte ist die RT-Operation für einen Takt.

Ablauf: wiederhole 3× Operation A, wiederhole 3×

Operation b, 1× Operation c, ...

Halbformale Beschreibung der Lösung

Nächster Schritt: Simulationsmodell zur Kontrolle.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 83/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 84/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Der Weg zum 1. Simulationsmodell


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 85/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Datentypen und Bearbeitungsmethoden

Komplexe Zielfunktionen in überschaubaren Schritten

entwerfen und Zwischenkontrollen.

In Anlehnung an die objektorientierte Programmierung

empehlt es sich, mit der Denition der Typen der zu

verarbeitenden Datenobjekte und Unterprogrammen zu ihrer

Verarbeitung zu beginnen (Package.)

Für die ersten Simulationen genügen reele Zahlen als Daten

und natürliche Zahlen als Index:

- Typvereinbarungen für den FIR-Filter

constant M: positive := 4; - Filtergrad

subtype tAdr is natural range 0 to M-1;

constant max_abs: real := 1000.0; -

Werteber.-Grenze

type tDaten is real range -(max_abs) to max_abs;

type tMem is array (natural range ) of tDaten;


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 86/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Die zwei Adressregister und die vier Datenregister der Pipeline

sollen zur gemeinsamen Übergabe an die

Bearbeitungs-Prozeduren zu einem Verbund zusammengefasst

werden:

- Datentyp für den Pipeline-Zustand

type tPipeline is record

cAdr, xAdr: tAdr;

cDat, xDat, Prod, Akku: tDaten;

end record;

Der Gesamtzustand des FIR-Filters besteht aus dem

Datenspeicherzustand und dem Pipeline-Zustand.


8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Die Operatoren + und * für den Typ tDaten

tDaten

function "+"(a, b: tDaten) return tDaten is

tDaten

+

constant sum: real := real(a) + real(b); tDaten

begin

if a=tDaten'low or b=tDaten'low or (abs sum)>max_abs then

return tDaten'low; - Pseudo-Wert für ungültig

else return tDaten(sum);

end if;

end function;

tDaten

function "*"(a, b: tDaten) return tDaten is

tDaten

*

constant prod: real := real(a) * real(b); tDaten

begin

if a=tDaten'low or b=tDaten'low or (abs prod)>max_abs then

return tDaten'low; - Pseudo-Wert für ungültig

else return tDaten(prod);

end if;

rof. G. Kemnitz end function;

· Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 87/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 88/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Bearbeitungsmethoden für die RT-Funktionen

RT-Operation in der Init-Phase zum Ablegen von Daten in

den Blockspeicher.

Die Daten sind Eingabewerte der Prozedur, der Block-Ram

für die Daten und der Pipeline-Zustand werden als les- und

veränderbar übergeben.

procedure InitStep(x: tDaten; signal xRAM:

inout tMem; signal pp: inout tPipeline) is

begin

pp.cAdr


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 89/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Die RT-Funktionen in den anderen Phasen unterscheiden

sich nur geringfügig. Zusammenfassen zu einer RT-Funktion

mit Fallunterscheidung.

cAdr

xAdr

xRAM

cDat

xDat

Prod

Akku

0

+1 mod M

W(x n

)

c M−1

x n−M+1

1

+1 mod M

R(x n−1

)

c 0

x n

c M−2 · x n−M+2

c M−1 · x n−M+1

∑M−3

...

∑M−2

...

2

. . . M −2 M −1

c 1 c 2

. . . c M−2

+1 mod M . . . +1 mod M nicht zählen

R(x n−2

) . . . R(x n−M+2

) R(x n−M+1

)

x n−2

. . .

x n−1

c 0 · x n

c 1 · x n−1

c 2 · x n−2

∑ 2

...

x n−M+2

. . .

y n = ∑M−1

...

c 0 · x n

. . .

cAdr Koeffizientenadressregister xDat Datenregister

x ...

cROM Koeffizientenspeicher Prod Produktregister

c ...

cDat Koeffizientenregister Akku Akkumulationsregister W(...)

xAdr Datenadressregister

im Startzyklus optional R(...)

xRAM Datenspeicher

geänderter Datenfluss M

Datenwert

Koeffizient

Schreiben

Lesen

Filtergrad


8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

cAdr

xAdr

xRAM

cDat

xDat

Prod

Akku

2

. . .

0

1

M −2 M −1

c M−2 · x n−M+2

c M−1 · x n−M+1

c 0 · x n

c 1 · x n−1

c 2 · x n−2

. . .

c M−1

c 0

c 1 c 2

. . . c M−2

+1 mod M

W(x n

)

+1 mod M

R(x n−1

)

+1 mod M

R(x n−2

)

. . .

. . .

+1 mod M

R(x n−M+2

)

nicht zählen

R(x n−M+1

)

x n−M+1

x n

x n−1

x n−2

. . . x n−M+2

∑M−3 ∑M−2

y n = ∑M−1

...

...

... c 0 · x n

∑ 2

... . . .

procedure NormalStep(x: tDaten; cROM: tMem;

signal xRAM: inout tMem;

signal pp: inout tPipeline) is

begin

pp.cAdr


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 91/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Testrahmen

Innerhalb des Testrahmens werden vereinbart:

eine initialisierte Konstante für den Koezientenspeicher:

constant cROM: tMem(tAdr) := (0.5, 1.0, -1.0, -0.5);

ein Signal für den Datenspeicher

signal xRAM: tMem(tAdr);

ein Signal für das Pipeline-Objekt

signal pp: tPipeline;

ein Dateiobjekt zum Einlesen der Eingabewerte x n

le Eingabedatei: text open read_mode is "Eingabe.txt";

und eine Konstante für die Taktperiode

constant Tp: delay_length := 10 ns;

Der Filtergrad M = 4 steckt in der Typvereinbarung von tAdr.


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 92/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Testprozess

- Vereinbarungen im Testprozess

variable x: tDaten;

variable InitRdy: boolean;

variable s: tString;

- Anweisungsfolge im Testprozess

- Initialisierung und Ausgabe Tabellenkopf

pp.cAdr


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 93/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Schleifenkörper

if pp.cAdr=0 then

if endfile(Eingabedatei) then wait; end if;

read(Eingabedatei, x); assign(s, str(x));

else assign(s, " ");

end if;

append(s, str(pp, xRAM));

if pp.cAdr=2 then

if not InitRdy then InitRdy := true;

else - Ausgabe

append(s, str(pp.Akku));

end if;

end if;

write(s); - Ausgabe der Ergebniszeichenkette

NormalStep(x, cROM, xRAM, pp);

wait for tp;


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 94/114

8. FIR-Filter 3. Der Weg zum 1. Simulationsmodell

Testausgabe

Eingabe:|cAdr|xAdr|| cDat | xDat || Prod | Akku || r(0) r(1) r(2) r(3) |Ausgabe:

100.0| 1| 3|| XX | XX || XX | XX || XX XX XX XX |

200.0| 2| 2|| XX | XX || XX | XX || XX XX XX 100.0|

300.0| 3| 1|| XX | XX || XX | XX || XX XX 200.0 100.0|

400.0| 0| 0|| XX | XX || XX | XX || XX 300.0 200.0 100.0|

| 1| 1|| 0.2000| 400.0|| XX | XX || 400.0 300.0 200.0 100.0|

| 2| 2|| 0.5000| 300.0|| 80.0| XX || 400.0 300.0 200.0 100.0|

| 3| 3|| -0.5000| 200.0|| 150.0| 80.0|| 400.0 300.0 200.0 100.0|

600.0| 0| 3|| -0.2000| 100.0|| -100.0| 230.0|| 400.0 300.0 200.0 100.0|

| 1| 0|| 0.2000| 600.0|| -20.0| 130.0|| 400.0 300.0 200.0 600.0|

| 2| 1|| 0.5000| 400.0|| 120.0| 110.0|| 400.0 300.0 200.0 600.0| 110.0

| 3| 2|| -0.5000| 300.0|| 200.0| 120.0|| 400.0 300.0 200.0 600.0|

-600.0| 0| 2|| -0.2000| 200.0|| -150.0| 320.0|| 400.0 300.0 200.0 600.0|

| 1| 3|| 0.2000| -600.0|| -40.0| 170.0|| 400.0 300.0 -600.0 600.0|

| 2| 0|| 0.5000| 600.0|| -120.0| 130.0|| 400.0 300.0 -600.0 600.0| 130.0

Eine übersichtliche Ergebnisdarstellung lohnt sich, weil sie

den Aufwand für die Bewertung der Tests und die

Fehlersuche erheblich mindert.

Es wäre auch sinnvoll, die Ausgabefolge so in eine Datei zu

schreiben, dass man sie in Matlab einlesen und mit den

Ausgaben eines dort pogrammierten Filters vergleichen kann.


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 95/114

8. FIR-Filter 4. Zahlendarstellung durch Bitvektoren

Zahlendarstellung durch Bitvektoren


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 96/114

8. FIR-Filter 4. Zahlendarstellung durch Bitvektoren

Ersatz der Zahlentypen durch Bitvektortypen

Austausch der Zahlentypen gegen geeignete Bitvektortypen, ohne

das gesamte Modell neu zuschreiben.

Adresswerte, Wertebereich 0 bis 3:

subtype tAdr is tUnsigned(1 downto 0);

Mit einem Bitvektor als Adresse entfallen die mod-(2 n )

Operationen (n Ergebnisbitanzahl).

Datendarstellung als 16-Bit vorzeichenbehaftete

Festkommazahlen:

subtype tDaten: tSigned(15 downto 0);

Überladen der Zugrimethoden auf den Speicher:

function read(Mem: tMem; adr: tAdr)

return tDaten;

procedure write(signal Mem: inout tMem;

adr: tAdr; x: tDaten);


8. FIR-Filter 4. Zahlendarstellung durch Bitvektoren

Koezienten: Betrag kleiner eins. Ein Vorkommsbit

(Vorzeichen) und 15 Nachkommabit. Wertebereich:

W B(Koeff) = ( −1, +1 − 2 −15)

Daten: Betrag kleiner 1000. 11 Vorkomma und 5

Nachkommabit. Wertebereich (−1024, +1023).

Produkte aus Daten und Koezienten: 12 Vorkomma- und

20 Nachkommabits. Abschneiden von 15 Nachkommabits. Zu

Übertragsvermeidung Akkumulation mit 13 Vorkommabits:

subtype tAkku is tSigned(17 downto 0);

Geeigneten Multiplikationsfunktion:

function mult(a, b: tDaten) return tAkku is

constant prod: tSigned(2 * tDaten'length - 1

downto 0) := a * b;

begin

return prod(prod'high) & prod(prod'high

downto tDaten'high);

end function;

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 97/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 98/114

8. FIR-Filter 4. Zahlendarstellung durch Bitvektoren

Für die Datendarstellung wird der Wert der Daten durch 2 5

dividiert und mit sieben Zeichen und einer Nachkommastelle

dargestellt:

function str_dat(x: tSigned) return string is

begin

if is_x(x) then return " XX";

else return rechts(str(real(int(x))/(2.0**5), 1),7);

end if;

end function;

Die ganzzahlige Werterepräsentation der Koezienten wird durch

2 15 geteilt und mit vier Nachkommastellen dargestellt:

function str_coeff(c: tSigned) return string is

begin

if is_x(c) then return " XX";

else return

rechts(str(real(int(c))/(2.0**15), 4),7);

end if;

end function;


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 99/114

8. FIR-Filter 4. Zahlendarstellung durch Bitvektoren

Einarbeitung der geänderten Typen und Unterprogramme in die

bisherige Beschreibung. Die Simulation soll idealerweise bis auf

Rundungsfehler wieder dieselbe tabellarische Ausgabe liefern.

Eingabe:|cAdr|xAdr|| cDat | xDat || Prod | Akku || r(0) r(1) r(2) r(3) |Ausgabe:

100.0| 1| 3|| XX | XX || XX | XX || XX XX XX XX |

200.0| 2| 2|| XX | XX || XX | XX || XX XX XX 100.0|

300.0| 3| 1|| XX | XX || XX | XX || XX XX 200.0 100.0|

400.0| 0| 0|| XX | XX || XX | XX || XX 300.0 200.0 100.0|

| 1| 1|| 0.2000| 400.0|| XX | XX || 400.0 300.0 200.0 100.0|

| 2| 2|| 0.5000| 300.0|| 80.0| XX || 400.0 300.0 200.0 100.0|

| 3| 3|| -0.5000| 200.0|| 150.0| 80.0|| 400.0 300.0 200.0 100.0|

600.0| 0| 3|| -0.2000| 100.0|| -100.0| 230.0|| 400.0 300.0 200.0 100.0|

| 1| 0|| 0.2000| 600.0|| -20.0| 130.0|| 400.0 300.0 200.0 600.0|

| 2| 1|| 0.5000| 400.0|| 120.0| 110.0|| 400.0 300.0 200.0 600.0| 110.0

| 3| 2|| -0.5000| 300.0|| 200.0| 120.0|| 400.0 300.0 200.0 600.0|

-600.0| 0| 2|| -0.2000| 200.0|| -150.0| 320.0|| 400.0 300.0 200.0 600.0|

| 1| 3|| 0.2000| -600.0|| -40.0| 170.0|| 400.0 300.0 -600.0 600.0|

| 2| 0|| 0.5000| 600.0|| -120.0| 130.0|| 400.0 300.0 -600.0 600.0| 130.0

Die Simulation nach diesem Entwurfsschritt soll

insbesondere Zeigen, ob mit der festgelgten Bitanzahl genau

genug gerechnet wird.


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 100/114

8. FIR-Filter 5. Ein- und Ausgabe über Signale

Ein- und Ausgabe über Signale


of. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 101/114

8. FIR-Filter 5. Ein- und Ausgabe über Signale

In der nächsten Version des Simulationsmodells wird der

Testrahmen deshalb in drei über Signale kommunizierende

Prozesse geteilt:

einen Prozess für die Bereitstellung der Eingabesignale,

einen Prozess zur Modellierung des Testobjekts und

einen Ausgabeprozess, der möglichst dieselben Textausgaben

wie die bisherigen Simulationsmodelle erzeugen soll

Testquelle

daten-

RD

x

I

T

x

pp Pipeline-Zustand

Testobjekt

I

FIR RD

WR

pp

xRAM

pp

T

I

x Test-

ausgabe-

RD prozess T

WR

pp.cAdr

a)

RD

00

01 10 11 00 01 10 11 00 01 10

x w 0 w 1 w 2 w 3 w 4

w 5

x Dateneingabesignal; y Datenausgabesignal; T Takt; I

Initialisierungseingang; RD Bestätigungssignal für Leseoperationen,

aktiv bei Datenübernahme; W R Bestätigungssignal für

Schreiboperationen, aktiv bei Datenausgabe.

· · ·

b)


8. FIR-Filter 5. Ein- und Ausgabe über Signale

Testeingabeprozess als nebenläuge Prozedur:

procedure Testdatenquelle(Dateiname: string;

signal RD: std_logic;

signal T, I: out std_logic;

signal x: out tDaten;

tp: delay_length := 10 ns) is

RD Testdatenquelle

variable pstr: tPString; variable ZNr: natural;

variable r: real;

le f: textio.text open read_mode is Dateiname;

begin

I


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 103/114

8. FIR-Filter 5. Ein- und Ausgabe über Signale

- Funktion innerhalb einer Taktperiode

if RD='1' then

if textio.endfile(f) then wait; end if;

read(f, pstr); get(pstr, r, -1000.0, 1000.0);

if pstr.Status/=ok then

write("Zeile " & str(znr) & ":" & str(pstr.err_msg)); wait

else x


8. FIR-Filter 5. Ein- und Ausgabe über Signale

Testausgabeprozess als nebenläuge Prozedur:

procedure Testausgabe(

x

signal T, RD, WR: std_logic;

RD

signal pp: tPipeline; signal x: tDat; WR

signal xRAM: tMem) is

variable s: tString;

pp

T

begin

write(" Zeit |Eingabe|Z| ... r(3)|Ausgabe"); (1)

loop

- Endlosschleife

wait until rising_edge(T); - warte auf Takt

assign(s, rechts(str(now, 1),8));

- Anhängen eines Zeilentextes, der

- den Zustand der Schaltung beschreibt

write(s);

end loop;

end procedure;

- Textzeile ausgeben

Testausgabeprozess

⇒WEB-Projekt: P5.2/FIR2_pack.vhdl

Nach diesem Entwurfsschritt können die exakten Zeitabläufe

kontrolliert werden. Der Testrahmen ist fertig und auch für

die Simulation der synthesefähigen Beschreibung nutzbar.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 104/114


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 105/114

8. FIR-Filter 6. Beschreibung als Automat

Beschreibung als Automat


type tZustand is XX, Init, Startzyklus, Normalzyklus;

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 106/114

8. FIR-Filter 6. Beschreibung als Automat

Synthesefähige Automatenbescheibung

a) Ablaufbeschreibung b) synthesefäfhige Beschreibung

Init: for ... loop

. . .

Endlosschleife

des Prozesses

wait for tP;

end loop;

if I=’1’ then

Startzyklus: for ... loop

. . .

Anfangswertzuweisungen;

wait for tP;

elsif aktive Taktflanke then

end loop;

Berechnungsschritte mit Fallunterscheidungen

nach Schleife

loop

Normalzyklus: for ... loop

und Schleifenzählerwert

. . .

end if;

wait for tP;

wait on T, I;

end loop;

end loop;

Warteliste

Drei nacheinander abzuarbeitende Schleifen. Drei Zustände +

ungültig:


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 107/114

8. FIR-Filter 6. Beschreibung als Automat

Erweiterung der Pipeline-Zustands um den Automatenzustand:

- erweiterter Datentyp für den Pipeline-Zustand

type tPipeline is record

cAdr, xAdr: tAdr;

cDat, xDat: tDaten;

Prod, Akku: tAkku; (1)

Zustand: tZustand;

end record;

⇒WEB-Projekt: P5.2/FIR2_pack.vhdl

Die Übergangsfunktion als Prozedur, die bei jeder aktiven

Taktanke aufgerufen wird:


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 108/114

8. FIR-Filter 6. Beschreibung als Automat

- Übergangsfunktion des gesamten FIR-Filters

procedure PipeStep(x: tDat; cROM: tMem;

signal xRAM: inout tMem;

signal pp: inout tPipeline) is

begin

case pp.Zustand is

when XX => null;

when Init =>

pp.cAdr


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 109/114

8. FIR-Filter 6. Beschreibung als Automat

In allen anderen Fällen, d.h. im Zustand Startzyklus oder

Normalzyklus sind die Fallunterscheidungen aus dem

bisherigen Entwurf zu übernehmen:

Schritt 0: Datenwert schreiben statt lesen (FU1),

- Operationen im Start- und Nomalzyklus

pp.cAdr


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 110/114

8. FIR-Filter 6. Beschreibung als Automat

Schritt 2: Produkt in den Akkumulator kopieren statt zum

Akkumulatorinhalt zu addieren und Ergebnis ausgeben

(FU2) und

letzter Schritt: Datenadresse nicht weiterzählen (FU3).

Im Startzyklus entfällt die Ergebnisausgabe. Statt dessen wird

der Zustand weitergeschaltet:

- Fallunterscheidung FU2

if pp.cAdr="10" then

pp.Akku


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 111/114

8. FIR-Filter 6. Beschreibung als Automat

Die drei Ausgabesignale:

Lesebestätigungssignal

Schreibbestätigungssignal

Akkumulatorzustand.

ergeben sich aus dem Pipeline-Zustand und sollen durch

getrennte Funktionen berechnet werden:

function RdGnt(pp: tPipeline) return std_logic is

begin

if pp.Zustand=Init or pp.cAdr=to_tUnsigned(0, tAdr'length)

then return '1';

else return '0';

end if;

⇒WEB-Projekt: P5.2/FIR2_pack.vhdl

end function;


to_tKoe(...) konvertiert Kommawerte in Bitvektoren.

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 112/114

8. FIR-Filter 6. Beschreibung als Automat

Das Signal für die Schreibbestätigung ist nur im Normalzyklus,

wenn die Koezientenadresse den Wert zwei hat, zu aktivieren:

function WrGnt(pp: tPipeline) return std_logic is

begin

if pp.Zustand=Normalzyklus and pp.cAdr=to_tUnsigned(2, tAdr'len

then return '1';

else return '0';

end if;

⇒WEB-Projekt: P5.2/FIR2_pack.vhdl

end function;

Konstanten und Signale für den Testrahmen:

constant cROM: tMem := (to_tKoeff( 0.2), to_tKoeff( 0.5),

to_tKoeff(-0.5), to_tKoeff(-0.2));

signal xRAM: tMem(0 to M-1);

signal pp: tPipeline;

signal T, I, rd, wr: std_logic;

⇒WEB-Projekt: P5.2/Test_FIR2.vhdl

signal x: tDat;


Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 113/114

8. FIR-Filter 6. Beschreibung als Automat

Das Verhaltensmodell der kompletten Übergangsfunktion als

Abtastprozess mit asynchroner Initialisierung:

process(T, I)

begin

if I='1' then

pp.cAdr


Zeit |Eingabe|Z|cAdr|xAdr|| cDat | xDat || Prod | Akku || r(0) r(1) r(2) r(3)|Ausgabe

10.0 ns| XX|I| 1| 3|| XX| XX|| XX| XX|| XX XX XX XX|

20.0 ns| 100.0|I| 1| 3|| XX| XX|| XX| XX|| XX XX XX XX|

30.0 ns| 200.0|I| 2| 2|| 0.5000| XX|| XX| XX|| XX XX XX 100.0|

40.0 ns| 300.0|I| 3| 1||-0.5000| XX|| XX| XX|| XX XX 200.0 100.0|

50.0 ns| 400.0|S| 0| 0||-0.2000| XX|| XX| XX|| XX 300.0 200.0 100.0|

60.0 ns| |S| 1| 1|| 0.2000| 400.0|| XX| XX|| 400.0 300.0 200.0 100.0|

70.0 ns| |S| 2| 2|| 0.5000| 300.0|| 80.0| XX|| 400.0 300.0 200.0 100.0|

80.0 ns| |S| 3| 3||-0.5000| 200.0|| 150.0| 80.0|| 400.0 300.0 200.0 100.0|

90.0 ns| 600.0|N| 0| 3||-0.2000| 100.0|| -100.0| 230.0|| 400.0 300.0 200.0 100.0|

100.0 ns| |N| 1| 0|| 0.2000| 600.0|| -20.0| 130.0|| 400.0 300.0 200.0 600.0|

110.0 ns| |N| 2| 1|| 0.5000| 400.0|| 120.0| 110.0|| 400.0 300.0 200.0 600.0| 110.0

120.0 ns| |N| 3| 2||-0.5000| 300.0|| 200.0| 120.0|| 400.0 300.0 200.0 600.0|

Die noch fehlenden Schritte bis zu einer synthesefähigen

Schaltung beinhalten:

Beseitigung aller Abfragen und Zuweisungen mit dem

Pseudo-Wert ungültig,

den entsprechenden Ersatz bzw. die Vereinfachung der

Read-Funktion und der Write-Prozedur und

eine Kapselung der Testobjektbeschreibung in eine

eigenständige Entwurfseinheit mit Schnittstellenbeschreibung

Prof. G. Kemnitz · Institut für Informatik, Technische Universität Clausthal 9. Juli 2013 114/114

8. FIR-Filter 6. Beschreibung als Automat

Simulationsausgabe

Weitere Magazine dieses Users
Ähnliche Magazine