VHDL-Synthese: Entwurf digitaler Schaltungen und Systeme [7th updated edition] 9783110375060

Citation preview

Jürgen Reichardt, Bernd Schwarz VHDL-Synthese De Gruyter Studium

Weitere empfehlenswerte Titel Lehrbuch Digitaltechnik, 3. Auflage Jürgen Reichardt, 2013 ISBN 978-3-486-72765-4, e-ISBN 978-3-486-75387-5

Prozessorentwurf, 2. Auflage Dieter Wecker, 2015 ISBN 978-3-11-040296-4, e-ISBN 978-3-11-040305-3, e-ISBN (EPUB) 978-3-11-040309-1

SIP und Telekommunikationsnetze, 5. Auflage Ulrich Trick, Frank Weber, 2015 ISBN 978-3-486-77853-3, e-ISBN 978-3-486-85922-5, e-ISBN (EPUB) 978-3-11-039911-0

Entwurf von digitalen Schaltungen und Systemen mit HDLs und FPGAs, 3. Auflage Frank Kesel, Ruben Bartholomä, 2013 ISBN 978-3-486-73181-1, e-ISBN 978-3-486-74715-7

Analoge Schaltungstechniken der Elektronik Wilfried Tenten, 2012 ISBN 978-3-486-70682-6, e-ISBN 978-3-486-85418-3

Modellierung von digitalen Systemen mit SystemC Frank Kesel, 2012 ISBN 978-3-486-70581-2, e-ISBN 978-3-486-71895-9

Jürgen Reichardt, Bernd Schwarz

VHDL-Synthese

Entwurf digitaler Schaltungen und Systeme 7., aktualisierte Auflage

Autoren Prof. Dr. rer. nat Jürgen Reichardt Hochschule für Angewandte Wissenschaften Hamburg Fakultät Technik und Informatik Department Informations- und Elektrotechnik Digitale Informationstechnik Berliner Tor 7 20099 Hamburg [email protected] Prof. Dr.-Ing. Bernd Schwarz Hochschule für Angewandte Wissenschaften Hamburg Fakultät Technik und Informatik Department Informatik Technische Informatik Berliner Tor 7 20099 Hamburg [email protected]

ISBN 978-3-11-037505-3 e-ISBN (PDF) 978-3-11-037506-6 e-ISBN (EPUB) 978-3-11-039784-0 Library of Congress Cataloging-in-Publication Data A CIP catalog record for this book has been applied for at the Library of Congress. Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.dnb.de abrufbar. © 2015 Walter de Gruyter GmbH, Berlin/Boston Coverabbildung: Autoren Druck und Bindung: CPI books GmbH, Leck ♾ Gedruckt auf säurefreiem Papier Printed in Germany www.degruyter.com

Vorwort Das vorliegende Buch entstand in seiner ersten Auflage vor nunmehr mehr als 15 Jahren aus einer Neubewertung der Lehrinhalte der Fächer „Digitaltechnik“ und „Entwurf Digitaler Systeme“ an den Departments Informations- und Elektrotechnik sowie Informatik der HAW-Hamburg. Diese hatte zum Ergebnis, die Hardwarebeschreibungssprache VHDL ((Very High Speed Integrated Circuit) Hardware Description Language) nicht als eigenständige Lehrveranstaltung sondern parallel zur Digitaltechnik zu vermitteln, um darauf aufbauend in den weiteren Lehrveranstaltungen Systementwürfe gestalten zu können. Ein besonderes Ziel dieser Lehrveranstaltungen ist es, den bekannten Beschreibungsformen für Elemente der Digitaltechnik einen Hochsprachenentwurf gegenüberzustellen. Der starke Hardwarebezug der genannten Lehrveranstaltungen setzt dabei voraus, dass überwiegend synthesefähige VHDL-Beschreibungen entwickelt werden. Besonderen Wert legen wir daher auf die Kombination aus Hardwarebeschreibung, Funktionsprüfung durch Simulation und Analyse der Syntheseergebnisse. Den synthesefähigen Hardwarebeschreibungen der ausgewählten Funktionselemente werden, soweit erforderlich, die digitaltechnischen bzw. bei den komplexeren Anwendungen der Kap. 9 und 10 auch die Grundlagen der systemtheoretischen Entwurfsprinzipien zur Seite gestellt. Das Lehrbuch soll als Zielgruppe zunächst die Studierenden der Elektrotechnik und der Informatik an Hochschulen und Universitäten erreichen. Es ist gerade mit seinen Erweiterungen zur Modellierung komplexerer Systeme in den Kapiteln 8, 9 und 10 aber ebenso auf Entwicklungsingenieure1 in der Praxis ausgerichtet, die erstmalig einen VHDL-basierten Digitalentwurf beabsichtigen. Der Verkaufserfolg sowie die sehr positiven Rückmeldungen der Leser zu den bisherigen Auflagen der „VHDL-Synthese“ gab uns mit diesem Ansatz Recht und war uns Ansporn für eine kontinuierliche Weiterentwicklung der Inhalte bis zur nun vorliegenden 7. Auflage. So wurden bereits in den letzten Auflagen unterschiedliche Systeme ergänzt bzw. überarbeitet, in denen die in den Kap. 1 bis 7 erlernten Grundlagen an konkreten Aufgabenstellungen vertieft werden. Diese reichen in der nun vorliegenden 7. Auflage vom Entwurf eines einfachen RISC-Prozessors in Kap. 8 über die Implementierung digitaler Filter in Kap. 9 bis hin zur Implementierung von Zustandsdifferenzengleichungen für Beobachter in Kap. 10, die für digitale Regelungen z.B. in der elektrischen Antriebstechnik zum Einsatz kommen. _________________ 1

Wir bitten die Leserinnen um Verständnis, dass wir im Folgenden die männlichen Berufsbezeichnungen verwenden. Wir haben uns wegen der Kürze und der unseres Erachtens besseren Lesbarkeit für diese Formulierungen entschieden.

VI

Vorwort

Für diese 7. Auflage sind die VHDL-Simulationsergebnisse aller Modellierungsbeispiele mit dem Simulationscompiler ModelSim PE [59] zum IEEE-Standard 1076-2008 syntaktisch überprüft und aktualisiert dargestellt worden. Zur Aktualisierung wurden auch die Schaltpläne der Syntheseergebnisse nun durchgängig direkt aus dem Implementierungswerkzeug Xilinx ISE 14.7 entnommen oder nach dessen Angaben graphisch aufbereitet. Die Dokumentation der Implementierungsergebnisse mit Post-Place&Route Timingsimulationen für FPGA-Zielhardware ist ebenso mit dem Werkzeug ISE 14.7 überarbeitet worden. Wir danken unseren Studenten, die durch vielfältige Diplom-, Bachelor- und MasterArbeiten über viele Jahre hinweg wertvolle Beiträge zur systematischen Weiterentwicklung dieses Lehrbuches beigetragen haben. Weiterer Dank gilt den Lektoren des de Gruyter Verlages, die uns mit Rat und Tat bei der Erstellung des Buches geholfen haben.

Hamburg, März 2015

J. Reichardt, B. Schwarz

Inhaltsverzeichnis 1 

Einleitung und Übersicht

1 

1.1 

Motivation ................................................................................................................ 1 

1.2 

Ziele und Organisation dieses Buches ...................................................................... 2 

1.3 

VHDL Entwurfsmethodik ........................................................................................ 6 

1.4 

Syntaxnotation .......................................................................................................... 9 

2 

Synthese einfacher Schaltnetze

2.1  2.1.1 2.1.2 2.1.3

Entity, Architektur und Signale .............................................................................. 11  Deklaration und Verwendung lokaler Signale ........................................................ 14 Richtungsmodi von Signalschnittstellen ................................................................. 15 Deklaration von Bussignalen .................................................................................. 17

2.2

Simulation von VHDL-Entwürfen.......................................................................... 17

2.3

Schaltnetze mit Boole'schen Gleichungen .............................................................. 20

2.4

Synthese selektiver und bedingter Signalzuweisungen........................................... 23

2.5

Übungsaufgaben ..................................................................................................... 28

3 

Entwurf digitaler Funktionselemente mit Prozessen

3.1 3.1.1

Prozesse .................................................................................................................. 31 Deklaration und Ausführung von Prozessen........................................................... 32

3.2 3.2.1 3.2.2 3.2.3

Schaltnetze mit sequentiellen Anweisungen ........................................................... 35 Die case-Anweisung ............................................................................................... 36 Die if-Anweisung ................................................................................................... 40 Schleifenkonstrukte ................................................................................................ 44 3.2.3.1 for loop .................................................................................................. 45 3.2.3.2 while loop .............................................................................................. 46

3.3 3.3.1

Einfache Schaltwerke ............................................................................................. 48 D-Flipflops und Register ........................................................................................ 48 3.3.1.1 VHDL-Beschreibung mit Signalen ....................................................... 49 3.3.1.2 Testbench zum D-Flipflop ..................................................................... 51 3.3.1.3 Entwurf von Registern........................................................................... 52 3.3.1.4 Verwendung von Variablen in taktsynchronen Prozessen..................... 53

11 

31 

VIII

Inhaltsverzeichnis

3.3.2 3.3.3

Johnson-Zähler mit Taktteiler ................................................................................. 55 Parametrisiertes Schieberegister ............................................................................. 57

3.4

Erzeugung von Latches........................................................................................... 60

3.5 3.5.1 3.5.2

Vermeidbare Synthesefehler ................................................................................... 63 Kombinatorische Schleifen ..................................................................................... 63 Fehlverhalten durch unvollständige Empfindlichkeitslisten ................................... 64

3.6 3.6.1 3.6.2

RTL-Syntheserichtlinien......................................................................................... 66 D-Flipflops und Register in getakteten Prozessen .................................................. 67 D-Latches und kombinatorische Logik ................................................................... 68

3.7

VHDL-Testbenches ................................................................................................ 68

3.8

Übungsaufgaben ..................................................................................................... 74

4 

Tri-State- und Don’t-Care-Modellierung

4.1

Die Datentypen std_ulogic und std_logic ............................................................... 79

4.2

Realisierung von Tri-State-Ausgangsstufen ........................................................... 82

4.3

Don’t-Care-Werte als Ausgangssignal ................................................................... 87

4.4

Don’t-Care-Werte als Eingangssignal .................................................................... 89

4.5

Konversion der Datentypen bit und bit_vector ....................................................... 92

4.6

Übungsaufgaben ..................................................................................................... 94

5 

Arithmetik und Synchronzähler

5.1

Arithmetik-Operatoren und zugehörige Datentypen............................................... 97

5.2

Komparator SN74xx85 ......................................................................................... 100

5.3

Entwurf von Synchronzählern .............................................................................. 102

5.4

Arithmetik mit den Datentypen signed und unsigned ........................................... 106

5.5

Integer-Arithmetik ................................................................................................ 111

5.6

Konversionsfunktionen und indizierter Zugriff auf Feldelemente ........................ 113

5.7

Arithmetik mit Synopys Bibliotheken .................................................................. 116

5.8

Hinweise zur Verwendung der Datentypen .......................................................... 117

5.9

Übungsaufgaben ................................................................................................... 119

6 

Entwurf von Zustandsautomaten

6.1

Automatenvarianten.............................................................................................. 123

6.2

Moore-Automat für eine Impulsfolgenerkennung ................................................ 126

6.3

Entwurfsbeispiel für einen Mealy-Automaten ...................................................... 130

79 

97 

123 

Inhaltsverzeichnis 6.4 6.4.1 6.4.2

IX

6.4.3 6.4.4

VHDL-Syntaxvarianten ........................................................................................ 136 Die Zwei-Prozess-Darstellung .............................................................................. 137 Die Mehr-Prozess-Darstellung ............................................................................. 139 6.4.2.1 Schnittstellensynchronisation .............................................................. 139 6.4.2.2 Maßnahmen zur Taktfrequenzerhöhung .............................................. 141 6.4.2.3 Maßnahme zur Reduzierung der Latenzzeit ........................................ 143 Die Ein-Prozess-Darstellung ................................................................................ 145 Vergleich der Syntaxvarianten.............................................................................. 146

6.5 6.5.1 6.5.2 6.5.3

Zustandscodierung ................................................................................................ 147 Strategien der Zustandscodierung ......................................................................... 147 Umsetzung der Zustandscodierung in VHDL....................................................... 148 Auswirkungen der Zustandscodierung auf die Syntheseergebnisse ..................... 149

6.6

Übungsaufgaben ................................................................................................... 156

7 

Struktureller VHDL-Entwurf

7.1

Ziele und Methoden der Systempartitionierung.................................................... 160

7.2 7.2.1

7.2.2 7.2.3

Struktureller Entwurf mit Komponenten .............................................................. 163 Struktureller Entwurf eines 4 zu 2 Prioritätsencoders .......................................... 164 7.2.1.1 Komponentendeklaration .................................................................... 167 7.2.1.2 Komponenteninstanziierung und port map-Anweisung ...................... 167 7.2.1.3 Konfiguration zur Auswahl von Modellarchitekturen ......................... 169 7.2.1.4 Modellparametrisierung ...................................................................... 169 7.2.1.5 Iterative Instanziierung ........................................................................ 171 Entwurf einer skalierbaren Addier/Subtrahier-Einheit ......................................... 174 Kopplung von Signalen in strukturellen VHDL-Beschreibungen ........................ 179

7.3 7.3.1 7.3.2

Strukturierung mit Unterprogrammen .................................................................. 182 Lokale Prozeduren und Funktionen ...................................................................... 182 Definition und Einsatz von packages.................................................................... 187

7.4 7.4.1 7.4.2

Herstellerspezifische Komponenten und Komponentengeneratoren .................... 190 Instanziierung von RAM- und ROM-Zellen mit Prozessen ................................. 190 Komponentengeneratoren ..................................................................................... 196

7.5

Unterstützung durch Synthesewerkzeuge ............................................................. 202

7.6

Übungsaufgaben ................................................................................................... 204

8 

Entwurf eines RISC-Prozessors

8.1 8.1.1 8.1.2 8.1.3

Spezifikation der Prozessorfunktionen ................................................................. 208 Das Programmiermodell ....................................................................................... 208 Der Instruktionssatz .............................................................................................. 210 Instruktionsformate ............................................................................................... 210

8.2

Prozessorarchitektur und -programmierung ......................................................... 211

159 

207 

Inhaltsverzeichnis

X 8.3 8.3.1 8.3.2 8.3.3 8.3.4 8.3.5 8.3.6 8.3.7 8.3.8

VHDL-Realisierung.............................................................................................. 214 Registerfile............................................................................................................ 215 Instruktions- und Datenspeicher ........................................................................... 218 Instruction Fetch (IF) ............................................................................................ 221 Instruction Decode (ID) ........................................................................................ 222 Execute (EX) ........................................................................................................ 225 Memory Access (MEM) ....................................................................................... 227 Top-Level-Architektur des RISC-Prozessors ....................................................... 230 Einfache Testbench für den RISC-Prozessor ........................................................ 233

8.4 8.4.1 8.4.2 8.4.3

Entwurfsverifikation ............................................................................................. 234 Vermeidung von RW-Hazards.............................................................................. 236 Vermeidung von C-Hazards ................................................................................. 237 Speichern und Lesen des Datenspeichers ............................................................. 239

8.5

FPGA-Implementierung ....................................................................................... 240

9 

Modellierung digitaler Filter

9.1 9.1.1 9.1.2

FIR-Filter .............................................................................................................. 245 Parallele FIR-Filterstrukturen ............................................................................... 245 Zahlendarstellung im Q-Format............................................................................ 250 9.1.2.1 Addition mit vorzeichenrichtiger Erweiterung der Summanden ......... 252 9.1.2.2 Binäre Multiplikation .......................................................................... 253 Filterskalierung und Beispielfilter ........................................................................ 254 VHDL-Modelle paralleler FIR-Filterstrukturen ................................................... 258 9.1.4.1 Kopplung von unterschiedlichen Taktbereichen ................................. 258 9.1.4.2 Basismodell der Direktform ................................................................ 261 9.1.4.3 Direktform mit symmetrisch balanciertem Addiererbaum .................. 269 9.1.4.4 Direktform mit unsymmetrisch balanciertem Addiererbaum .............. 273 9.1.4.5 Linear-Phasen-Struktur........................................................................ 283 9.1.4.6 Transponierte Form mit reduzierter Anzahl der Multiplizierer ........... 293 9.1.4.7 Systolische FIR Filter .......................................................................... 298 9.1.4.8 Vergleich der Implementierungsergebnisse und Timinganalysen ....... 302 Sequentielle FIR-Struktur mit MAC-Einheit ........................................................ 304 9.1.5.1 Multiplizierer-Akkumulatoreinheit ..................................................... 307 9.1.5.2 Ringpuffer für die Abtastwerte ............................................................ 309 9.1.5.3 Koeffizienten-ROM............................................................................. 311 9.1.5.4 Sequenzsteuerung mit einem Zustandsautomaten ............................... 312 9.1.5.5 Simulations- und Syntheseergebnisse ................................................. 316 Taktschemata der Filterdatenpfade ....................................................................... 320 9.1.6.1 Audiodatenrate .................................................................................... 321 9.1.6.2 Hohe Datenraten .................................................................................. 322

9.1.3 9.1.4

9.1.5

9.1.6

9.2 9.2.1 9.2.2

243 

IIR-Filter ............................................................................................................... 323 Koeffizientenberechnung und Beispielfilter ......................................................... 323 Parallele Strukturen für IIR-Filter 2. Ordnung...................................................... 328

Inhaltsverzeichnis 9.2.3

XI

9.2.4 9.2.5

VHDL-Modelle für Varianten der Direktform II .................................................. 331 9.2.3.1 Transponierte Struktur der Direktform II ............................................ 331 9.2.3.2 Modifizierte Direktform II .................................................................. 339 9.2.3.3 Implementierungsergebnisse und Timinganalyse................................ 342 Sinusgenerator als synthesefähige Testbench ....................................................... 343 Entwurfsschritte für IIR-Filter .............................................................................. 350

9.3

FPGA-Entwurf mit Simulink ................................................................................ 351

10 

Zustandsdifferenzengleichungen für Beobachter

355 

10.1 Zeitinvariante und lineare Systeme....................................................................... 358 10.1.1 Zeitliche Diskretisierung ...................................................................................... 359 10.1.2 VHDL-Modell für die Zustandsdifferenzengleichungen ...................................... 363 10.2 10.2.1 10.2.2 10.2.3

Numerische Integration von gekoppelten Differentialgleichungen ...................... 370 Rechteck- und Trapezintegration .......................................................................... 371 VHDL-Modell der kombinierten numerischen Integration .................................. 376 Prozessorelement mit Mehrzyklus-Datenpfad ...................................................... 383 10.2.3.1  Algorithmisches Zustandsdiagramm ................................................... 385  10.2.3.2 Datenpfad mit Mehrfach-Ressourcennutzung ..................................... 387 10.2.3.3 VHDL-Modellierung des Prozessorelementes .................................... 391

10.3

Vergleich der Implementierungsergebnisse .......................................................... 400

10.4 Nichtlineare, gekoppelte Integralgleichungen ...................................................... 406 10.4.1 Odometrie mit einem Einspur-Fahrzeugmodell .................................................... 407 10.4.2 VHDL-Modell des nichtlinearen Doppelintegrators............................................. 410 11 

Anhang

425 

11.1

VHDL-Codierungsempfehlungen ......................................................................... 425

11.2

Checkliste zum VHDL-basierten Entwurf digitaler Systeme ............................... 429

11.3

Liste der VHDL-Schlüsselworte ........................................................................... 433

11.4 11.4.1  11.4.2 11.4.3 11.4.4 11.4.5 11.4.6

Lösungen zu den Übungsaufgaben ....................................................................... 433 Lösungen zu den Aufgaben in Kap. 2.5 ................................................................ 434  Lösungen zu den Aufgaben in Kap. 3.7 ................................................................ 436 Lösungen zu den Aufgaben in Kap. 4.6 ................................................................ 442 Lösungen zu den Aufgaben in Kap. 5.7 ................................................................ 445 Lösungen zu den Aufgaben in Kap. 6.6 ................................................................ 450 Lösungen zu den Aufgaben in Kap. 7.7 ................................................................ 455

12 

VHDL-Syntaxübersicht und Bibliotheken

461 

13 

Literaturverzeichnis

471 

14 

Sachregister

477 

1

Einleitung und Übersicht

1.1

Motivation

Die Entwicklung von mikroelektronischen Schaltungen auf hohem Abstraktionsniveau wird durch die beiden nachfolgenden Trends bestimmt: − Starker Anstieg der Entwurfskomplexität − bei drastisch reduzierten Entwicklungszeiten (Time to market). Zugleich entwickelt sich der Markt für mikroelektronische Produkte von Computeranwendungen immer weiter hin zu Kommunikations- und Consumer-Anwendungen. Exemplarisch sollen hier nur das rasante Wachstum des Mobilfunkmarktes sowie die neuartigen Applikationen, die sich aus dem Zusammenwachsen der Computer und digitaler Fernsehsysteme im Zusammenhang mit der Internet-Entwicklung ergeben, genannt werden. In der Industrie reichen herkömmliche Wege über grafische Schaltplaneingaben auf Logikelementebene schon seit längerem nicht mehr aus, um in den kurzen Entwicklungszyklen wettbewerbsfähig zu bleiben. Ein Lösungsansatz beim Schaltungsentwurf ist die Hardwarebeschreibung durch Hochsprachen, der durch eine zunehmende Zahl von CAEWerkzeugen zur Schaltungssimulation und -synthese unterstützt wird. Ein besonderer Vorteil dieses Konzepts ist die gemeinsame Nutzung einer einheitlichen Modellierung für Simulation und Synthese. Dabei dient die Simulation der Verifikation der Entwurfsidee und die Synthesewerkzeuge setzen die Hardwarebeschreibung automatisch in Schaltpläne und Logikgatter-Netzlisten um. Letztere werden für die herstellerspezifische Implementierung der Schaltung auf Hardwareplattformen wie ASICs (Application Specific Integrated Circuits), FPGAs und CPLDs benötigt. Zusammen mit dem Einsatz der CAE-Werkzeuge führt die Hardwareentwicklung auf Basis von Hochsprachen dazu, dass die Vielfalt der implementierungsspezifischen Entwurfsdetails stark reduziert wird. Der Entwickler kann sich so mehr dem Systementwurf widmen und wird in die Lage versetzt, in kürzerer Zeit komplexere Schaltungen zu entwerfen. Die Realisierung digitaler Systeme mit FPGAs, die mehrere Millionen Logikzellen1 bieten [55], erfordert eine Beschreibung auf Basis komplexer Komponenten, wie z.B. ALUs (Arithmetic Logic Units), Steuerwerken und On-Chip RAM/ROM-Speicher.

_________________ 1

Logikzelle: Kombination aus einer Look-Up-Tabelle mit vier oder sechs Eingängen und einem Daten-Flipflop

1 Einleitung und Übersicht

2

Durch Nutzung von Top-Down bzw. Bottom-Up Entwurfsstilen sowie durch Einsatz wiederverwendbarer Komponenten lässt sich eine im Vergleich zum Schaltplanentwurf höhere Abstraktionsebene des Systementwurfs erreichen [16], [42]. Als Modellierungssprachen für den beschriebenen Entwurfsstil haben sich weltweit die beiden Sprachen Verilog und VHDL etabliert, die den Markt in der Vergangenheit etwa zu gleichen Teilen dominierten [56]. Verilog war überwiegend im amerikanischen Markt vertreten, hat sich jedoch in Europa gegenüber VHDL weniger durchsetzen können. Seit Mitte der 90er Jahre ist auch in den USA ein erheblicher Anstieg der VHDL-Nutzung zu beobachten [57]. Seit wenigen Jahren werden insbesondere für Anwendungen, bei denen es auf eine gemeinsame Hardware-Software-Modellierung ankommt, Programmiersprachen wie C, C++ oder auch SystemC [68] zur Simulation bzw. Synthese digitaler Hardware eingesetzt, für die es seit kurzem auch Synthesewerkzeuge für FPGA-Zieltechnologien gibt [69]. Aus den oben genannten Gründen und aufgrund der IEEE-Standardisierung sowie der daraus resultierenden Portierbarkeit der Entwicklungsergebnisse zwischen unterschiedlichen CAE-Umgebungen bzw. Bausteinen wurde die Sprache VHDL für die Lehre und das vorliegende Buch ausgewählt. Die in allen Hardwarebeschreibungssprachen verwendeten Konzepte sind jedoch recht ähnlich, womit das Erlernen einer weiteren Sprache nach Studium dieses Buches recht leicht fallen sollte. Einen Vergleich findet der Leser z.B. in [2]. VHDL wurde erstmalig 1987 und nachfolgend in den Jahren 1993, 2002 und 2008 durch die IEEE-Norm 1076 standardisiert [32]. Der synthesefähige Syntaxanteil von VHDL, der nur eine Teilmenge des gesamten Sprachumfangs darstellt, wurde zuerst 1999 durch die Norm 1076.6 standardisiert. Die in heutigen Synthesewerkzeugen implementierten Möglichkeiten basieren meist auf dem überarbeiteten Synthesestandard aus dem Jahr 2004 [20]. Aus diesem Grund wurde im vorliegenden Buch besonderer Wert darauf gelegt, nur eine sicher synthesefähige Untermenge zur Hardwarebeschreibung einzusetzen. Als Erprobungsgrundlage dienten zunächst überwiegend die PC-basierten Werkzeuge Aurora der Fa. Viewlogic [10], FPGA-Express der Fa. Synopsys [5]. Seit mehreren Jahren wird dafür der FPGA Synthese Compiler XST verwendet [81], der in den Entwurfsprogrammen der Fa. Xilinx [81] zum Einsatz kommt.

1.2

Ziele und Organisation dieses Buches

Die besondere Aufgabe, die wir uns mit diesem Buch gestellt haben, besteht darin, die digitaltechnischen Entwurfselemente mit den VHDL-Modellierungselementen zusammenzuführen. Dabei werden folgende immer wiederkehrende Entwurfsschritte bearbeitet: − Digitaltechnische Problembeschreibung − Hardwarebeschreibung mit VHDL − Verifikation des VHDL-Codes durch Simulation − Analyse des Syntheseergebnisses.

1.2 Ziele und Organisation dieses Buches

3

Schrittweise erfolgt eine Steigerung der zu vermittelnden Syntaxkomplexität. Dies geschieht parallel zum wachsenden Funktionsumfang der modellierten Komponenten. So wird die Hardware-Modellierung mit VHDL aus Sicht der Digitaltechnik von einfachen kombinatorischen Logikfunktionen, Flipflops, gesteuerten Zählern und Zustandsautomaten bis zu komplexen Systemen wie einem RISC-Prozessor bzw. verschiedenen Implementierungsvarianten digitaler Filter dargestellt. Aufgrund der Vielzahl möglicher VHDL-Beschreibungen für eine Problemstellung haben wir es angestrebt, jeweils wiederverwendbare und erweiterbare VHDL-Module vorzustellen. Dazu gehört auch, dass die Syntheseergebnisse überwiegend als technologieunabhängige Schaltpläne sorgfältig aufbereitet und erläutert werden. Für den Leser soll sich dadurch als Lernziel ein geschulter Blick ergeben, mit dem er die plausible Übereinstimmung der synthetisierten Flipflops, Latches und Schaltnetze mit seiner Entwurfsvorstellung prüfen kann. Das vorliegende Buch soll kein vollständiges VHDL-Syntaxlexikon darstellen, stattdessen wird ein synthesefähiger VHDL-Syntaxvorrat aus Sicht der digitaltechnischen Zielvorstellungen erlernt. Nicht synthesefähige Syntax wird als solche ausdrücklich erläutert und nur im Zusammenhang mit rein simulationstechnischen Aspekten genutzt. Dazu gehören zum einen die Formulierung von Stimuligeneratoren in VHDL-Testumgebungen und zum anderen die Modelle für nicht VHDL-basierte Schaltungsmakros. Die FPGA-Hersteller liefern diese optimierten Hardwaremakros, die bei der Synthese in die Netzlisten eingebunden werden können, in der Regel zusammen mit VHDL-Modellen, die das Verhalten dieser Schaltungsfunktionen nachbilden. Dabei reicht die Komplexität der Makros von einfachen RAM- und ROM-Speichern über spezielle mathematische Operationen bis hin zu IPBlöcken (IP = Intellectual Property), die z.B. Bus-Interfaces oder parametrisierbare Filterstrukturen darstellen. Die Simulation einer Hardwarebeschreibung ist im Lernprozess sowie in der praktischen Entwicklungstätigkeit ein entscheidender Schritt zur Verifikation eines Entwurfes. Zum Nachvollziehen der Beispielentwürfe des Buches sowie zur Überprüfung der eigenen Lösungen zu den Übungsaufgaben wird dringend empfohlen, einen VHDL-Simulator bzw. ein Synthesewerkzeug einzusetzen. Die einzelnen Kapitel dieses Lehrbuches lassen sich grob gefasst drei HardwareSyntheseschwerpunkten zuordnen: − Logik-Synthese, − Schaltwerk-Synthese, − Struktur-Synthese hierarchischer Systeme. Die in der Literatur dafür benutzten Beschreibungsformen sind mit folgenden Begriffen klassifizierbar [13], [15], [42], [43]: • Verhaltensbeschreibung: Modellierung des Ein-/Ausgangsverhaltens von digitaltechnischen Komponenten. Prinzipiell ist zu unterscheiden, ob die Modelle synthesefähig sind (Datenflussdarstellung), oder ob sie nur für die Simulation geeignet sind (algorithmische Darstellung). • Strukturbeschreibung: Mit hierarchischen Strukturmodellen werden die Signalkopplungen zwischen den Komponenten beschrieben.

4

1 Einleitung und Übersicht

Im vorliegenden Lehrbuch bilden Hardwarebeschreibungen mit der Datenflussdarstellung den Kern der Ausführungen. Diese Hardware-Verhaltensbeschreibung wird in den IEEEStandards als Darstellung auf der Register Transfer Ebene (RTL = Register Transfer Level) präzisiert [42], [43]. Darin werden die Schaltungen mit ihren Registern und der dazwischen liegenden kombinatorischen Logik beschrieben. Der VHDL-IEEE-Synthesestandard [20] wurde für RTL-Beschreibungen entwickelt. Das Buch ist neben dieser Einführung in 9 weitere Kapitel und einen Anhang gegliedert, dabei werden die drei oben genannten Themenbereiche wie folgt behandelt: In den Kapiteln 2 bis 4 sollen mit elementaren VHDL-Konstrukten digitale Grundkomponenten realisiert werden. Darauf aufbauend erfolgt in zwei weiteren Kapiteln eine Darstellung des Entwurfs komplexerer Komponenten, wie z.B. von Komparatoren, Zählern und Automaten. Nach einer Vorstellung der Strukturierungsmethoden digitaler Systeme mit VHDL werden die bisher erlernten Konzepte an zwei völlig unterschiedlichen Beispielen umgesetzt: Einem einfachen RISC-Prozessor sowie Implementierungsvarianten digitaler Filter. Der erste Themenbereich beginnt im Kapitel 2 mit der Vorstellung der wesentlichen syntaktischen Grundstrukturen eines VHDL-Codes zur Beschreibung einfacher Schaltnetze mit Entwurfseinheiten (Entities) und Architekturen. Dazu gehören auch Signale und deren nebenläufige Wertzuweisung. Schon in diesem einführenden Kapitel wird der Leser auf Möglichkeiten hingewiesen, den eigenen Entwurf mittels geeigneter VHDL-Testumgebungen zu simulieren. Zur Erweiterung der allein mit nebenläufigen Anweisungen stark eingeschränkten Modellierungsmöglichkeiten wird in Kapitel 3 die Beschreibung von Schaltnetzen und Schaltwerkelementen mit Prozessen und den zugehörigen sequentiellen Anweisungen erläutert. Diese erlauben zunächst Verzweigungen, die entweder Multiplexer oder Prioritätsencoder generieren. Schleifenkonstrukte können entweder der Erzeugung einer endlichen Anzahl regelmäßiger Hardwareelemente oder aber der Abarbeitung getakteter Vorgänge dienen. Dazu werden Paritätsgeneratoren vorgestellt, bei denen auch auf den Unterschied zwischen VHDL-Signalen und -Variablen eingegangen wird. Als Beispiele einfacher Schaltwerke werden D-Flipflops und Register sowie ein Zähler mit Schaltwerktabelle und ein parametrisiertes Schieberegister entworfen. Die speziellen Möglichkeiten, die der Einsatz von Prozessen in Testumgebungen liefert, werden ebenfalls in diesem Kapitel aufgezeigt. In Kapitel 4 werden mehrwertige Datentypen eingeführt, mit denen sich über die einfache 0-1-Darstellung digitaler Signale hinaus, unter anderem hochohmige Buszustände (TriState-Treiber) sowie Don’t-Care-Einträge in Wahrheitstabellen umsetzen lassen. Der zweite Themenbereich, der die Modellierung komplexerer Komponenten vorstellt, beginnt in Kapitel 5 mit der Einführung arithmetischer Operatoren, die für die mehrwertigen Datentypen definiert sind. Darauf aufbauend wird der Entwurf von Komparatoren, Addierern und Subtrahierern erläutert. Auch einfache Schaltwerke wie gesteuerte Zähler werden hier behandelt. Ergänzend wird in diesem Kapitel der Integer-Datentyp eingeführt, mit dem sich besonders vorteilhaft indizierte Feldzugriffe, wie sie z.B. bei der Speicheradressierung erforderlich sind, beschreiben lassen. Die Umsetzung der aus der Digitaltechnik bekannten Automatenstrukturen behandelt Kapitel 6. Dabei wird am Beispiel eines Automaten zur seriellen Sequenzerkennung auf geeignete Abbildungsvarianten der Automatenkomponenten auf VHDL-Prozesse und die Dar-

1.2 Ziele und Organisation dieses Buches

5

stellung der Zustandscodierung eingegangen. Die Realisierung von Signalsynchronisationen und des Komponentenpipelinings zur Taktfrequenzerhöhung in Systemen mit gekoppelten Automaten wird ebenfalls vorgestellt. Im dritten Schwerpunkt werden in Kapitel 7 die wesentlichen Schritte zum VHDL-Entwurf digitaler Systeme vorgestellt. Dazu gehört neben der Vorstellung einer Entwurfsmethodik die Abbildung auf Strukturmodelle, die durch gekoppelte Komponenten und Netzlisten repräsentiert werden. Als weitere Strukturierungsmittel werden in diesem Kapitel Unterprogramme erläutert. Als Ausblick wird die Einbindung herstellerspezifischer, parametrisierbarer Schaltungsmakros in den VHDL-Code diskutiert. In den Kapiteln 8 und 9 werden zwei Beispiele für digitale Systeme mit unterschiedlichem Schwerpunkt vorgestellt: Während beim schrittweisen Entwurf eines RISC-Prozessors mit vierstufiger Pipeline im Kapitel 8 die Methodik des Systementwurfs im Vordergrund steht, wird im Kapitel 9 besonderer Wert auf die Simulations- und Synthesesemantik von Entwurfsvarianten digitaler FIR- und IIR-Filter gelegt. Dabei erfolgt eine vergleichende Bewertung des Implementierungsaufwands dieser Strukturen. Das Kapitel 10 behandelt die Modellierung von gekoppelten Zustandsdifferenzengleichungen, wie sie in Beobachtersystemen der Regelungstechnik genutzt werden. Die Grundlagen digitaler Integrationsverfahren für lineare und nichtlineare Systembeschreibungen sowie die Architektursynthese von Einzyklus-, Mehrzyklus- und von Pipeline-Modellen sind Gegenstand dieses weiterführenden Kapitels. Insbesondere diese drei Kapitel gehen über die üblicherweise in der Digitaltechnik gelehrten Lehrinhalte hinaus und richten sich an Studierende höherer Semester. Am Ende der Kapitel 2 bis 7 ist jeweils eine Reihe von Übungsaufgaben zur Entwicklung digitaler Grundkomponenten zusammengestellt. Der Anhang enthält neben einer Musterlösung zu den Übungsaufgaben auch komprimierte Hinweise mit Codierungsempfehlungen, die einen synthesegerechten VHDL-Entwurf ermöglichen, eine Checkliste zur Systematik des Entwurfs digitaler Systeme unter Verwendung von VHDL sowie eine Liste der VHDL-Schlüsselworte. Dateien mit Quellcodes für Beispiellösungen sowie weitere Informationen zu diesem Buch finden Sie unter dem URL: http://users.etech.haw-hamburg.de/users/reichardt/ und auf den Internetseiten des Verlags (www.degruyter.com => VHDL-Synthese => Materialien).

1 Einleitung und Übersicht

6

1.3

VHDL Entwurfsmethodik

Den Entwurfsablauf eines entweder konventionell mit einem Schaltplaneditor oder aber mit VHDL modellierten digitalen Systems zeigt Bild 1-1.

Bild 1-1: Entwurfsmethodik für Digitalschaltungen

1.3 VHDL Entwurfsmethodik

7

Die einzelnen Schritte des Entwurfsprozesses werden nachfolgend an Hand des FPGAEntwicklungssystems ISE der Fa. Xilinx [22] beschrieben: •

Die Eingabe des digitalen Systems erfolgt mit einem Texteditor als VHDL-Modell. Alternativ sind andere Eingabemöglichkeiten z.B. durch einen Schaltplaneditor ebenfalls möglich.

•

In einer oder mehreren funktionalen Simulationen wird überprüft, ob das Modell die funktionalen Spezifikationen des Systems erfüllt (Validierung). Dies erfolgt auf Basis verschiedener Simulationstests, die als Testvektoren bezeichnet werden. In den Testvektoren erhalten alle Eingangssignale einen bestimmten Wert (Stimuli) und die Testergebnisse (Response) werden mit den zu erwartenden Weten verglichen. Die Testvektoren werden in einer sogenannten Testbench zusammengefasst, die ebenfalls als VHDL-Code formuliert werden kann (vgl. Kap. 3.7).

•

Nach erfolgreicher Validierung erfolgt die Synthese. Dabei wird das für die Validierung verwendete VHDL-Modell (ohne die Testbench) vom Synthesewerkzeug der Entwicklungsumgebung analysiert und in eine zunächst noch weitgehend technologieunabhängige Netzliste von Komponenten der Digitaltechnik (kombinatorische Logikkomponenten, Flipflops etc.) überführt. Komplexere, häufig vorkommende Komponenten wie z.B. Addierer werden in geeignete Macroblöcke transformiert. Die Analyse des Syntheseergebnisses ist im Entwicklungsablauf ein außerordentlich wichtiger Schritt, weil es bei einer nicht synthesegerechten Modellierung des VHDL-Codes zu einem Fehlverhalten der Schaltung kommen kann. Als Hilfsmittel zur Kontrolle stehen zur Verfügung:

•

o

Der während der Synthese erstellte Synthesereport.

o

Ein Schaltplan, der während der Synthese automatisch erstellt wurde. Realistischerweise können jedoch nur kleinere Schaltungsteile an Hand des Schaltplans überprüft werden.

o

Eine erneute Simulation der Funktionalität unter Verwendung der gleichen Testbench, wie sie für die funktionalen Simulation verwendet wurde. Zu diesem Zweck erstellt die Entwicklungsumgebung automatisch ein neues VHDL-Modell, welches die Komponenten verwendet, die während der Synthese identifiziert wurden. Diese Verifikation wird als Postsynthesis Simulation bezeichnet.

Für den nächsten Entwicklungsschritt müssen die sogenannten „Constraints“ angeben werden. Dazu gehören insbesondere die genaue Bausteinbezeichnung, die Anschlussbelegung sowie die Taktrate(n), mit denen das System betrieben werden soll. Auf der Grundlage der während der Synthese erstellten Netzliste und der Constraints werden sukzessive die folgenden Schritte abgearbeitet, die bei FPGAs zusammen genommen als „Physical Design“ bezeichnet werden. Alternativ wird dafür auch der Begriff „Backend Design“ verwendet. o

Translate: Während dieser Entwurfsphase werden die während der Synthese erstellten Netzlisten verschiedener Entwurfsblöcke zu einer Netzliste des gesamten Systems zusammengefügt.

o

Map: Dies bedeutet die automatisierte Abbildung der Logik auf die in der Zielhardware befindlichen Ressourcen. Bei FPGAs gehört dazu z.B. die Abbildung der

1 Einleitung und Übersicht

8

Boole’schen Gleichungen auf Look-Up-Tabellen (vgl. Kap. 2.3) oder die Auswahl geeigneter Flipflops. Während dieser Phase erfolgt auch eine Vereinfachung der Logikfunktionen. Der Anwender kann entscheiden, ob diese Optimierung entweder innerhalb einer einzelnen Komponente oder aber über die Komponentengrenzen hinweg durchgeführt werden soll. o

Place and Route: Bei der Platzierung wird festgelegt, wo sich z.B. die Look-UpTabellen oder Flipflops innerhalb des Bausteines befinden. Nachfolgend wird die Verdrahtung definiert. Dabei legt das Implementierungswerkzeug fest, mit welchen Verdrahtungsressourcen die Logikblöcke verbunden werden.

o

Am Ende des physikalischen Entwurfs erfolgt eine statische Timing-Analyse. Dies bedeutet die systematische Suche nach dem kritischen Pfad des Systems, also der längsten Laufzeit kombinatorischer Logik zwischen zwei getakteten Speicherelementen. Dieser legt bekanntlich die maximale Taktfrequenz fest, mit der das System betrieben werden kann.

In der Regel lassen sich von der Implementierungsoftware nicht alle Constraints mit der initialen Platzierung und Verdrahtung erreichen. Aus diesem Grunde müssen die Schritte des physikalischen Entwurfs iterativ solange ausgeführt werden, bis alle Anschluß- und Zeitvorgaben erreicht werden. Falls dies nicht möglich sein sollte, muss entweder das Entwurfskonzept verändert werden, oder aber die Constaints geändert werden. •

Zur Kontrolle des physikalischen Entwurfsprozesses sollte eine erneute Verikation durch Simulation auf Basis der ursprünglichen VHDL-Testbench durchgeführt werden. Alle Layoutinformationen werden unter Berücksichtigung der zu erwartenden Gatterund Leitungsverzögerungen in einem automatisch erstellten VHDL-Modell zusammengefasst. Die Postlayout VHDL-Timingsimulation beschreibt damit das worstcase Schaltungsverhalten mit allen Verzögerungen, die in der Hardware tatsächlich zu erwarten sind. Dabei ist darauf zu achten, dass die während der statischen TimingAnalyse erhaltenen maximalen Taktfrequenzen bei der Definition der Taktsignale in der Testbench nicht überschritten werden.

•

Abschließend erstellt das Entwicklungssystem die Programmierdatei und nach der Programmierung des Bausteins kann eine Analyse des Hardwareverhaltens erfolgen. Auch dieser Schritt wird vom Entwicklungssystem unterstützt: Nach Hinzufügen spezieller Hardwareblöcke zum Entwurf können ausgewählte Signale innerhalb des FPGAs in einem internen Speicher abgelegt und nachfolgend wie in einem Logikanalysator ausgewertet werden (Chipscope [112]).

Dieses Buch behandelt schwerpunktmäßig die Erstellung von VHDL-Code mit dem speziellen Ziel, das Verhalten der funktionalen Simulation auch im Hardwareverhalten wieder zu finden. Die in dieser Auflage vorgestellten VHDL-Codeanalysen basieren auf dem aktuell gültigen Standard VHDL-2008 [113]. Wegen der zunehmenden Verbreitung von FPGAs beim Entwurf digitaler Systeme beschränken wir uns in den Beispielen vornehmlich auf den FPGA-Entwurf, wobei wir für die meisten Implementierungsbeispiele exemplarisch den Spartan-3 Baustein xc3s400-5 pq208 ausgewählt haben. Sollten in einigen Beispielen andere FPGA-Typen verwendet worden sein, so wird im Text explizit darauf hingewiesen.

1.4 Syntaxnotation

1.4

9

Syntaxnotation

Anhand zweier exemplarischer VHDL-Syntaxbeschreibungen soll kurz auf die in diesem Buch verwendete Bezeichnungsweise eingegangen werden: entity is [generic();] port(); [< Entitydeklarationen >;] end ; architecture of is [< Architekturdeklarationen >;] begin {;} end ;

• Grundsätzlich wird VHDL-Code bzw. die VHDL-Syntaxbeschreibung auch im Fließtext als Courier Font dargestellt. • VHDL-Schlüsselworte bzw. -Trennzeichen sind fett gedruckt. • Elemente in spitzen Klammern stellen Bezeichner oder andere, untergeordnete Elemente der Syntaxbeschreibung dar (z.B. ). • Die in eckigen Klammern angegebenen Syntaxelemente sind optional und werden in den einführenden Beispielen weggelassen (z.B. [generic( );] ) • In geschweiften Klammern { } angegebene Syntaxkonstrukte können beliebig oft wiederholt werden. • Elemente einer Liste alternativer Möglichkeiten von Syntaxkonstrukten werden durch den Vertikalstrich | getrennt. Während die ersten fünf Notationselemente im oben angegebenen Beispiel wieder zu finden sind, stellt die nachfolgende Syntaxbeschreibung ein Beispiel für das letzte Element dar: for | others | all: use entity .();

Eine vollständige Syntaxübersicht findet der Leser im Kap. 12, in dem eine Zusammenstellung der Fa. Qualis [58] reproduziert ist. Unter dem URL: http://users.etech.hawhamburg.de/users/schubert/vorles.html lässt sich eine deutschsprachige VHDL-Syntaxbeschreibung im PDF-Format über das Internet herunter laden.

2

Synthese einfacher Schaltnetze

In diesem Kapitel werden die grundlegenden VHDL-Konzepte erläutert. Ausgehend von vollständigen Beispielen wird der VHDL-Sprachschatz schrittweise, problemorientiert erweitert. Dabei werden zunächst die Begriffe entity und architecture erklärt, die die Schnittstellen einer Logikeinheit bzw. deren Funktion beschreiben. Es werden Signale definiert, denen ein digitaler Wert mit nebenläufigen Anweisungen zugewiesen wird. Am Ende des Kapitels wird erläutert, wie die VHDL-Entwürfe mittels geeigneter Testumgebungen simuliert werden können. Nach dem Durcharbeiten soll der Leser in der Lage sein, synthesefähige VHDL-Beschreibungen für einfache kombinatorische Schaltungen auf Gatterebene entwerfen zu können. Dazu gehört zunächst nur die korrekte Verwendung der Datentypen bit und bit_vector sowie der problemorientierte Umgang mit den port-Modi in, out und buffer. Die syntaktischen und semantischen Unterschiede der bedingten und selektiven Signalzuweisungen sollen verstanden sein. Die Funktion des inout port-Modus wird später im Kapitel 4 erläutert, da zugehörige praktische Anwendungen den Datentyp std_logic_vector erfordern, der erst in diesem Kapitel eingeführt wird.

2.1

Entity, Architektur und Signale

Die in der nachfolgenden Liste aufgeführten VHDL-Elemente sind als grundlegende Strukturelemente jeder VHDL-Beschreibung anzusehen: • In der mit entity bezeichneten Entwurfseinheit werden die Schnittstellen eines VHDL-Funktionsblocks nach außen beschrieben. In einem Vergleich eines Board-Designs mit einem VHDL-Quellcode stellt eine entity den zu bestückenden IC-Gehäusetyp dar, der durch die Anzahl und die Bezeichnung der Anschlüsse eindeutig definiert ist. Die Deklaration der Anschlüsse innerhalb der entity erfolgt mit Hilfe einer port-Anweisung. • Die architecture beschreibt das Innenleben, d.h. die Funktionalität des VHDLCodes. Jeder entity muss (mindestens) eine architecture zugeordnet sein. In obiger Vorstellung beschreibt also die Architektur, welche Funktion bzw. welcher Chip sich in dem Gehäuse befindet. • Ein port-Signal beschreibt die Kommunikation einer entity nach außen. In unserem Modell werden port-Signale verwendet, um verschiedene integrierte Schaltkreise

2 Synthese einfacher Schaltnetze

12

(ICs) auf einem Board (Platine) miteinander zu verknüpfen. Innerhalb einer Architektur werden lokale Signale erforderlich, wenn verschiedene Funktionsblöcke innerhalb eines ICs miteinander verbunden werden sollen. Signale können also auf unterschiedlichen Hierarchieebenen definiert werden. Jedes Signal ist von einem eindeutig zu definierenden Typ. Zur Einführung soll hier zunächst nur der Datentyp bit bzw. bit_vector benutzt werden. Der Wertevorrat des Datentyps bit besteht aus den logischen Werten '0' und '1'. Ein bit_vector stellt einen aus mehreren bit-Signalen bestehenden Bus dar. Dieser Bus kann entweder aufsteigend, z.B. als bit_vector(0 to 7), oder aber abfallend als bit_vector (7 downto 0) bezeichnet werden. Alle Signale müssen einen eindeutigen Namen besitzen, der entweder in der entity oder in der weiter unten erläuterten Signaldeklarationsanweisung (Abschnitt 2.1.1) festgelegt wird. Die Schnittstellen der entity werden als port bezeichnet. Dessen Signalrichtung ist bei der Deklaration anzugeben. Die Syntax eines entity/architecture-Paars besteht aus den beiden Rahmen: entity is [generic();] port(); [< Entitydeklarationen >;] end ; architecture of is [< Architekturdeklarationen >;] begin {;} end ;

Als erstes Beispiel zeigt Code 2-1 die vollständige VHDL-Beschreibung eines Multiplexers mit vier Dateneingängen nach Bild 2-1. -- mux4x1.vhd -- Selektive Signalzuweisung --------------------------entity MUX4X1 is port( S: in bit_vector(1 downto 0); E: in bit_vector(3 downto 0); Y: out bit); end MUX4X1;

architecture VERHALTEN of MUX4X1 is begin with S select -- Auswahlsignal Y EN_CNT_C, CNT_C_MAX => CNT_C_MAX, COEF => COEF_I); RAM: RAM_S_65_16 generic map( WIDTH => WIDTH ) port map ( RESET => RESET, CLK => CLK, EN => EN_CNT_S, WE => WE_R_S, DIN => XN(19 downto 4), SAMP => SAMP_I); MAC: MAC_FIR generic map( WIDTH => WIDTH ) port map ( CLK => CLK, CLR_REG => CLR_REG, EN_REG => EN_REG, EN_SAT => EN_SAT, COEF => COEF_I, SAMP => SAMP_I, YN => YN ); Z_REG: process(CLK) -- Zustandsaktualisierung begin if (CLK = '1' and CLK'event) then if (RESET = '1') then ZUSTAND RD_S=>RD library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity ODE_TB is generic(PERIODE48MHZHALBE: time:= 10.41666667 ns; -- 1/2fclk SAMPLES: positive := 700); -- 700*1/fa=1.458 ms end entity ODE_TB; architecture ODE_SOL of ODE_TB is component ODE_SP is -- Dgl.-System 2. Ordnung --generic -- nur für VHDL-Simulation ...

380

10 Zustandsdifferenzengleichungen für Beobachter

port ( CLK, RESET, RD: in std_logic; -- 48 MHz Systemtakt DONE: out std_logic; -- Ergebnis verfügbar U: in std_logic_vector(11 downto 0); -- Eingangssignal < 1 Y1, Y2: out std_logic_vector(11 downto 0)); -- Y, dY/dt end component; signal signal signal signal signal begin CLOCK: begin

CLK, CLR: std_logic; X: std_logic_vector(11 downto 0); -s.Q11 Y1: std_logic_vector(11 downto 0); -- sg.Q10 Y2: std_logic_vector(15 downto 0); --s15g TEMP_1, TEMP_2, READY, RD_S: std_logic ; process -- 48 MHz Clock-Periode

CLK right/left,field => ); -- Lage des Elements in der Zeile write(L,time'(now),justified=>r/l, field => , unit => us); writeline(output,L); -- Key-Word Output: Konsolen-Ausgabe writeline(,L); -- Kopie einer Zeile in eine Datei

Die Type-Qualifier dienen hier der Syntaxerklärung und sind für den Code nicht erforderlich. Diese Funktionen arbeiten mit einer Variablen, sodass sie nur in einem Prozess nutzbar sind. Das Schlüsselwort now repräsentiert die aktuelle Zeit, zu der der jeweilige Prozess durch ein Signal in der Empfindlichkeitsliste getriggert oder mit einer wait for Anweisung angehalten wurde.

10.4 Nichtlineare, gekoppelte Integralgleichungen

421

Dateien können in jedem Deklarationsabschnitt auch von Prozessen, Funktionen und Prozeduren deklariert werden: architecture I_O of TESTBENCH is -- file O_FILE: text; begin TB: process() variable LINE_BUF: line; -- output line file O_FILE: text; begin file_open(O_FILE,"TEST.txt", append_mode); -write(LINE_BUF,string'(" Result available")); writeline(O_FILE,LINE_BUF); file_close(O_FILE); end process TB; end I_O;

write_mode

Gemäß einem konsistenten Codierstil sollte jeweils ein Paar von file open und file close gewählt werden. Mit dem append mode zeigt der Zeilen-Pointer auf die nächste freie Zeile, wenn der Prozess erneut getriggert wird. -- Testbench erzeugt Takt-, Freigabesignale und Stimuli für Modelleingänge library IEEE; use ieee.std_logic_1164.ALL; use ieee.std_logic_unsigned.all; -- Integer-Arithmetik für Loop use ieee.numeric_std.all; -- Typ-Konvertierung zu Integer use ieee.std_logic_textio.ALL; -- Datei-Schreib- u. Lesevorgänge use std.textio.ALL; entity FZ_MODELL_TB IS end FZ_MODELL_TB; architecture STIMULI OF FZ_MODELL_TB is component FZ_MODELL port( CLK, RESET, RD_S : in std_logic; VM : in std_logic_vector(13 downto 0); -- Fz-Geschwindigkeit ALPHA : in std_logic_vector(7 downto 0); -- Lenkwinkel 0 rechts THETA : out std_logic_vector(7 downto 0); -- Achswinkel XM : out std_logic_vector(11 downto 0); -- Vorderradkoordinate DONE : out std_logic); end component; -- file remains opened until simulation is terminated by -- Simulate -> End Simulation file theta_file : TEXT open write_mode is "theta_log.dat"; file xm_file : TEXT open write_mode is "xm_log.dat"; signal signal signal signal signal

CLK, RESET : std_logic; VM : std_logic_vector(13 downto 0); ALPHA, THETA : std_logic_vector(7 downto 0); XM : std_logic_vector(11 downto 0); READY, RD_S, TEMP_1, TEMP_2, DONE: std_logic;

constant PERIODE_HALBE : time := 12.5 us; -- Tclk=25 μs => fclk=40 kHz -- T = 20 ms; T/Tclk = 40*20 = 800; f=1/T = 50 Hz; -- READY-Dauer = 10 Tclk

422

10 Zustandsdifferenzengleichungen für Beobachter

begin UUT: FZ_MODELL port map ( CLK => CLK, RESET => RESET, RD_S => RD_S, VM => VM, ALPHA => ALPHA,THETA => THETA, XM => XM, DONE => DONE); TAKT: process begin CLK (C_OUT,S) (C_OUT,S) (C_OUT,S) (C_OUT,S)