Tutorial als PDF - CES

Einführung in Werkzeuge zum Entwurf digitaler
Schaltungen
24. November 2008

Inhaltsverzeichnis
1 Einführung 3
1.1 Das XILINX-Werkzeug . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1 Schaltplan . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.2 Simulation . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.3 Synthese . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 FPGA-Entwurfsumgebung . . . . . . . . . . . . . . . . . . . . 4
1.3 Entwurfsablauf . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Entwurfsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Betriebssystemumgebung . . . . . . . . . . . . . . . . . . . . 7
2 Strukturbeschreibung 9
2.1 Neues Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Schaltplan erstellen . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3 Symbole erstellen . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4 Symbole einfügen . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5 Verdrahten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3 Verhaltensbeschreibung 23
4 Synthese 26
5 Simulation 27
5.1 Erstellen der Testbench . . . . . . . . . . . . . . . . . . . . . 27
5.2 Verhaltenssimulation . . . . . . . . . . . . . . . . . . . . . . . 29
5.3 Post-Route Simulation . . . . . . . . . . . . . . . . . . . . . . 30
6 Praxistest 32
6.1 Symbol TUTORIAL . . . . . . . . . . . . . . . . . . . . . . . 33
6.2 Schaltplan ENVIRONMENT . . . . . . . . . . . . . . . . . . 33
6.3 Symbole USB INTERFACE und LED INTERFACE . . . . . 34
6.4 Platzieren und Verdrahten . . . . . . . . . . . . . . . . . . . . 35
6.5 Randbedingungen und FPGA-Konfiguration . . . . . . . . . . 35
6.6 Generieren des Programming Files . . . . . . . . . . . . . . . 36
6.7 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1

7 Anhang 40
7.1 VHDL-Code für GGT . . . . . . . . . . . . . . . . . . . . . . 40
7.2 VHDL-Code für COMPARATOR . . . . . . . . . . . . . . . . 42
7.3 VHDL-Code für LED INTERFACE . . . . . . . . . . . . . . 43
7.4 VHDL-Code für USB INTERFACE . . . . . . . . . . . . . . 44
7.5 Pinzuordnung . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2

Kapitel 1
Einführung
Ziel dieses Praktikums ist es, einen Einblick in den Entwurf hoch integrierter
Schaltungen (VLSI = Very Large Scale Integration) zu gewinnen. Im Rahmen
des Praktikums werden dazu Schaltungen entworfen, getestet und synthetisiert.
Der Schwerpunkt des Hardwareentwurfes liegt auf der so genannten High-
Level-Synthese. Darunter versteht man das (weitgehend) automatische Erzeugen
der Gatterbeschreibung ausgehend von einer algorithmischen Verhaltensbeschreibung.
Den hardwarenäheren Teil dieser Aufgabe - die sogenannte Low-Level-Synthese
- überlassen wir automatischen Verfahren, die von den verwendeten Entwurfswerkzeugen
angeboten werden. Sie erzeugen die vollständige Layoutbeschreibung der zu
entwickelnden Schaltung. Diese Beschreibung kann direkt zur Fertigung der
Schaltung verwendet werden. Da aber für die vollkundenspezifische Fertigung
von Schaltungen sehr komplexe und teure Technologieprozesse benötigt werden,
ist die Erstellung eines solchen Chips im Rahmen des Praktikums leider
nicht möglich. Auch in der Industrie werden oft für das Prototyping der
zu entwerfenden Schaltungen FPGA-Bausteine (Field Programmable Gate
Array) eingesetzt. Die FPGA-Technologie ermöglicht eine sehr schnelle und
billige Fertigung einer Schaltung und wird heute nicht nur für Prototyping
verwendet. In diesem Praktikum werden bei der Schaltungsimplementierung
die FPGA-Bausteine und die entsprechenden Entwurfswerkzeuge der Firma
Xilinx benutzt. Neben dem Entwurf der Hardware wird später auch noch
der Entwurf von Software Gegenstand des Praktikums sein.
1.1 Das XILINX-Werkzeug
Sämtliche Schaltungen dieses Praktikums werden im Projektmanager von
XILINX ISE (Integrated Synthesis Environment) erstellt. ISE stellt eine
komplette Entwicklungsumgebung zur Verfügung.
3

1.1.1 Schaltplan
Für den grafischen Entwurf wird der Schematic Editor von Xilinx benutzt.
Dieser Editor erlaubt es hierachisch strukturierte, vernetzte Schaltungen zu
entwerfen und daraus VHDL-Beschreibungen zu generieren.
1.1.2 Simulation
Zur Simulation von VHDL und anderen Beschreibungssparchen wird der
ISE-Simulator verwendet. Zusätzlich zur Verhaltens- oder Sturkturbeschreibung
können Dateien im ”Standard-Delay-Format” hinzugezogen werden, die Informationen
über die Verzögerungszeiten der Gatter beinhalten.
1.1.3 Synthese
Eine der Hauptaufgaben des Xilinx ISE ist die Erzeugung einer FPGA-
Implementierung aus einer VHDL-Beschreibung. Die Transformation besteht
aus mehreren Schritten, die innerhalb des Xilinx-Werkzeuges ausgeführt
werden:
Analyse Syntaktische und semantische Analyse des VHDL-Quelltextes.
Synthese Übersetzung der (algorithmischen) Verhaltensbeschreibung auf
Register-Transfer-Ebene.
Abbildung (Mapping) Auflösen der Schaltungshierarchie und Aufteilung
der Schaltungslogik auf spezifische Komponenten des FPGA-Bausteins
(CLB, IOB, etc.).
Platzierung (Place and Route) Platzieren der durch das Abbilden bestimmten
Komponenten auf bestimmte Positionen auf dem Chip (Placement)
und Verdrahtung der FPGA-Komponenten wie gefordert (Routing).
Post-Synthese-Simulation Erzeugung einer VHDL-Gatterebenenbeschreibung
mit Verzögerungszeiten, um eine zeitbehaftete Simulation
zu ermöglichen.
Konfiguration Erzeugen einer FPGA-Konfiguration, mit der ein
Xilinx FPGA geladen, d.h. konfiguriert werden kann.
1.2 FPGA-Entwurfsumgebung
Für das Praktikum Entwurf eingebetter Systeme wird die FPGA-Lösung
X2SUSB der Firma Cesys verwendet. Dabei handelt es sich um eine Platine,
die mit einem Xilinx Spartan II FPGA bestückt ist. Zur Kommunikation mit
dem Rechner steht eine USB 1.1 Schnittstelle zur Verfügung. Es gibt zur
Erzeugung von Taktsignalen einen Taktgenerator und zur Kommunikation
4

mit dem FPGA selbst einen Erweiterungs-Stecker mit 96 Pins, die direkt an
den FPGA angeschlossen sind. Für dieses Tutorial wird an den Erweiterungsstecker
eine sogenannte Indikatorplatine gesteckt, die mittels LEDs angelegte Werte
anzeigt. Im Anhang dieser Tutorials findet sich das Datenblatt der Platine.
1.3 Entwurfsablauf
Die Funktion der einzelnen Werkzeuge soll anhand des Entwurfs eines einfachen
Beispiels erläutert werden. Das Beispiel ist dabei so gewählt, dass möglichst
alle im Praktikum benötigten Funktionen angesprochen werden.
Abbildung 1.1 zeigt den allgemeinen Entwurfsablauf: Ausgangspunkt eines
Schaltungsentwurfes ist eine verbal formulierte Aufgabe. Der erste Entwurfsschritt
besteht in der Entwicklung der Struktur der zu erzeugenden Schaltung. Die
zur Lösung der Entwurfsaufgabe benötigten Module müssen in die Schaltung
eingefügt und miteinander verbunden werden. Danach sind die verwendeten
Module durch ihre jeweilige Verhaltensbeschreibung zu definieren.
Anschließend kann für die hierarchische Schaltungsbeschreibung durch Simulation
überprüft werden, ob das Verhalten der entworfenen Struktur der gegebenen
Aufgabe entspricht (ISE-Simulator). Ist dies nicht der Fall, müssen entweder
die Verhaltensbeschreibungen einzelner Module oder aber die gesamte Struktur
verändert werden.
Im folgenden zweiten Schritt wird aus der Verhaltens- und Strukturbeschreibung
mit Hilfe des Synthesewerkzeuges zunächst eine Gatterbeschreibung und
dann eine FPGA-Konfiguration generiert. Hierbei wird die Hierarchie des
Entwurfs aufgelöst, die Schaltung auf eine Chipfläche verteilt und dann
verdrahtet. Das erzeugte Layout dient als Grundlage für den Herstellungsprozess
des Chips.
Bevor dieser jedoch gefertigt wird, kann mit einer Post-Synthese-Simulation
(erneut wird der ISE Simulator verwendet) das Verhalten der Schaltung
getestet werden. In diesem Simulationsschritt wird die Schaltung auf dem
hardwarenächsten Niveau getestet und alle Randbedingungen, die zum Synthesezeitpunkt
bekannt sind, fließen in die Simulation mit ein. So kann überprüft werden, ob
die Schaltung immer noch die gestellte Aufgabe löst. Gegebenenfalls müssen
Schaltungselemente neu platziert oder die Verdrahtung geändert werden. Die
letzte Stufe des Entwurfs bilden die Fertigung und das Testen des Prototyps.
1.4 Entwurfsbeispiel
Es soll eine synchrone Schaltung entworfen werden, die den größten gemeinsamen
Teiler zweier positiver 8-bit-Zahlen IN1 und IN2 berechnet und das Ergebnis
mit einer vorgegebenen Zahl COMP vergleicht.
Nach jedem Reset (RESET ’1’-aktiv) soll das Signal RES OK logisch 0 sein.
Die Berechnung soll beginnen, sobald das Signal RESET logisch 0 wird, und
5

jederzeit asynchron abgebrochen werden können, sobald RESET logisch 1
wird.
Sobald das Ergebnis feststeht, soll das Signal RES OK logisch 1 werden und
das Endergebnis am Ausgang RESULT anliegen, bis ein Reset auftritt. Ist der
Wert von RESULT identisch mit COMP, so soll das Signal EQUAL logisch 1 sein,
falls sich die Werte von RESULT und COMP unterscheiden soll EQUAL logisch 0
sein.
Die Schaltung wird in zwei Module GGT und COMPARATOR aufgeteilt. GGT
sei dabei ein synchrones Steuerwerk, das auf die ansteigende Flanke des
Taktsignals CLK reagiert. COMPARATOR sei eine rein kombinatorische Schaltung.
Die Signale RESET, CLK, RES OK und EQUAL seien vom Typ std logic, die
Signale IN1, IN2, RESULT und COMP seien Busse vom Typ std logic vector
mit jeweils acht Bit Breite.
Hinweis Per Konvention sind alle Signale, die von links an einen Block
herangeführt werden, Eingänge und alle, die von rechts an einen Block
herangeführt werden, Ausgänge oder bidirektionale Signale. Die Ausnahme
dieser Regel ist, wenn Signale nach Bedeutungsverwandschaft gruppiert werden.
1.5 Betriebssystemumgebung
Rechnerumgebungen Die Rechner, auf denen das Praktikum durchgeführt
wird, stehen im Raum R268. Der Roboter-Versuch findet im Raum R269
statt. Die Programme für das Praktikum laufen teils unter dem Betriebssystem
Linux, teils unter Windows.
SSH Auf den Linux-Rechnern ist SSH installiert. Um Programme auf
einem anderen Rechner mit lokaler X-Ausgabe starten zu können, müssen
Sie sich analog zu folgendem Beispiel einloggen:
ssh -X synth1@i80pc74.itec.uka.de
Esterel Wir besitzen eine Lizenz für die Esterel-Programme der Linux-
Version.
Xilinx Die Xilinx IDE ist unter Linux installiert.
X2S USB Die Platine ist an den USB-Port der Rechner i80pc71 und
i80pc44 im Raum R269 angeschlossen. Die Software dafür ist unter Windows
installiert.
EEPROM Brenner Zum beschreiben der EEPROMs verwenden wir das
Programm PG4UW. Es ist auf den Rechnern i80pc71 und i80pc44 unter
Windows installiert.
7

SDCC Der Cross-Compiler, der C-Quelltext in 8051-Maschinensprache
übersetzt, steht auf den Linux- Rechnern zur Verfügung.
8

Kapitel 2
Strukturbeschreibung
Im Folgenden wird anhand des Tutorials die Bedienung von ISE erklärt.
Alle Projekte werden in /home/GRUPPE/Praktikum/PROJEKT gepeichert (GRUPPE
entspricht der jeweiligen Praktikumsgruppe und PROJEKT dem entsprechenden
Projekt. Es sind Ordner für die verschiedenen Projekte schon vorgegeben
bzw. erstellt)
Starten Sie auf der Konsole Xilinx mit dem Befehl ise
Sie sehen nun den Projektmanager von ISE. Erstellen Sie ein neues Projekt
mit dem Namen ”TUTORIAL” über das Menü File → New Project mit den
Einstellungen wie in den folgenden Abbildungen dargestellt.
2.1 Neues Projekt
1. File → New Project
• Project Name: TUTORIAL
• Location: /home/GRUPPE/Praktikum/TUTORIAL
• Top-Level Source Type: Schematic
2. Next
Geben Sie nun die folgenden Projekteigenschaften an
3. Next
• Family: Spartan2
• Device: XC2s200
• Package: pq208
• Speed: −5
• Simulator: ISE
• Preferred Language: VHDL
9

4. Next
5. Next
6. Finish
2.2 Schaltplan erstellen
Abbildung 2.1: Neues Projekt
Als nächstes erstellen bzw. fügen Sie einen neuen Schaltplan mit dem Namen
TUTORIAL ein.
1. Rechtsklick auf TUTORIAL (Projekt) im Sources View → New Source
2. Next
3. Finish
• Source Type: Schematic
• File name: TUTORIAL
Es wird ein leeres Blatt angezeigt.
10

Abbildung 2.2: Projekteigenschaften
Abbildung 2.3: Neue Quelldatei hinzufügen
11

2.3 Symbole erstellen
Abbildung 2.4: Neuer Schaltplan
Als nächstes müssen die Symbole GGT und COMPARATOR erstellt werden.
Achten Sie bitte auf die korrekkte Benennung Input/Output-Signale sowie
Busbreite. Signale mit mehr als einem Bit werden mit SIGNALNAME(von:bis)
angegeben.
Beispiel: RESULT(7:0) wird in VHDL als RESULT std logic vector (7
downto 0) übersetzt.
1. Tools → Symbol Wizard
2. Next
3. Next
4. Next
• Pin Name Source: Specify Manually
• Shape: Do not use Reference Symbol → Rectangle
• Symbol Name: GGT
• Add Pin: Geben sie die Pins nach Abbildung 2.7 ein
• Symbol Width: 400
12

5. Finish
• Es wird eine Vorschau des Symboles angezeigt. Eventuelle Fehler
mit Back korrigieren. Nachträgliche Änderungen des Symboles
führen zu Problemen!
6. Tools → Check Symbol
Falls Fehler auftreten sollten, löschen Sie das Symbol und wiederholen
Sie den Vorgang
Erzeugen Sie auf die gleiche Weise das Symbol COMPARATOR, so wie in Abbildung
2.12 dargestellt.
2.4 Symbole einfügen
Abbildung 2.5: Symbol Wizard
Nachdem beide Symbole erzeugt worden sind, wechseln Sie wieder auf TUTORIAL.sch.
Suchen Sie im Feld ”Symbol Name Filter” nach GGT. Markieren Sie das
gefunde Symbol in “Symbols (that begin with... ) und platzieren Sie das
Symbol im .sch Fenster. Legen Sie die endgültige Position mit der linken
Maustate fest.
13

Abbildung 2.6: Neues Symbol
14

Abbildung 2.7: Input/Output Signale für den GGT-Baustein
15

Abbildung 2.8: Aussehen des GGT-Symboles
16

Abbildung 2.9: Vorschau des GGT-Symboles
17

Abbildung 2.10: Fertiges GGT-Symbol
Verfahren sie genauso mit dem COMPARATOR Symbol. Das Ergebnis ist in
Abbildung 2.13 dargestellt.
2.5 Verdrahten
Als nächstes müssen die beiden Symbole verdrahtet, sowie Ein- und Ausgänge
(I/O-Marker) für die Gesamtschaltung eingefügt werden.
1. I/O Marker hinzufügen:
• Menü Add → I/O Marker und an den gewünschten Anschluß des
Symboles platzeren
• gesetzte Marker umbenennen: Doppelklick auf die Marker und
umbenennen. Busbreite beachten (siehe Abbildung 2.14)
2. Verdrahten gemäß Abbildung 2.14
• Menu Add → Wire
• Ausgang RESULT von GGT mit Eingang IN1 des COMPARATOR verbinden
3. Instantznamen vergeben
18

Abbildung 2.11: Regelmäßige Symbolchecks
19

Abbildung 2.12: Das COMPARATOR-Symbol
20

Abbildung 2.13: Symbole Einfügen
• Doppelkick auf das ensprechende Symbol und im erscheinenden
Fenster InstName Ux vergeben. Für GGT U1, für COMPARATOR U2.
Der Schaltplan ist nun fertig.
21

Abbildung 2.14: Verdrahten und Ein-/Ausgänge hinzufügen
22

Kapitel 3
Verhaltensbeschreibung
Nun werden die einzelnen Verhaltenbeschreibungen erstellt. Gehen Sie dabei
folgendermaßen vor:
1. GGT-Symbol markieren
2. Tools → Generate HDL Template from Symbol
3. Im erscheinenden Fenster VHDL auswählen
4. Next
5. Im erscheinenden Fenster sehen Sie nun eine Vorchau des Codegerüstes.
6. Finish
Verfahren Sie genauso für das COMPARATOR Symbol.
Hinweis: Es wird nur ein VHDL-Gerüst erzeugt, das noch mit der eigentlichen
Verhaltensbeschreibung (architecture) vervollständigt werden muß. Bibliotheken
beachten!
Wechseln Sie nun zum Sources-View und klappen Sie TUTORIAL.sch auf.
Hier erscheinen die eben erstellten Grundgerüstdateien. Siehe Abbildungen
3.1, 3.2, 3.3.
23

Abbildung 3.1: Generieren des VHDL-Gerüstes
Abbildung 3.2: VHDL als Zielsprache wählen
24

Abbildung 3.3: Fertiges VHDL-Gerüst
Öffnen sie hier GGT.vhd und fügen Sie den Code aus Listing 7.1 wischen die
Schlüsselwörter begin und end des GGT Architektur ein. Beachten Sie hierzu
auch die unten angeführten Hinweise.
Dann öffnen Sie COMPARATOR.vhd und fügen Sie den Code aus Listing 7.2
zwischen die Schlüsselwörter begin und end der COMPARATOR Architektur
ein.
Hinweis 1 Wenn eine VHDL-Datei im Sources View ausgewählt ist, kann
die Sytax mittels Check Syntax (im Processes Fenster) überprüft werden.
Hinweis 2 Ersetzen sie numeric std durch logic artih
25

Kapitel 4
Synthese
Synthetisieren Sie nun das Projekt, um die einzelnen Codedateien auf Fehlerfreiheit
zu überprüfen. Markieren Sie im Sources-Fenster den Schaltplan TUTORIAL.sch
und doppelklicken Sie hierzu im Fenster Processes auf ”Synthesize - XST“.
Eine erfolgreiche Synthese erkennen Sie an der Meldung (Konsole) Process
”Sythesize“ completed successfully (Abbildung 4.1).
Abbildung 4.1: Erfolgreiche Synthese
26

Kapitel 5
Simulation
Der Xilinx Simulator erlaubt es und, die Schaltung sowohl auf der Verhaltensebene
als auch auf der Schaltkreisebene zu simulieren. Bei der Verhaltensebene
wird nur das Verhalten der Schaltung, nicht aber die zeitliche Verzögerung
der Gatter berücksichtigt. Diese werden bei der Post-Route Simulation berücksichtigt,
wodurch diese um ein vielfaches langsamer ist. Üblicherweise wird die Schaltung
auf ihr Verhalten überprüft. Erst wenn dieses Verhalten korrekt ist, wird
eine zeitbehaftete Simulation (Post-Route Simulation) auf Schaltkreisebene
durchgeführt. Sind beide Simulationsschritte erfolgreich, schließt sich der
Praxistest mit realer Hardware an.
Um eine Schaltung zu simulieren , muß diese mit Signalen stimuliert werden.
Hierzu wird die zu simulierende Schaltung in eine sogenannte Testbench
eingebettet. Die Testbench ist eine übergeordnete Schaltung ohne Ein- und
Ausgänge, sie enthalt nur Programmcode (VHDL) zur Stimulation der Eingangssignale
der zu simulierenden Schaltung. Damit die Testbench nicht manuell erzeugt
werden muß, bietet Xilinx ISE eine grafische Oberfläche zum Erstellen der
Testbench an (Waveform Editor).
5.1 Erstellen der Testbench
Für die Simulation benötigen Sie eine Testbench. Diese wird folgendermaßen
erzeugt (Gehen Sie dabei nach den Screenshots vor):
1. Project → New Source
2. Next
• Test Bench WaveForm
• File Name: TUTORIAL TESTBENCH
3. Select a source: TUTORIAL
4. Next
27

5. Finish
Abbildung 5.1: Testbench erstellen
Abbildung 5.2: Für Testbench wählen
Danach erscheint ein neues Fenster Initial Timing and Clock wizard (Abbildung
5.3). Belassen Sie die Einstellungen und klicken auf Finish. Nun öffnet
sich TUTORIAL TESTBENCH.tbw (Abbildung 5.4), speichern Sie die erstellte
Testbench. Ändern Sie nun die Anzeige in Sources View auf Sources for:
Behavioral Simulation Die Werte der einzelnen Signale weden standardmäßig
in hexadezimalen Werten angegeben. Sie können die Signalcodierung der
Busse per Rechtsklick ändern (z.B. Dezimal). Mit einem Linksklick auf ein
Signal öffnet sich ein Fenster. Hier können Sie durch Werteingabe das Signal
an diesem selektierten Zeitpunkt ändern.
28

Abbildung 5.3: Timingeinstellungen
Stellen Sie die Signale auf Decimal (unsigned) um. Danach belegen Sie die
Signale mit sinnvollen Werten, z.B.:
• Anlegen eines Resetsignales
• IN1 auf 8
• IN2 auf 2
• COMPARE auf 2
5.2 Verhaltenssimulation
Bei der Simulation kann man nun die Schaltung auf Funktionstüchtigkeit
überprüfen. Wechseln Sie die Ansicht in “Sources for:” auf Behavioral Simulation
(Abbildung 5.5, 5.6) und wählen Sie die Testbench aus. Wählen Sie nun im
Reiter Processes → Xilinx ISE Simulator → Simulate Behavioral Model
mittels Doppelklick aus. Starten die die Simulation über Simulation → Run
All (Hierzu sind die entsprechenden Schaltflächen in der Werkzeugleiste
vorhanden). Überprüfen Sie, ob die Ausgangssignale korrekte Werte liefern.
29

5.3 Post-Route Simulation
Verfahren Sie wie im Abschnitt Verhaltenssimulation. Wählen Sie Post-
Route Simulation statt Behavioral Simulation. Überprüfen sie ebenfalls ob
die Ausgangssignale korrekte Werte liefern.
Hinweis sollte die Post-Route Simulation nicht auf Anhieb funktionieren,
führen Sie folgendes durch:
• Project → Cleanup Project Files
• ISE beenden und neu starten
• Programming File nach Kapitel 6.6 erstellen
• Post-Route Simulation nochmal starten
Abbildung 5.4: Waveform Editor
30

Abbildung 5.5: Post-Route Simulation
Abbildung 5.6: Signalverlauf
31

Kapitel 6
Praxistest
Bevor wir unsere Schaltung in der Praxis testen können, müssen wir diese
in die bestehende Hardware einbinden. Wie eingangs erwähnt, steht uns ein
FPGA Board mit USB interface zur Verfügung. An diesem FPGA Board
ist eine LED Platine angeschlossen. Ziel ist, die Eingangssignale für unsere
Schaltung vom PC aus (per USB) zu setzen und das Ergebnis an den
LED’s abzulesen. Hierzu müssen wir unsere Schaltung in eine übergeordnete
Schaltung ENVIRONMENT einbetten, wobei die Eingänge am USB INTERFACE
und die Ausgänge am LED INTERFACE angeschlossen sind. Abbildung 6.1
verdeutlicht die resultierende Hierarchie der Gesamtschaltung.
ENVIRONMENT
USB_INTERFACE
TUTORIAL LED_INTERFACE
GGT
COMPARE
Abbildung 6.1: Hierarchie der Gesamtschaltung
Wir brauchen also drei neue Symbole:
• TUTORIAL
• LED INTERFACE
• USB INTERFACE
sowie eine neue Schaltung:
• ENVIRONMENT
in die dann die drei Bausteine gemäß Abbildung 6.1 eingefügt werden.
32

6.1 Symbol TUTORIAL
Erstellen Sie das Symbol TUTORIAL wie folgt:
• Sources for: → Synthesis/Implemtation
• Tools → Symbol Wizzard → Using Schematic (Abbildung 6.2)
• Folgen Sie dem Dialog (Abbildung 6.3)
Abbildung 6.2: Symbol TUTORIAL aus der Schaltung TUTORIAL erstellen
6.2 Schaltplan ENVIRONMENT
Erstellen Sie nun eine neue Sourcedatei vom Typ Schematic mit dem Namen
ENVIRONMENT (analog Abschnitt 2.2).
Hinweis Es ist unbedingt erforderlich, dass sie den Schaltplan ENVIRONMENT
als Top Module setzen. Wählen Sie per Rechtsklick auf den Schaltplan (im
Sources View) ENVIRONMENT den Menupunkt Set as Top Module.
33

Abbildung 6.3: Fertiges Symbol
6.3 Symbole USB INTERFACE und LED INTERFACE
Erstellen Sie die beiden Symbole LED INTERFACE und USB INTERFACE wie in
den Abbildungen 6.4 und 6.5 zu sehen.
Abbildung 6.4: Symbol LED-Interface
34

Abbildung 6.5: Symbol USB-Interface
6.4 Platzieren und Verdrahten
Öffnen sie ENVIRNMENT.sch und platzieren und verdrahten Sie die eben
erstellten Symbole (Abbildung 6.6). Generieren Sie je ein VHDL-Codegerüst
für die beiden Symbole USB INTERFACE und LED INTERFACE und fügen Sie
den entsprechenden VHDL-Code 7.3 und 7.4 ein.
Hinweis Bei der Erstellung der Symbole gibt es im Xilinx ISE keine
Möglichkeit gepufferte Ein- bzw. Ausgänge zu deklarieren. Dies ist für das
USB INTERFACE unbedingt erforderlich. Ändern Sie deshalb die Signale MODE,
COMP VALUE, VALUE1, VALUE2 und RESET von OUT nach BUFFER im generierten
VHDL-Codegerüst. Bitte beschaten Sie, daß der I/O-Marker beim Anschluß
DATA(7:0) an USB INTERFACE bidirektional ist!
6.5 Randbedingungen und FPGA-Konfiguration
Zum Schluß müssen noch die Ranbedingungen eingegeben werden, damit
die Pins des FPGAs richtig zugeordnet werden:
• Project → New Source → Implentation Constraint File (Abbildung
6.7)
35

Abbildung 6.6: Gesamtschaltung
• Doppelklick auf ENVIRONMENT.ucf
• Übertragen Sie die Pinnzuordung aus 7.5 in die Datei ENVIRONMENT.ucf
6.6 Generieren des Programming Files
Für den abschließenden Test muß ein sogenanntes Programming File erszeugt
werden. Hierzu ist noch eine Enstellung nötig.
• Markieren Sie Ihr Top Modul (ENVIRONMENT (ENVIRONMENT.sch))
• Rechtsklick auf Generate Programming File im FEnter Processes
• Properties auswählen
• Haken müssen bei “Run Design Rules Checker (DRC)” und “Create
ASCII Configruation File” gesetzt sein
• Mittels OK die Änderungen übernehmen
Doppelklicken Sie nun “Generate Programming File”
36

6.7 Test
Abbildung 6.7: Implementation Constraint File
Nun wird es ernst! Begeben Sie sich an einen Windows-Rechner (Raum
269), der mit einer FPGA-Platine über USB verbunden ist. Das Programm
XC2USB Diag, das ebenfalls über die Arbeitsfläche gestartet werden kann,
besorgt die Kommunikation mit dem FPGA. Starten Sie es, es erscheint das
Hauptfenster wie in Abblidung 6.8.
Über die Schaltfläche “Configure Fpga” kann das FPGA programmiert werden
mit einer Konfiguration, wie wir sie hier erstellt haben. Konfigurieren Sie
also das FPGA mit Ihrem Entwurf aus der Datei ENVIRONMENT.rbt, die
in Ihrem Projektverzeichnis liegen sollte. Nun kann der Entwurf getestet
werden. Um Ihre Ausgaben anzuzeigen, ist eine Erweiterungsplatine an den
Bus der FPGA-Platine angebracht, die durch LEDs kodiert die Berechnungsergebnisse
anzeigt:
Es werden die LED-Reihen doppelt benutzt, die Zahlenwerte darstellen.
In der oberen Reihe werden Eingabe 2 oder das Ergebnis dargestellt, in
der unteren Reihe Eingabe 1 oder der Vergleichswert. In der Mitte sind
noch LEDs für die Zustände Equal, Res Ok und Reset angebracht. Mit dem
Programm XC2 USB kann man mit dem Entwurf über USB kommunizieren.
Dies geschieht über das Lesen bzw. Schreiben von Werten an Speicheradressen.
Der Befehl zum Schreiben dieser Speicheradressen lautet write BLOCK
ADDR VALUE
Dabei steht BLOCK für eine Zahl zwischen 0 und 3 (es gibt 4 Speicherblöcke)
37

Abbildung 6.8: Hauptfenster
und ADDR für eine Adresse (hexadezimal) innerhalb des ausgewählten Blockes.
Folgende Adressen werden benutzt im Tutorium:
Adresse Zweck
0 Der Wert für IN1
1 Der Wert für IN2
2 Der Wert für COMP
Bit 0: Anzeigemodus
3
Bit 1: Reset
Die Adressen 0-2 erklären sich selbst. An der Adresse 3 werden durch die
beiden niedrigsten Bit zwei Steuerleitungen gesetzt. Durch das niedrigste Bit
kann der Anzeigemodus gesetzt werden: Ist es ’0’, so werden die Eingaben
(IN1 und IN2) auf der Platine angezeigt; ist es ’1’, so werden die Ausgaben
(RESULT und COMP) angezeigt. Mit dem zweit niedrigste Bit kann das
Reset-Signal gesetzt bzw. gelöscht werden. Ein typischer Dialog zur Demonstration
des Write-Befehls ist in Abbildung 6.9 dargestellt.
38

Abbildung 6.9: Typischer Dialog
39

Kapitel 7
Anhang
7.1 VHDL-Code für GGT
--------------------------------------------------------------------------------
-- Copyright (c) 1995-2008 Xilinx, Inc. All rights reserved.
--------------------------------------------------------------------------------
-- ____ ____
-- / /\/ /
-- /___/ \ / Vendor: Xilinx
-- \ \ \/ Version : 10.1.02
-- \ \ Application :
-- / / Filename : xil_F6mGuc
-- /___/ /\ Timestamp : 10/21/2008 13:23:54
-- \ \ / \
-- \___\/\___\
--
--Command:
--Design Name:
--
library ieee;
use ieee.std_logic_1164.ALL;
use ieee.std_logic_arith.ALL;
library UNISIM;
use UNISIM.Vcomponents.ALL;
entity GGT is
port ( CLK : in std_logic;
IN1 : in std_logic_vector (7 downto 0);
IN2 : in std_logic_vector (7 downto 0);
RESET : in std_logic;
40

end GGT;
RESULT : out std_logic_vector (7 downto 0);
RES_OK : out std_logic);
architecture BEHAVIORAL of GGT is
begin
CLOCKED: process (CLK, RESET, IN1, IN2)
variable a : std_logic_vector (7 downto 0) := "XXXXXXXX";
variable b : std_logic_vector (7 downto 0) := "XXXXXXXX";
variable h : std_logic_vector (7 downto 0) := "XXXXXXXX";
begin
if RESET = ’1’ then
a := IN1;
b := IN2;
elsif CLK = ’1’ and CLK’event then
if a /= b then
if unsigned(b) > unsigned(a) then
h := a;
a := b;
b := h;
end if;
a := unsigned(a) - unsigned(b);
end if;
else
-- do nothing
end if;
RESULT

7.2 VHDL-Code für COMPARATOR
--------------------------------------------------------------------------------
-- Copyright (c) 1995-2008 Xilinx, Inc. All rights reserved.
--------------------------------------------------------------------------------
-- ____ ____
-- / /\/ /
-- /___/ \ / Vendor: Xilinx
-- \ \ \/ Version : 10.1.02
-- \ \ Application :
-- / / Filename : xil_GcbZlx
-- /___/ /\ Timestamp : 10/21/2008 13:24:02
-- \ \ / \
-- \___\/\___\
--
--Command:
--Design Name:
--
library ieee;
use ieee.std_logic_1164.ALL;
use ieee.numeric_std.ALL;
library UNISIM;
use UNISIM.Vcomponents.ALL;
entity COMPARATOR is
port ( IN1 : in std_logic_vector (7 downto 0);
IN2 : in std_logic_vector (7 downto 0);
EQUAL : out std_logic);
end COMPARATOR;
architecture BEHAVIORAL of COMPARATOR is
begin
COMPARE: process(IN1, IN2)
begin
if IN1 = IN2 then
EQUAL

7.3 VHDL-Code für LED INTERFACE
--------------------------------------------------------------------------------
-- Copyright (c) 1995-2007 Xilinx, Inc. All rights reserved.
--------------------------------------------------------------------------------
-- ____ ____
-- / /\/ /
-- /___/ \ / Vendor: Xilinx
-- \ \ \/ Version : 9.2.03i
-- \ \ Application :
-- / / Filename : xil_nx6w7L
-- /___/ /\ Timestamp : 07/29/2008 16:00:01
-- \ \ / \
-- \___\/\___\
--
--Command:
--Design Name:
--
library ieee;
use ieee.std_logic_1164.ALL;
use ieee.numeric_std.ALL;
library UNISIM;
use UNISIM.Vcomponents.ALL;
entity LED_INTERFACE is
port ( COMP : in std_logic_vector (7 downto 0);
EQUAL : in std_logic;
IN1 : in std_logic_vector (7 downto 0);
IN2 : in std_logic_vector (7 downto 0);
MODE : in std_logic;
RESULT : in std_logic_vector (7 downto 0);
RES_OK : in std_logic;
LEDARRAY : out std_logic_vector (21 downto 0));
end LED_INTERFACE;
architecture BEHAVIORAL of LED_INTERFACE is
begin
LEDARRAY(7 downto 0)

LEDARRAY(17)

MODE : BUFFER std_logic;
RESET : BUFFER std_logic;
VALUE1 : BUFFER std_logic_vector (7 downto 0);
VALUE2 : BUFFER std_logic_vector (7 downto 0);
DATA : inout std_logic_vector (7 downto 0));
end USB_INTERFACE;
architecture BEHAVIORAL of USB_INTERFACE is
signal Out_data : Std_Logic_Vector(7 downto 0); -- Zwischenlager für Ausgang
BEGIN
output_selection : process(adr, value1, value2, comp_value, reset, mode)
begin
case adr is
when "00" => Out_data Out_data Out_data Out_data mode, 1 => reset, others => ’0’);
when others => Out_data ’0’);
end case;
end process;
write_process : process(adr, wr_n)
begin
if wr_n = ’1’ and wr_n’event then
case adr is
when "00" => value1 value2 Comp_Value mode

# WR_N for the EZ-USB-Interface (if jumpered so)
NET "oe_n" LOC = "P120";
# OE_N for the EZ-USB-Interface
NET "ledarray" LOC = "P82" ;
NET "ledarray" LOC = "P100";
NET "ledarray" LOC = "P101";
NET "ledarray" LOC = "P102";
NET "ledarray" LOC = "P74" ;
NET "ledarray" LOC = "P70" ;
NET "ledarray" LOC = "P20" ;
NET "ledarray" LOC = "P16" ;
NET "ledarray" LOC = "P10" ;
NET "ledarray" LOC = "P7" ;
NET "ledarray" LOC = "P4" ;
NET "ledarray" LOC = "P205";
NET "ledarray" LOC = "P202";
NET "ledarray" LOC = "P199";
NET "ledarray" LOC = "P61" ;
NET "ledarray" LOC = "P58" ;
NET "ledarray" LOC = "P48" ;
NET "ledarray" LOC = "P45" ;
NET "ledarray" LOC = "P42" ;
NET "ledarray" LOC = "P36" ;
NET "ledarray" LOC = "P33" ;
NET "ledarray" LOC = "P29" ;
# All of them are pins on the extension head
NET "data" LOC = "P108";
NET "data" LOC = "P109";
NET "data" LOC = "P110";
NET "data" LOC = "P111";
NET "data" LOC = "P112";
NET "data" LOC = "P113";
NET "data" LOC = "P114";
NET "data" LOC = "P115";
# EZ-USB-Data-Bus
NET "clk" LOC = "P185";
# the system-clock
NET "adr" LOC = "P151";
NET "adr" LOC = "P152";
# the EZ-USB-Address-Bus
46