Embed Size (px)
Citation preview
Hochschule Bremen WS07/08Fachbereich Elektrotechnik und InformatikFlughafenallee 1028199 Bremen
RST-L Ausarbeitung
VHDL vs Verilog
Anke Kamp
Frank Schmidt
Florian Thiem
Inhaltsverzeichnis
1 Einleitung 1
2 Background 12.1 Warum HDLs? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2 Entwicklungsebenen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3 Programmablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
3 Die Sprachen 43.1 Anfange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.1.1 VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43.1.2 Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2 Komplexitat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63.3 Programmaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3.1 VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.3.2 Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4 Grundlagen der Sprachen 94.1 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.1.1 VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94.1.2 Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.2 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124.2.1 VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134.2.2 Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5 Modularisierung 155.1 Entwicklungsebenen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165.2 Modulaufruf durch andere Module . . . . . . . . . . . . . . . . . . . . . . 16
5.2.1 Modul bei Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . 165.2.2 Komponente bei VHDL . . . . . . . . . . . . . . . . . . . . . . . 17
5.3 Wiederverwendbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6 Zeitverhalten 196.1 Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
6.1.1 Compilerdirektive ’timescale . . . . . . . . . . . . . . . . . . . . . 196.1.2 Systemebene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206.1.3 Verzogerungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.1.4 Blockierende und nichtblockierende Zuweisungen . . . . . . . . . . 216.1.5 Gabelung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226.1.6 Kontinuierliche Zuweisungen . . . . . . . . . . . . . . . . . . . . . 226.1.7 Gatterverzogerungen . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.2 VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236.2.1 Prozesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236.2.2 Kontinuierliche Zuweisungen . . . . . . . . . . . . . . . . . . . . . 24
I
6.2.3 Verzogerungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
7 Operatoren 257.1 VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.1.1 Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . 257.1.2 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . 267.1.3 Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . 267.1.4 Schiebeoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 277.1.5 Konkatenationsoperator . . . . . . . . . . . . . . . . . . . . . . . 27
7.2 Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277.2.1 Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . 277.2.2 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . 287.2.3 Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . 287.2.4 Schiebeoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 287.2.5 Zusammenfugungsoperatoren . . . . . . . . . . . . . . . . . . . . 297.2.6 Konditionale Operatoren in Verilog . . . . . . . . . . . . . . . . . 29
8 Konstrukte auf Gatterebene 298.1 User Defined Privileges in Verilog . . . . . . . . . . . . . . . . . . . . . . 29
8.1.1 Kombinatorische UDP . . . . . . . . . . . . . . . . . . . . . . . . 298.1.2 Sequentielle UDP . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
9 Beispielprogramm Manchester Code 319.1 Grundlagen des Manchester Code . . . . . . . . . . . . . . . . . . . . . . 319.2 Manchester Encoder in VHDL . . . . . . . . . . . . . . . . . . . . . . . . 33
9.2.1 Grundsatzlich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339.2.2 Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339.2.3 Interne Signale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349.2.4 Interner Ablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359.2.5 Mankos am ME . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399.2.6 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
9.3 Manchester Decoder in Verilog . . . . . . . . . . . . . . . . . . . . . . . . 409.3.1 Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409.3.2 Interne Signale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419.3.3 Interner Ablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419.3.4 Mankos am MD . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449.3.5 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
10 Fazit 45
Anhang 47Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47Abbildungsverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48Tabellenverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
II
Liste der verwendeten Listings . . . . . . . . . . . . . . . . . . . . . . . . . . . 48Waveforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52Programmcode und Testbenches . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Manchester Encoder VHDL . . . . . . . . . . . . . . . . . . . . . . . . . 56Manchester Encoder VHDL Testbench . . . . . . . . . . . . . . . . . . . 59Manchester Decoder Verilog . . . . . . . . . . . . . . . . . . . . . . . . . 69Manchester Decoder Verilog Testbench . . . . . . . . . . . . . . . . . . . 72
III
1 Einleitung
Mit Hardwarebeschreibungssprachen (HDL - Hardware Description Language) werdenOperationen von integrierten Schaltungen durch eine formale Syntax beschrieben. MitHDL’s kann nicht nur das Design der Schaltungen beschrieben werden, sondern diebeschriebene Schaltung kann mit entsprechenden Werkzeugen (EDA - Electronic DesignAutomation) auch simuliert und somit also auch getestet werden.Die Besonderheit bei HDL’s ist, dass in ihrer Notation die Moglichkeit gegeben wird,zeitliche Ablaufe und entsprechend die von der Hardware abverlangte Parallelitat zubeschreiben.Im Folgenden soll naher auf die beiden HDL’s VHDL und Verilog eingegangen werden.Beide Sprachen sind zur Zeit in der Praxis die vorherrschenden Sprachen, wobei diegroßte Verbreitung von VHDL in Europa und von Verilog in den USA vorliegt.
2 Background
2.1 Warum HDLs?
Die umfangreichen technischen Errungenschaften der heutigen Zeit werden immer kom-plexer. Trotz der hohen Komplexitat stellen die Hersteller an die Schaltungen den An-spruch der schnellen, effektiven Verarbeitung und dieses, wenn moglich, auf geringstemRaum. Besonders die Hersteller im Embedded Bereich treiben diese Entwicklung starkvoran. Die Entwicklung der ASICs sind ohnehin schon sehr aufwendig und teuer unddas hat zur Folge, dass bei einem zu spat entdeckten Verarbeitungsfehler dessen Be-seitigung nur mit erheblichen Zusatzkosten beizukommen ist. Durch die Entwicklungder Schaltungen mit HDLs werden diese Kosten stark gesenkt, denn die Uberprufungder Schaltungen ist mit Hilfe der Simulation moglich. Es ist somit nicht mehr notwen-dig, zu Testzwecken einen Prototyp des ASICs herzustellen. Fehler konnen somit fruherentdeckt und beseitigt werden, was nicht nur die Kosten senkt sondern auch die Ent-wicklungszeit. Es ist mit Hilfe der Simulation auch eine finanziell tragbare Optimierungder Schaltung moglich. Ein weiterer Vorteil dieser Arbeitsweise liegt auch in der Steige-rung der Komplexitat, die fruher eher auf Basis der Entwicklungskosten limitiert war.ASICs und FPGAs sind heutzutage in der Lage, Schaltungen mit ca einigen Millionenbis einigen 10 Millionen Transistoren umzusetzen, dieses ist jedoch durch die Entwicklerselber nicht mehr zu erfassen. Somit ist die Komplexitat, zur Zeit, durch die Entwicklerlimitiert. Das heißt also, HDLs bewirken, dass die Grenzen der Schaltungsentwicklungnicht mehr durch die Technik gesetzt werden sondern durch den Menschen.
2.2 Entwicklungsebenen
Folgende Auflistung soll die in der Hardware-Entwicklung verwendeten Entwicklungs-ebenen in Erinnerung bringen.
1. Systemebene/Algorithmische Ebene
1
� Grobes algorithmisches Model
� Modulierung in C/C++, MATLAB, VHDL, Verilog
2. Register-Transfer-Ebene
� Beschreibung kommunizierender Register und Logikeinheiten, mit Datenstruk-turen und Datenflusse
3. Gatterebene
� Beschreibung durch Gatter und Flipflops
4. Schaltkreisebene
� Beschreibung durch Bauteile, z.B. Transistoren
Bei allen Ebenen ist die Simulation mit entsprechenden Simulatoren moglich, wobei dieSimulation aufgrund von zu hoher Komplexitat der heutigen Projekte und der hierfurzur Verfugung stehenden zu kleinen Rechnerkapazitaten auf der Schaltkreisebene nichtdurchgefuhrt werden kann.
2.3 Programmablauf
Wie bereits erwahnt, haben HDLs den Entwicklungsablauf entscheidend verandert. InAbbildung 1 ist der typische Designablauf mit HDLs dargestellt. Mit Absicht wird inder Abbildung HDL genutzt, denn sowohl VHDL als auch Verilog unterstutzen diesenAblauf.
Abbildung 1: Typischer Designablauf [DEO94]
Wie zu erkennen ist, wird der fertig gestellte Code gleich uberpruft. Dieses wird meist
2
mit Hilfe der Simulation getan, Somit kann man also sagen, dass in diesem Fall dieSimulation im Grunde ein Testing der beschriebenen Hardware ist. Das Ergebnis wirdin den gangigen EDA-Werkzeugen als Waveform oder in einer Ergebnisliste ausgegeben,teilweise aber auch beides. Die Ruckgabewerte der Simulation sind also im Grunde ei-ne Darstellung der Ein- und Ausgabesignale des zu prufenden Designs (DUT - Deviceunder Test oder auch DUV - Device under Verification). Da im DUT selber keine Ein-gangssignale definiert sind, sondern nur die Ports fur sie, muß ein Top-Level-Design, alsoein in der Projekthierarchie hoher angesiedeltes File, die Ports ansteuern. Abbildung 2verdeutlicht die Simulationsumgebung des DUT. Wie zu erkennen ist, werden in der
Abbildung 2: Zusammenhang Testbench und DUT [FK06]
Testbench alle fur die Simulation wichtige Daten definiert. Die Stimuli sind die benotig-ten Eingangssignale, nach der Verarbeitung durch das DUT ubernimmt die Testbenchdie Resultate und fuhrt sie dann zur Ausgabe weiter. Viele EDA-Werkzeuge bieten auchdie Moglichkeit der automatischen Testbench Generierung, wobei dann alle notwendigenPort-Informationen vorgegeben werden und nur noch die Stimuli durch den Entwicklerselber geschrieben werden mussen.Nachdem die Simulation die gewunschten Ergebnisse liefert, bieten viele EDA-Werkzeugedie Moglichkeit der Synthese, welche eine Umsetzung des Designs in eine tiefere Entwick-lungsebene ist. Ist das Design zum Beispiel auf der Register-Transfer-Ebene umgesetzt,
”transformieren“ die Simulatoren die Schaltung auf die Logik-Ebene. Somit ist die Syn-
these also das Gegenteil einer Schaltungsanalyse, welche die”feine“ Schaltung in ein
”groberes“ Model umsetzt.
3
3 Die Sprachen
3.1 Anfange
Beide Programmiersprachen haben gemein, dass unterschiedliche Versionen (Veroffent-lichungszeit abhangig) jeweils unterschiedlichen Funktionsumfang mit sich bringen. Imgroßen und ganzen ist jedoch selten der Funktionsumfang der Sprachen selber Basis furdie Entscheidung, sondern eher personliche Bevorzugungen oder die Voraussetzungen,gegeben durch die Auftraggeber und vorhandene Programmieroberflache.
3.1.1 VHDL
(Quellen: [FK06], [Mad08])VHDL ist ein Akronym fur VHSIC Hardware Description Language, wobei VHSIC wie-derum ein Akronym fur Very High Speed Integrated Circuit ist.Entstanden ist VHDL aus dem Bestreben, eine standardisierte, einheitliche Sprache zuentwickeln, die zur Beschreibung oder Dokumentation von Hardware verwendet werdensollte. Ein weiteres Augenmerk wurde dabei auch darauf gelegt, dass die Hardware nichtnur beschrieben, sondern auch simuliert werden konnen sollte.Initiiert wurde die Entwicklung der Sprache in den achziger Jahren durch das amerika-nische Verteidigungsministerium (Department of Defense - DoD). Das DoD hatte vorder Entwicklung von VHDL haufig das Problem, dass beim Schaltungsentwurf die Zu-lieferer meist unterschiedliche EDA-Werkzeuge oder andere Methoden verwendeten, dieteilweise nicht miteinander kompatibel waren, da sie haufig firmenspezifisch waren. DieZiele fur die
”neue“ Sprache VHDL wurden 1981 durch Vertreter der Regierung, der
Industrie und Hochschulen festgelegt und 1983 bekamen die Firmen Intermetrics, IBMund Texas Instruments den Auftrag, VHDL in Anlehnung an ADA zu entwickeln.Das ebenfalls fur das DoD entwickelte ADA 83 ist eine objekt-basierte Sprache diewesentliche Merkmale der objektorientierten Konzepte wie z.B. Vererbung nicht imple-mentiert. Diese Anlehung an ADA ist auch Basis fur die objekt-basierte Umsetzung vonVHDL und somit auch das Fehlen der objektorientierten Merkmale.Das erste VHDL wurde 1985 unter VHDL-Version 7.2 veroffentlicht. 1987 wurde dieSprache VHDL vom amerikanischen IEEE1 unter der Bezeichnung IEEE 1076-1987 stan-dardisiert. 1988 wurde VHDL auch als ANSI -Standard2 veroffentlicht und das DoD ver-langt seit 1988 von allen Zulieferern die Dokumentation in VHDL. 1993 wurde eine uber-arbeitete Version von VHDL, die einige Erweiterungen beinhaltet, unter IEEE 1076-1993standardisiert. Der IEEE 1076-1993 ist derzeitig der letzte gultige VHDL Basis-Standardund ist im Language Reference Manual (LRM) dokumentiert 3.Da IEEE 1076-1993 nur die Beschreibung von Schaltungen und deren Simulation um-setzt, gab es Bestrebungen, auch die Entwicklung fur speziellere Probleme zu ermogli-
1IEEE - Institute of Electrical and Electronics Engineers2ANSI - American National Standards Institute3 LMR zu finden unter http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?tp=&arnumber=893288&isnumber=19335
4
chen bzw. zu vereinfachen. Besonders zu erwahnen ist hierfur z.B. die Simulation desZeitverhaltens auf Gatterebene. Dieses ist als IEEE 1076.4 standardisiert worden undist auch als VITAL-Standard4 bekannt. Weitere Ansatze sind IEEE 1076.6, der die Syn-thesefahigkeit bei der automatischen Umsetzung auf Register-Transfer-Ebene in eineGatterrealisierung garantiert, IEEE 1076.3 fur die vorzeichenlose und vorzeichenbehaf-tete Arithmetik oder auch IEEE 1076.2, welches ein mathematisches Package ist, umGleitpunktzahlen und komplexe Zahlen zu simulieren. Teilweise wird auch versucht deneigentlichen digitalen Hintergrund zu verlassen, wie z.B. bei VHDL-AMS, welches dieSimulation von analogen Schaltungen ermoglicht und als IEEE 1076.1 standardisiertwurde.Seit 2002 wird an einer umfangreichen Uberarbeitung mit der Bezeichnung VHDL-200Xgearbeitet, deren Veroffentlichung zur Zeit jedoch noch aussteht (Stand Dezember 2007).Ziel hierbei ist die Neuerung der synthesefahigen Umsetzung von Gleitpunktzahlen, denndie Synthesefahigkeit ist zur Zeit nur fur ganzzahlige Datentypen moglich.
3.1.2 Verilog
(Quellen: [Unb08b], [Unb08a], [FV07], [FK06])Entwickelt wurde Verilog 1984 als proprietare Sprache durch die Firma Gateway DesignAutomation Inc. Verilog wurde in Anlehnung an die in den Achzigern haufig verwendeteProgrammiersprache C entwickelt. Ohne jedoch standardisiert zu sein, wurden in denVerilog Veroffentlichungen zwischen 1984 und 1990 immer wieder grundlegende Uber-arbeitungen vorgenommen. Die Firma Gateway entwickelte zusammen mit der SpracheVerilog einen Simulator, der seit 1985 von Gateway angeboten wurde. Nach wesentli-chen Anderungen an dem Simulator und an der Sprache wurde 1987 Verilog-XL her-ausgebracht. Verilog-XL zeichnet sich durch die schnelle und effiziente Simulation derSchaltungsbeschreibung auf Gatterebene aus. Vergleichbar mit VHDL konnte also eineBeschreibung der Schaltung auf Gatterebene durchgefuhrt werden, nur konnte Verilogbereits zu diesem Zeitpunkt die Beschreibung auf der Register-Transfer-Ebene ermogli-chen. Das fuhrte ab 1986 hauptsachlich in den USA zu dem Anstieg der Verilog Nutzung.1988 wurde durch die Firma Synopsys das erste Logiksynthesewerkzeug veroffentlicht,das es ermoglichte, die in Verilog verfasste RTL-Beschreibung in eine Gatterrealisierungzu uberfuhren. Dieser
”Design Compiler“, der heute noch von vielen Entwicklern genutzt
wird, fuhrte zu einer weiteren Verbreitung von Verilog.Seit 1989 wurde der Verilog-XL Simulator haufig bei der Schaltungs-Entwicklung zurSimulation der Funktionen mit dem Zeitverhalten auf Gatterebene genutzt und diesesim Prinzip einer
”Sign-Off-Simulation“. Hierbei garantieren die ASIC-Hersteller dem
Kunden, dass bei der Verwendung des Simulators und der gleichen Simulationsmodellefur die Gatter, die Funktionen und das Zeitverhalten des gefertigten ASICs5 gleich derSimulation ist.1989 wurde die Gateway Design Automation Inc von der Firma Cadence Design Systems,einem der Marktfuhrer im EDA-Bereich, aufgekauft. Wahrend Cadence, nun Rechtein-
4VITAL - VHDL Initiativ Towards ASIC Libraries5ASIC - Application Specific Integrated Circuit
5
haber von Verilog, sowohl die Sprache als auch den Simulator weiterentwickelte, konzen-trierten sich andere EDA-Hersteller auf den offenen Standard VHDL. Cadence erkanntedie Gefahr, dass die Industrie aufgrund der Lizensierung Verilogs zu VHDL wechselnkonnte und rief 1990 die Open Verilog International (OVI) ins Leben. Diese veranlasste1991 die Offnung der Sprache Verilog, was dazu fuhrte, dass andere EDA-Hersteller mitder Entwicklung von Simulatoren begonnen und 1992 zur Veroffentlichung des ersten,nicht von Cadence entwickelten Simulators fuhrte. Um zu verhindern, dass jede Firmadie Sprache zu ihren eigenem Nutzen verandert, wie Gateway es in der Regel getan hat-te, wird 1994 die Arbeitsgruppe IEEE 1364 gegrundet, was 1995 unter der BezeichnungIEEE 1364-1995 zur Standardisierung von Verilog fuhrte.Eine Uberarbeitung des Standards wurde mit IEEE 1364-2001 geliefert. Dieser auch alsVerilog 2001 bezeichnete Standard erweitert den alten Standard, um schon langer vonden Nutzern bemangelte Einschrankungen zu beseitigen.Eine Erweiterung fur Verilog 2001 ist SystemVerilog 3.0. Diese ist 2002 veroffentlichtworden und ermoglichte nun erstmalig die Verifizierung der Hardware. Dadurch ist Ve-rilog zur ersten Hardware Beschreibungs- und Verifikationssprache, oder kurz HDVL6,geworden. Somit ist es also moglich geworden, Verification und Entwicklung in einerSprache umzusetzen. Wie bereits erwahnt, konnen die EDA Werkzeuge teilweise dieTestbench generieren, das Verfassen der Stimuli bleibt jedoch noch immer dem Ent-wickler uberlassen. Aufgrund der Komplexitat der heutigen Entwicklungen fuhrt dieseshaufig zu Problemen, denn die prazise Umsetzung der Stimuli verlangt eine genaue Pro-grammierung und entsprechend auch eine verhaltnismassig lange Zeit. Um die Stimulizu entwickeln, wurde daher bisher haufig auf andere Sprachen, wie zum Beispiel VERA,zuruckgegriffen. VERA ist eine Hardware Verification Language (HVL) und ist daraufausgelegt, Stimuli prazise zu beschreiben. Dieses hat die Entwickler jedoch immer dazugezwungen, zwei unterschiedliche Sprachen zu lernen, oder die Firmen mußten Inge-nieure fur die eigentliche Entwicklung und fur die Verifikation beschaftigen. Dieses wirdnun durch SystemVerilog umgangen, denn hierbei findet die Verification ebenfalls in derVerilog-Notation statt. Ein Erlernen einer zweiten Sprache wird daher fur die Entwicklernicht mehr notig, denn bei SystemVerilog werden die Konstrukte der HVLs mit Veriloggebundelt.Wie VHDL versucht auch Verilog, speziellere Problemlosungen moglich zu machen. EinBeispiel dafur ist die Umsetzung fur Analog and Mixed-Signal Designs, welche mit derErweiterung Verilog-AMS ermoglicht wird.
3.2 Komplexitat
Um die Komplexitat der beiden Sprachen zu erkennen, betrachtet man am einfachs-ten einen Code in beiden Sprachen, der das gleiche wiedergibt. Als Beispiel dient einTuroffner, der drei Eingangssignale hat. C ist ein Signal, das im Grunde zur Siche-rung der Tur dient. Heißt also, wenn C gesetzt ist, dann ist die Tur abgeschlossen. Hund P sind die Offnungssignale, z.B. wenn die Tur auf Knopfdruck geoffnet wird und
6HDVL - Hardware Description and Verification Language
6
zwei Knopfe vorhanden sind. Somit muß zum Offnen der Tur also entweder H oder PTrue sein und C muß False sein, erst dann darf das Ausgangssignal F gesetzt werden,was letztendlich die Tur offnet. Der Code, der dieses System umsetzt sieht wie folgt aus:
Listing 1: Verilog DoorOpener
module DoorOpener (C, H, P, F ) ;input C, H, P;output F;reg F;
always @(C, H, P)begin
F <= (˜C) & (H | P) ;end
endmodule
Listing 2: VHDL DoorOpener
l ibrary i e e e ;use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
Entity DoorOpener i sPort (C, H, P: in s t d l o g i c ;
F : out s t d l o g i c ) ;end DoorOpener ;
Architecture beh of DoorOpener i sbegin
Process (C, H, P)begin
F <= not (C) and (H or P) ;end Process ;
end beh ;
An diesem Beispiel schon zu erkennen, ist der unterschiedliche Ansatz im Programm-aufbau.Bei Verilog ist die Zuweisung von Datentypen hier nur bedingt notwendig und Bibliothe-ken mussen hier nicht eingebunden werden. Lediglich das Ausgangssignal benotigt einenDatentyp, damit die Ergebnisse nicht verloren gehen, denn reg speichert ihren Inhaltzwischen den Anweisungen. Wahrend Verilog sich also eher intuitiv darstellt (Richtungder Signale angeben und die gewunschte Tatigkeit beschreiben und es lauft), zeigt sichVHDL da schon etwas komplexer. VHDL fordert auch in diesem sehr einfachen Beispieleine genaue Programmierung mit Port Definition, mit entsprechender Datentyp Dekla-rierung und Einbindung der Bibliotheken. Dieses verlangert den VHDL Code etwas undfordert von dem Programmierer entsprechende Sorgfalt und Ubersicht. Dieses macht denEinstieg in VHDL schwerer, ist jedoch fur die Robustheit sehr von Vorteil.
3.3 Programmaufbau
Sowohl Verilog wie auch VHDL haben gemeinsam, dass die Ports mit der entsprechendenRichtung deklariert werden mussen. Sie mussen also als input oder als output typisiertwerden.
3.3.1 VHDL
(Quellen: [Mad08], [Ash08], [FK06])VHDL Entwurfe sind in Bibliotheken organisiert, die aus ausfuhrbarem Code bestehen.Diese Entwurfsbibliotheken konnen aus package, entity, architecture und configu-ration bestehen. Ein package stellt eine globale Deklaration dar, so sammelt es z.B.
7
Typen oder auch Unterprogramme, die dann in mehreren Entwurfen verwendet werden.Sie sind einer library zugeordnet, somit muß zum Einfugen des package diese libraryvorher zugefugt werden. Zu sehen ist dieses in den ersten beiden Code-Zeilen des Tur-Offners Listing 2.Wie ebenfalls schon im Beispiel des Tur-Offners zu sehen war, macht VHDL eine strengeTrennung zwischen der Port Deklaration und der eigentlichen Funktionsumschreibung.Die Ports werden in der entity festgelegt, deren Aufbau in Listing 3 zu sehen ist. Siestellt also die externe Sichtweise dar. Das eigentliche Funktionsdesign wird in einer derentity zugeordneten architecture beschrieben, die unter Listing 4 dargestellt ist.
Listing 3: VHDL Entity als Pseudocode
entity entityName i s[ generic ( L i s te−der−gene r i c s−und−deren−Typen ) ; ][ port ( L i s te−der−Anschlussports−und−deren−Typen ; ][ l o c a l d e c l a r a t i o n s ; ]
[ beginpas s i v e statements ]
end [ entity ] [ entityName ] ;
Bei der entity werden neben den Ein- und Ausgabeports teilweise auch generics festge-legt. Dieses sind Parameter, die interne Eigenschaften und Wortbreiten festlegen. Fur diearchitecture werden die generics dann als Konstanten angesehen. Die passive state-ments sind eine Sammlung von Signalen, deren paralleler Ablauf synchronisiert werdenoder voneinander ausgeschlossen werden muß. Damit ist gemeint, dass wenn z.B. be-stimmte Zusammenhange (z.B. beide High) zwischen zwei Signalen an zwei unterschied-lichen Eingangsports nicht auftreten durfen, dann konnen diese Zusammenhange hiervoneinander ausgeschlossen werden. Die entity eines Entwurfs kann als Komponente inandere Entwurfe eingebunden werden.Die architecture ist die eigentliche Funktionsbeschreibung und kann an verschiedeneentity angeschlossen werden bzw. mehrere architecture konnen an einer entity ver-wendet werden. Die notwendige Definition zur Auswahl der architecture wird dannuber die configuration bestimmt.
Listing 4: VHDL Architecture als Pseudocode
architecture architectureName of entityName i s[ l o c a l d e c l a r a t i o n s ]
beginstatements ;
end [ architecture ] [ architectureName ] ;
Bei den local declarations werden die Typen, Konstanten fur die Unterprogramme undarchitecture festgelegt, wobei das eigentliche Design der Funktionen in den statementsbeschrieben wird.
8
3.3.2 Verilog
(Quellen: [Unb08c], [Bha99], [FV07], [FK06])Wahrend VHDL einen eher
”harten“ Aufbau mit entity und architecture im Source
Code aufweist, ist Verilog eher simpel in der Struktur. Es ist, wie im Listing 5 zu sehenist, nur mit einem module versehen. In diesem module werden die Deklarationen unddie Statements nacheinander aufgelistet. Zum Zwecke der Ubersichtlichkeit sollten dieDeklarationen sortiert werden, was aber nicht zwingend ist. Eine Bibliothek kann zwar,wenn notwendig, eingebunden werden, dieses ist aber in den meisten Falle nicht notig.
Listing 5: Verilog Module als Pseudocode
module moduleName ( p o r t L i s t ) ;port d e c l a r a t i o n ;[ other d e c l a r a t i o n ; ] // z .B. l o k a l e Variab len
statements ;endmodule
4 Grundlagen der Sprachen
4.1 Datentypen
Es gibt in beiden Sprachen gangige Datentypen, wie z.B. boolean, bit, skalare, fliess-komma, characters, integer. Die Werte und Verwendung diese Datentypen sind ver-gleichbar mit denen in anderen Sprachen, wobei der Integerbereich von −2−31 bis 231 − 17 reicht. Bei der Verwendung ist jedoch zu beachten, dass nicht alle Datentypen synthe-tisierbar sind. So sind z.B. Fliesskomma-Zahlen in Verilog bisher gar nicht und in VHDLerst mit der neusten Version 200x synthetisierbar.
4.1.1 VHDL
VHDL verlangt eine genaue Typisierung, das hat zur Folge, dass jede Konstante (Wiebei anderen Sprachen ein Parameter der zentral zugewiesen wird und dann haufiger ver-wendet werden kann), Variable (Zwischengroße wie in anderen Programmiersprachen,Verwendung mehrfach und beliebig oft moglich) und alle Signale (interne Verbindungs-leitung zwischen Funktionsblocken, Behandlung wie Ausgangsgroßen) in der Deklara-tion einen festen Typ zugewiesen bekommen mussen. Diese Typen sind in Packagesvordefiniert, die in der Regel erst eingefugt werden mussen. Ausgenommen von die-ser Importpflicht ist das Package standard, denn dieses beinhaltet den Sprachstandardund ist entsprechend immer bekannt. Weiter werden noch haufig benotigt das Packagetextio aus der std Bibliothek und aus der ieee Bibliothek die Packages std logic 1164,std logic textio (ermoglicht z.B. Dateien einzulesen) und numeric std (ermoglicht Ver-wendung von arrays mit std logic als Signale), numeric bit (ermoglicht Verwendung von
7 siehe: http://www1.hs-bremerhaven.de/kmueller/s06ng/assets/stf_e1.pdf
9
arrays vom Bit Datentyp als Signale). Einige wichtige Datentypen in VHDL mit denentsprechenden Werten lauten:
� std ulogic und std logic
– 1: Wert 1; stark
– 0: Wert 0; stark
– W: unbekannt; schwach
– L: Wert 0; schwach
– H: Wert 1; schwach
– (-): don’t care
– Z: tristate/hochohmig; schwach
– X: unbekannt; stark; Ergebnis fehlerhaft entstanden
– U: undefiniert; uninitialisiert oder unbekanntes Signal
� < datentyp > vector; z.B. Bit vector(3 downto 0)
� Records (aus bestehenden Typen zusammengesetzter Datentyp)
� Eigene Typdefinitionen per type;z.B. type name is (liste, der, werte)
� Typeinschrankung per subtype;z.B. subtype name is < datentyp > range untergrenze to obergrenze;
Durch std logic und std logic wird ein Logiksystem definiert, welches fur die Simulati-on und Synthese von Hardware besser geeignet ist als der Bit Datentyp. Sie ermoglichenneun Zustande, wobei, in der Liste
”stark“ und
”schwach“ die Treiberstarken definiert.
Es gibt bei VHDL verschiedene Datentypen, die vektorfahig sind. Als Beispiel wurde derBit Datentyp verwendet, aber auch andere wie z.B. std logic sind equivalent zu ver-wenden. Um die Zugriffsrichtung zu definieren, kann neben dem gezeigten downto auchto verwendet werden, wobei dann entsprechend die Ober- und Untergrenze getauschtwerden muß.Das folgende Beispiel im Listing 6 zeigt die Verwendung des Record Datentyps als Pseu-docode. In diesem Datentyp konnen die Komponenten unterschiedlichster Datentypenzu einem gebundelt werden. Es ist somit moglich abstrakte Datenmodelle zu bilden,dessen einzelnen Felder uber die Namen dereferenziert werden konnen.
Listing 6: VHDL Beispiel fur Record Datentyp
type typeName i s recordf ie ldName : typeRange
end record [ typeName ] ;
−− Zu g r i f f auf Fe lder :
10
process . . .variable var : typeName ;beginvar . f ie ldName := value ;. . .−− mogl iche we i t e r e Anweisungen , Typ Qu a l i f i z i e r t
var := typeName ( ’ value1 ’ , va lue2 ) ;. . .
VHDL ist sehr gut geeignet, um Datentypen selbst zu definieren. Wie schon beschriebenist es moglich, aus bereits bestehenden Typen einen
”neuen“ Datentypen zu erstellen.
Aber auch das Einschranken der Datentypen wird unterstutzt, welches mit subtypemoglich ist, oder das Erstellen eines komplett neuen Datentypes mit type. Bei der Defi-nition eines neuen Datentypes ist es zum Beispiel moglich, die verschiedenen Zustande,die der Datentyp einnehmen kann, in einer Liste aufzufuhren und somit eine kompletteUnabhangigkeit von bereits bestehenden Datentypen zu bekommen. Es bestehen jedochzum Erstellen der eigenen Datentypen viele unterschiedliche Herangehensweisen. So istes z.B. auch moglich, aus einem selbst erstellten Vektor nur bestimmte Werte zu ent-nehmen, die mit Hilfe des Index definiert werden und diese Werte zu einem eigeneneDatentyp zu definieren. Die Moglichkeiten sind sehr umfangreich und ermoglichen so-mit die Umsetzung von sehr komplexen Dartentypen, denn auch die Schachtelung derverschiedenen Datentypen ist moglich.
4.1.2 Verilog
Es gibt neben den gangigen Datentypen jedoch auch spezielle Typen. Wobei Verilog zweiHauptdatentypen zur Verfugung stellt, die in der folgenden Tabelle 1 gelistet sind.
Schlusselwort Beschreibung
wire Einfache Verbindung zwischen Schaltungs-elementen, Leitung, Variablen ohne Spei-cherverhalten
reg Verbindung mit Speicherverhalten, Ziel furZuweisungen, Variablen mit Speicherverhal-ten
Tabelle 1: Datentypen in Verilog
Es gibt in diesen beiden Datentyp Klassen noch weitere speziellere Typen (z.B. tri0,welches fur ein wire mit einem Pulldownwiderstand bei der Simulation verwendet wird),die nur fur ganz spezielle Variablen verwendet werden konnen. Im Grunde sind jedoch
11
diese beiden die wichtigsten und die prinzipielle Verwendung ist vergleichbar.Der wire Datentyp ist im Grunde ein Verbinder. Er besitzt kein Speicherverhalten undist daher in seinem Verhalten vergleichbar mit einem physikalischen Draht.Die Bezeichnung reg kommt von Register und dieses signalisiert auch die Verwendung.Der reg Datentyp besitzt ein Speicherverhalten, was jedoch nicht zu verwechseln ist miteinem in der Hardware wiederzufindenen Register, da es nur eine Variable ist.Beide Typen, sowohl reg als auch wire, konnen in Kombinationen verwendet werden.Das heißt, dass sie nicht nur in der Grundbreite von einer
”Leitung“ mit einem Bit
Breite verwendet werden konnen, sondern in beliebiger Anzahl mit beliebiger Bitbreite.Die folgende Tabelle 2 zeigt einige exemplarische Verwendungen.
Typ Syntax Beispiel
Leitung oder Variablemit einer Breite voneinem Bit
name reg enable;
Bus oder Variable miteiner Breite von n Bit [n-1:0] name wire [3:0] nibble;k Busse mit jeweilsn Bit [n-1:0] name [0:k-1] wire [2:0] activity [0:1];
Speicher mitk Speicherzellender Breite n Bit
[n-1:0] name [0:k-1]reg [7:0] memory [0:31];Zugriff: memory[4][2]
Tabelle 2: Anwendungen der Datentypen in Verilog
Wie in der Tabelle zu erkennen ist, wird wire fur Busse verwendet und reg fur Speicher-zellen. Um die Kombination von mehreren wires und regs zu erstellen, wird sowohl dieBitbreite als auch die Anzahl vektorisiert zugewiesen. Wobei der Aufbau grundsatzlichaus Bitbreite Name Anzahl besteht. Die Zuweisungen wird dann wie bei Variablenoder Konstanten durchgefuhrt, wobei der Zugriff auf die einzelne Zelle oder den einzel-nen Bus mit Name [Zelle/Leitung] [Bit] durchgefuhrt wird.Wie bereits erwahnt, muß bei Verilog nicht unbedingt ein Datentyp zugewiesen werden.Dies ruhrt daher, dass als default-Wert sowohl fur die input als auch fur die outputPorts wire angesetzt ist. Dieses ist selbsverstandlich durch entsprechende Zuweisungzu andern, wobei zu beachten ist, dass input und inout Ports nur vom Typ wire seindurfen. Somit konnen also nur die output Ports in einen der reg Datentypen verandertwerden.
4.2 Funktionen
Sowohl Verilog als auch VHDL ermoglichen die Verwendung von Funktionen, welchewie bei herkommlichen Programmiersprachen Unterprogramme darstellen. Sie dienendazu, immer wiederkehrende Ablaufe zu beschreiben und somit die Wiederverwendbar-keit dieser Teile zu erleichtern und ermoglichen die Strukturierung und Vereinfachung
12
des Codes. Beide Sprachen liefern dafur jeweils zwei unterschiedliche Notationen, wobeidiese sich nicht nur in der Notation selber unterscheiden sondern auch in ihren Bedingun-gen, die sie erfullen mussen. Bei den Funktionen beider Sprachen gibt es jedoch starkeAhnlichkeiten und diese nicht nur in der Notation sondern auch in den Bedingungen.
4.2.1 VHDL
(Quellen: [Mad08], [Ash08], [FK06])Die beiden Funktionstypen bei VHDL heißen function und procedure. Beide Funkti-onstypen arbeiten intern sequenziell und konnen immer dann verwendet werden, wennder Ruckgabewert erlaubt ist. Der prinzipielle Aufbau der function Listing 7 und derprocedure Listing 8 ist im folgenden dargestellt. Dabei ist die Parameterliste bei derfunction optional, denn es ist moglich functions mit keinem oder mehreren Parameternaufzurufen.
Listing 7: Aufbau einer function
function funcName ( parameterL i s te ) return type i s−− Dek lara t ion ;
begin−− S e q u en z i e l l e Anweisungenreturn var ;
end funcName ;
Sollte jedoch bei der function keine Parameterliste vorhanden sein, muß die Variable varim Deklarationsteil angelegt werden. Dabei durfen die Parameter/Argumente bei func-tions nur den Modus IN besitzen und mussen daher auch nicht zwingend mit einerRichtung deklariert sondern nur typisiert werden. Als Argumentenklassen stehen beider function die Signale und Konstanten zur Verfugung, wobei bei Nichtangabe derArgumentenklasse Konstanten als
”Defaultklasse“ gesetzt wird. Wie im Beispiel zu er-
kennen ist, wird die function mit return und Angabe des Variablennamens verlassen.Dieses ist bei functions jedoch nur fur einen Wert moglich. Dieser eine Wert ist je-doch zwingend. Es ist somit nicht moglich, keinen oder mehrere Werte auszugeben. Wiebereits erwahnt und wie auch im Beispiel zu erkennen ist, werden sequenzielle Anweisun-gen verwendet. Bei functions sind dazu alle sequenziell abzuarbeitenden Anweisungenausser wait moglich, denn wait wurde eine Zeitverzogerung bewirken und dieses istbei functions nicht erlaubt. Da keine Verzogerungen bei functions zugelassen werden,ist es moglich diese zu synthetisieren. Die function ist keine eigenstandige Anweisung,kann jedoch sowohl von sequenziellen als auch von nebenlaufigen Anweisungen aufgeru-fen werden.Dieses ist bei procedures anders. Diese sind eigenstandige Anweisungen und konnendaher selbstandig sequenziell als auch parallel verwendet werden. Werden proceduresjedoch parallel verwendet, dann werden sie uber die IN und INOUT Argumente gesteu-ert. Das heißt, immer wenn die Argumente sich andern, wird die procedure ausgefuhrt.
13
Listing 8: Aufbau einer procedure
procedure procName ( p a r a m e t e r l i s t e ) i s−− Dek lara t ion ;
begin−− s e q u e n z i e l l e Anweisungen
end procName ;
Die procedure hat allerdings noch weitere Unterschiede zu der function. So ist die Pa-rameterliste bei der procedure nicht optional, denn es muß mindestens ein Argumentubergeben werden. Es konnen allerdings auch mehrere Parameter genutzt werden. DieArgumente haben dafur allerdings auch die Moglichkeit, neben dem Modus IN, den Mo-dus INOUT und OUT anzunehmen. Ist kein Modus angegeben, werden die Argumenteper default auf IN gesetzt und diese bei fehlender Argumentenklasse als Konstante.Wenn die Argumente als Modus OUT gesetzt wurden aber keine Argumentenklassedefiniert wurde, wird per default fur den Parameter die Klasse Variable verwendet. So-mit gibt es also eine Klasse zusatzlich, denn neben den Argumentenklassen Signale undKonstanten ist bei der procedure auch noch die Klasse Variable moglich. Ein weitererUnterschied ist, dass bei procedures die Moglichkeit besteht keinen oder auch mehrereRuckgabewerte zu bekommen. Zum Verlassen der procedure gibt es zwei Moglichkeiten,zum einen wie bei der function ein return zu setzen, zum anderen durch die Steue-rung uber eine sensitivity-list. Eine sensitivity-list ist eine Folge von verschiedenenVariablen, deren Anderung zum Ausfuhren des, durch die sensitivity-list gesteuer-ten, Blockes fuhrt. Beide Wege sensitivity-list und return schliessen sich, aufgrundihrer ahnlichen Wirkungen gegenseitig aus, das heißt also ein return kann nur verwen-det werden, wenn die Steuerung nicht uber eine sensitivity-list getatigt wird. Bei derprocedure sind alle sequenziellen Anweisungen moglich, es gibt dabei keine Ausnah-me. Es ist somit also moglich ein wait zu verwenden, was jedoch die Synthesefahigkeitbeeinflusst. Denn wie bereits erwahnt, schliesst eine Zeitverzogerung die Synthese desEntwurfs aus.
4.2.2 Verilog
(Quellen: [Unb08c], [Bha99], [FV07], [FK06])Die beiden Funktionen in Verilog heißen function und task. Wie bereits erwahnt sinddie Funktionen in VHDL und Verilog sehr ahnlich. Im Grunde entspricht die Verilogfunction der VHDL function und die Verilog task der VHDL procedure. Im Beispielder task Listing 9 und der function Listing 10 ist diese Ahnlichkeit bereits zu erkennen.
Listing 9: Aufbau einer task
task taskName ;d e c l a r a t i o n ;
statement ;endtask
14
Wie die VHDL procedure ist bei der Verilog task eine Zeitverzogerung moglich, ebensowie die Argumente den Modus INPUT als auch OUTPUT annehmen durfen. Die taskist ebenfalls ein eigenstandiger Aufruf und kann entsprechend aufgerufen werden, z.B.mit
”tsk(out1,in1);“. Hierbei wurde der Ruckgabewert in out1 stehen, somit ist out1
hier ein expliziter Ruckgabewert.
Listing 10: Aufbau einer function
function [ range ] functionName ;d e c l a r a t i o n ;
statement ;endfunction
Wahrend die task im Grunde keinen Unterschied zur VHDL procedure aufweist, gibtes bei der Verilog function leichte Unterschiede zur VHDL function. So hat die Verilogfunction die Option ein range zu setzen, womit interne Eigenschaften des Ruckgabe-wertes und die Wortbreite definiert werden kann. Sollte das range nicht gesetzt werden,dann wird als Default-Wert ein Ruckgabewert von einem Bit breite verwendet. Die Ve-rilog function darf zwar ebenfalls keine Zeitverzogerung aufweisen, aber die Verilogfunction muß mindestens ein INPUT Argument bekommen, allerdings darf auch beiVerilog kein Argument als OUTPUT deklariert sein. Ein weiterer Unterschied zu VHDLbietet Verilog auch im Ruckgabewert, denn dieser ist hier keine explizit verwendete Va-riable, sondern er ersetzt den Funktionsnamen und ist somit ein direkter Ruckgabewert.Das heißt also, bei einem Funktionsaufruf in Verilog, mit RWert= fkt(in1) wurde dasErgebnis durch die Zuweisung der Funktion mit dem Namen fkt in der Variable RWertzu finden sein und nicht wie bei VHDL uber die Returnvariable in RWert landen. Wie andiesem Beispiel auch zu erkennen ist, ist auch in Verilog die function keine eigenstandi-ge Anweisung und muß entsprechend mit einer anderen Anweisung aufgerufen werden,was wieder equivalent zur VHDL function ist.
5 Modularisierung
Die Verwendung von Hardwarebeschreibungssprachen zu Zwecken der Simulation undSynthetisierung von Schaltkreisen macht die Aufteilung des Systems in verschiedeneModule nicht zwingend erforderlich. In den meisten Fallen wird aber durch die Mo-dularisierung die Gesamtstruktur leichter uberschaubar, was die Programmierung undFehlersuche erleichtert.Auch bei der Weiterentwicklung eines Systems vom Grundentwurf auf der Systemebenezu einem synthetisierbaren Entwurf auf Gatterebene kann die Modularisierung helfen.Da Module miteinander nur uber ihre Schnittstellen kommunizieren, ist es moglich,einzelne Module bereits in hardware-nahere Entwicklungsebenen zu
”ubersetzen“, also
dort mit dem gleichen Verhalten neu zu modellieren.
15
5.1 Entwicklungsebenen
Es ist in beiden Sprachen moglich, ein Modul sowohl rein auf einer der Entwicklungs-ebenen zu verfassen, als auch in ein und demselben Modul Elemente der verschiedenenEbenen zu mischen, zum Beispiel Gatter von der Gatterebene und Prozesse von derSystemebene.
Systemebene Die Modellierung beginnt oft auf dieser Ebene, auf der das ganze Systemmit der Macht einer hoheren Programmiersprache modelliert werden kann. Die Systeme-bene eignet sich fur die Simulation von Entwurfen, um ubersichtlichen Code schnell aufgewunschtes Verhalten zu uberprufen. Will man dagegen eine wirklichkeitsnahe Simulati-on erhalten oder Schaltkreise synthetisieren, muss man das Modul auf hardware-naherenEbenen modellieren.
Register-Transfer-Ebene Diese ist im Befehlsumfang bereits sehr eingeschrankt, sosind Schleifen und Abfragen nicht mehr moglich, es stehen aber noch die Benutzungverschiedener Datentypen, die Zuweisung von Werten in sequentieller oder nebenlaufigerWeise und die Verwendung von Operatoren zur Verfugung.
Gatterebene Hier steht nur noch eine Liste von Gattern mit ihren Ein- und Aus-gabeports zur Verfugung. Dabei muss man sich bei VHDL auf die bekannten Gatterbeschranken, wogegen bei Verilog auch eigene Gatter definiert werden konnen, woraufweiter unten noch eingegangen wird. Ein Modul auf Gatterebene ermoglicht die Synthe-tisierung von Schaltkreisen und bei Simulationen wirklichkeitsnahere Resultate als beihardware-ferneren Ebenen. Um den Uberblick zu behalten, empfiehlt sich die Verwen-dung einer graphischen Oberflache, auf der die Gatter angeordnet werden konnen.
Schaltkreisebene Diese wird nur noch wenig verwendet, weil Synthetisierung bereitsauf Gatterebene moglich ist und eine Simulation wegen des hohen Zeitaufwands beikomplexen Systemen nicht mehr praktiziert wird.
5.2 Modulaufruf durch andere Module
In beiden Sprachen ist es moglich, in einem Modul ein anderes aufzurufen, wie Bhaskerin seinen Buchern ausfuhrt[Bha98][Bha99]. Jedes Modul hat bestimmte Ein- und Ausga-beports, die bei seiner Deklaration festgelegt werden. Durch diese Ports kann es mit demAufrufer kommunizieren. Deklarationen von Modulen durfen nicht geschachtelt werden,sondern mussen voneinander getrennt sein.
5.2.1 Modul bei Verilog
Bei Verilog ist ein Modul auch als solches bekannt (module). Zum Aufruf ist lediglichnotig, dass das aufgerufene Modul deklariert wurde und benannt wurde.
16
Listing 11: Verilog Volladdierer ruft Halbaddierer auf
module f u l l a d d e r ( a , b , c in , sum , c out ) ;
input a , b , c i n ; // h i e r s ind a l l e Werteoutput sum , c out ; // j e w e i l s e in Bit b r e i t
reg tmp1 , tmp2 , tmp3 ;
h a l f a d d e r ha1 ( a , b , tmp1 , tmp2 ) ; // Aufruf von ha l f a d d e rh a l f a d d e r ha2 ( tmp1 , c in , sum , tmp3 ) ; // sum e r g i b t s i c h
own or or1 ( c out , tmp2 , tmp3 ) ; // s e l b s t d e f i n i e r t e s ODER// mit Ausgabewert c ou t
endmodule
5.2.2 Komponente bei VHDL
Bei VHDL muss ein Modul vor einem Aufruf nicht nur als Architektur einer Entitydeklariert werden, es muss auch in der aufrufenden Architektur zuerst als Komponentedeklariert werden; danach kann diese Komponente instantiert werden.
Listing 12: VHDL Volladdierer ruft Halbaddierer auf
entity Full Adder i sport ( a , b , c i n : in BIT , sum , c out : out BIT ) ;
end Full Adder ;
architecture Full Adder of Full Adder i s
component Half Adderport (HAA, HAB: in BIT ; HASUM, HACOUT: out BIT ) ;
end component ;
component Own Orport (OZ: out BIT ; OA, OB: in BIT ) ;
end component ;
signal tmp1 , tmp2 , tmp3 : BIT ;
begin// Aufruf von Half Adder
HA1: Half Adder port map ( a , b , tmp1 , tmp2 ) ;HA2: Half Adder port map ( tmp1 , c in , sum , tmp3 ) ;
// sum e r g i b t s i c h
OR1: Own Or port map ( c out , tmp2 , tmp3 ) ;
17
// s e l b s t d e f i n i e r t e s ODER mit Ausgabewert c out
end Full Adder ;
5.3 Wiederverwendbarkeit
Bei VHDL konnen Deklarationen laut Bhasker[Bha98] auch zu Paketen (package) zu-sammmengefasst werden, die man mit use in den Code einbinden kann:
Listing 13: VHDL Package als Pseudocode
package packageName i s[ package−item−d e c l a r a t i o n s ]
end [ package ] [ packageName ] ;
In einem Paket konnen Unterprogramme, Typen, Subtypen, Konstanten, Signale, Va-riablen, Files, Komponenten und Attribute deklariert, Attribute und Abbruchkriterien(disconnection) spezifiziert sowie Nutzungen (use clause) festgelegt werden.
Listing 14: VHDL Beispielpaket Synth Pack
package SYNTH PACK i sconstant LOW2HIGH: TIME := 20 ns ;type ALU OP us (ADD, SUB, MUL, DIV, EQL) ;attribute PIPELINE : BOOLEAN;type MVL i s ( ’U’ , ’ 0 ’ , ’ 1 ’ , ’Z ’ ) ;type MVL VECTOR i s array (NATURAL range <>) of MVL;subtype MY ALU OP i s ALU OP range ADD to DIV ;component NAND2
port (A, B: in MVL; C: out MVL) ;end component ;
end SYNTH PACK;
Dieses Paket ist vollstandig und kann mit “use WORK.SYNTH PACK.all“ eingebundenwerden. Pakete, die Unterprogramme deklarieren oder Konstanten zuruckhalten, sinddagegen unvollstandig:
Listing 15: VHDL Beispielpaket Program Pack
use WORK.SYNTH PACK. a l l ; −− Al l e Dek lara t ionen aus SYNTH PACK−− mit e in f u gen
package PROGRAMPACK i sconstant PROP DELAY: TIME; −− zu r u c k geha l t ene Konstantefunction ”and” (L , R: MVL) return MVL;procedure LOAD ( signal ARRAY NAME: inout MVL VECTOR;
START BIT, STOP BIT , INT VALUE: in INTEGER) ;end PROGRAMPACK;
18
Fur solche Falle wird ein Paketkorper notig, der denselben Namen wie das Paket hatund die zuruckgehaltenen Konstanten und den eigentlichen Programmkorper der Unter-programme enthalt.
Listing 16: VHDL Package Body als Pseudocode
package body packageName i spackage−body−item−d e c l a r a t i o n s
end [ package body ] [ packageName ] ;
In einem Paketkorper konnen Unterprogrammkorper, vollstandige Konstantendeklara-tionen und Deklarationen von Unterprogrammen, Typen, Subtypen und Files enthaltensein; auch konnen auch hier mit use clauses andere Pakete mit eingebunden werden.
Listing 17: VHDL Beispielpaketkorper Program Pack
package body PROGRAMPACK i suse WORK.TABLES. a l l ;constant PROP DELAY: TIME := 15 ns ;function ”and” (L , R: MVL) return MVL i sbegin
return TABLE AND(L , R) ;−− TABLE AND wurde im Paket TABLES d e f i n i e r t
end ”and” ;
procedure LOAD ( signal ARRAY NAME: inout MVL VECTOR;START BIT, STOP BIT , INT VALUE: in INTEGER) i s
−− Lokale Dek lara t ionen h i e r e in f u genbegin−− Verhal ten der Prozedur h i e r e in f u gen
end LOAD;end PROGRAMPACK;
6 Zeitverhalten
6.1 Verilog
Bhasker beschreibt das Zeitverhalten von Verilog in seinem”Verilog Primer“[Bha99].
6.1.1 Compilerdirektive ’timescale
Innerhalb des Codes bezieht sich Verilog nur auf Zeiteinheiten; der genaue physikalischeWert wird erst durch die Compilerdirektive ’timescale festgelegt:
� ’timescale Zeiteinheit / Prazision
� z.B. ’timescale 100 ns / 10 ns
19
Erlaubt sind dabei die Zeiteinheiten s, ms, us, ns, ps, fs. Die Direktive muss mindestenseinmal vor dem ersten Modul angegeben werden; sie gilt dann fur alle folgenden Module,es sei denn es wurde eine neue Direktive dort festgelegt werden; ab dort ware fur allefolgenden Module diese neue Direktive gultig. Prazision legt die kleinste Zeiteinheit fest,mit der im System gerechnet wurde; alle Zeitangaben waren Vielfache dieses Werts undmussten im Notfall entsprechend gerundet werden.
6.1.2 Systemebene
Code auf der Systemebene erscheint immer als Teil von always- und initial-Statements:
Listing 18: Verilog always- und initial-Statements
module c l o ck gen ( s t op s i gn ) ; // Veri log−Clock−Erzeugung
input s t op s i gn ;reg c l o ck ;
i n i t i a lbegin
c l o ck = 1 ’ b0 ; // c l o c k auf 0 i n i t i a l i s i e r tend
always // c l o c k s c h a l t e t a l l e 10 Einhe i tenbegin // zwischen 1 und 0 um; d i e s e l b e
#10 c lo ck = ˜ c l o ck ; // Tak t f l anke w i ed e rho l t s i c h so nachend // 2 Umschaltungen (20 Einhe i ten )
i n i t i a lbegin
#1000 $ f inish ; // c l o c k wird 1000 Einhe i tenend // nach dem Sta r t a b g e s c h a l t e t
always@ ( s top s i gn )begin
$ f inish ; // auch b e i einem event s t o p s i gnend // wird d i e c l o c k a b g e s c h a l t e t
endmodule
Always- und initial-Statements sind die grundlegenden Elemente der Systemebene. In-nerhalb dieser konnen auch case- und if-else-Anweisungen und Schleifen verschiedenerArt (for, while, repeat, forever) ausgefuhrt werden. Always- und initial-Statements wer-den einmal beim Start nebenlaufig angestoßen, die always-Statements werden jedochwieder neu begonnen, wenn sie beendet sind. Oft sind always-Statements darum anKonditionen gebunden, beispielsweise an die steigende Flanke eines clock-Signals, undwerden erst in solchen Fallen weiter ausgefuhrt.
20
6.1.3 Verzogerungen
Code wird normalerweise sofort ausgefuhrt, kann aber auf verschiedene Arten verzogertwerden:
Listing 19: Verilog Verzogerungen
i n i t i a lbegin
#5 r s t = 1 ’ b0 ; // Ausfuhrung wird um 5 Ze i t e i n h e i t e n v e r z o g e r tr s t = #5 1 ’ b0 ; // Der Wert wird g e s p e i c h e r t und
// nach 5 Einhe i ten ubernommenQ = @(posedge Clk ) D; // Erst b e i s t e i g end e r Tak t f l anke
// von Clk werden d ie Daten ubernommenend
Steht die Verzogerung zum Zeilenbeginn, wird erst nach Ablauf dieser Zeit auf die altenDaten zugegriffen, um sie zuzuweisen, steht sie dagegen auf der rechten Seite der Zuwei-sung, werden die alten Daten sofort zwischengespeichert, aber erst nach der Verzogerungzugewiesen.
6.1.4 Blockierende und nichtblockierende Zuweisungen
Listing 20: Verilog Nichtblockierende Zuweisungen
always @(posedge c l o ck )begin
a <= b ;end
always @(posedge c l o ck )begin
b <= a ;end
Diese nichtblockierenden Zuweisungen sorgen dafur, dass a und b ihre Werte tauschen.Dabei wird am Anfang jeweils der Wert gelesen, temporar gespeichert und am Endejeweils zugewiesen. Blockierende Zuweisungen mit = hatten zur Folge, dass die Befehlejeweils sofort ausgefuhrt werden, das heißt, eine Zuweisung ist bereits beendet, bevordie zweite beginnt. Die Zuweisungen haben aber hier keine vorbestimmte Reihenfolge,so dass es am Ende von der Hardware abhangen wurde, welcher Wert angenommen wird,was unbedingt zu vermeiden ist.
Listing 21: Verilog Parallele und sequentielle nichtblockierende Zuweisungen
i n i t i a lbegin
#15 a <= 1 ; // 15 Einhe i ten nach dem Sta r t wird a zu 1#10 b <= 1 ; // 25 Einhe i ten nach dem Sta r t wird b zu 1
21
end
in i t i a lbegin
c <= #20 2 ; // 20 Einhe i ten nach dem Sta r t wird c zu 2d <= #10 2 ; // 10 Einhe i ten nach dem Sta r t wird d zu 2
end
Im ersten Fall wird die Ausfuhrung der Statements 15 und 10 Einheiten spater begon-nen als bei den jeweiligen Vorgangern, wobei sich die Verzogerungen summieren. Imzweiten Fall beginnt dagegen die Ausfuhrung aller Statements jeweils sofort, aber dieUbernahme der neuen Daten wird verzogert; da die Ausfuhrung gleichzeitig beginnt, istdie Ausfuhrungsreihenfolge von der Hohe der jeweiligen Verzogerung abhangig, wobeiim Beispiel d seinen neuen Wert fruher erhalt als c.
6.1.5 Gabelung
Bei einer Gabelung konnen auch normalerweise blockierende Zuweisungen parallel aus-gefuhrt werden:
Listing 22: Verilog Gabelung
i n i t i a lbegin
#5 a = 1 ; // 5 Einhe i ten vergangen#5 b = 1 ; // 10 Einhe i ten vergangenfork
#1 c = 2 ;#3 d = 3 ;#5 e = 4 ;#7 f = 5 ; // l a n g s t e r Be feh l nach 7 Einhe i ten beendet ,
join // zwischen f o r k und j o i n vergehen so v i e l e Einhei ten ,// wie der l a n g s t e Be feh l b e n o t i g t ( h i e r 7) , a l s o s ind// b e i j o i n insgesamt 17 Einhe i ten vergangen
#3 a = e ; // 20 Einhe i ten vergangenend
6.1.6 Kontinuierliche Zuweisungen
Mit assign (und force) kann man Werte kontinuierlich zuordnen (assign bei Registern,force auch bei Nets, die Spannungszustande auf Kabeln modellieren). Bis zum deassign(oder release bei Nets) sind diese Werte dann kontinuierlich zugeordnet und konnen pereinfacher Zuweisung mit = oder <= nicht geandert werden.
� assign Z=A
� assign A=B
22
Im Beispiel hat die Reihenfolge der Anweisung keinen Einfluss auf das Resultat, da beideAnweisungen kontinuierlich durchgefuhrt werden. Eine Anderung von B hat zur Folge,dass A den neuen Wert von B annimmt, und direkt darauf auch Z den neuen Wert vonA, so dass A, B und Z den gleichen Wert annehmen. Im Vergleichsfall mit einfachenZuweisungen wurden zwar A und B den gleichen Wert annehmen, Z dagegen wurdebeim ursprunglichen Wert von A verbleiben.
6.1.7 Gatterverzogerungen
Wahrend man Gatterverhalten nicht andern kann, kann man die Verzogerung einstellen,mit der das Gatter auf Anderungen reagiert:
Listing 23: Verilog Gatteraddierer mit Verzogerungen
module gate adder ( a , b , sum , c out ) ;
input a , b ;output sum , c out ;
and #4 ( c out , a , b ) ;xor #(3 , 4 , 5) (sum , a , b ) ;
endmodule
Bei Angabe eines Verzogerungswerts gilt dieser fur alle Schaltungen des Gatters, beizweien gilt der erste fur steigende und der zweite fur fallende Flanken, bei dreien giltaußerdem der dritte fur das Abschalten des Gatters.
6.2 VHDL
In seinem”VHDL Primer“[Bha98] beschreibt Bhasker das Zeitverhalten von VHDL.
6.2.1 Prozesse
Prozesse sind in VHDL auf der Systemebene angesiedelt und haben eine Sensitivitatslistemit Werten, auf deren Anderung hin sie starten:
Listing 24: VHDL Add-Or-Invert als sequentieller Prozess
entity AOI i sport (A, B, C, D: in BIT , Z : out BIT ) ;
end AOI ;
architecture AOI Sequentia l of AOI i sbegin
process (A, B, C, D)variable TEMP1, TEMP2: BIT ;
beginTEMP1 := A and B;
23
TEMP2 := C and D;TEMP1 := TEMP1 or TEMP2;Z <= not TEMP1;
end process ;end AOI Sequentia l ;
Prozesse enthalten sequentiellen Code. Die Zuweisung mit <= kann auch bei VHDLparallele nichtblockierende Zuweisungen ermoglichen. In Prozessen kann man auch aufFlanken reagieren:
� if CLK = ’1’ and CLK’EVENT then
� ...
� end if;
6.2.2 Kontinuierliche Zuweisungen
Kontinuierliche Zuweisungen finden in VHDL außerhalb von Prozessen statt:
Listing 25: VHDL Add-Or-Invert als kontiniuierliche Zuweisung
entity AOI i sport (A, B, C, D: in BIT , Z : out BIT ) ;
end AOI ;
architecture AOI Concurrent of AOI i sbegin
Z <= not ( (A and B) or (C and D) ) ;end AOI Concurrent ;
6.2.3 Verzogerungen
Verzogerungen kann man in VHDL einfach mit Angabe der Zeit erklaren:
� A <= B after 20 ns;
Außerdem kann man auf verschiedene Ereignisse warten:
� wait on A, B, C;
� wait until A = B;
� wait for 20 ns;
� wait on CLOCK for 20 ns;
� wait until SUM > 100 for 50 ns;
� wait on CLOCK until SUM > 100;
24
7 Operatoren
Weil die Sprachen unabhangig voneinander entwickelt wurden, sind die Operatoren we-gen der Anforderungen zwar ahnlich, im Einzelfall jedoch zum Teil sehr verschieden. Sogibt es nur in VHDL verschiedene Schiebeoperatoren und arithmetische Operationen mitGleitpunkt-Zahlen, wahrend Verilog mehrere Arten von logischen Operatoren und denkonditionalen Operator kennt. Beide HDLs verwenden folgende Arten von Operatoren:
� Arithmetische Operatoren
� Logische Operatoren
� Vergleichsoperatoren
� Schiebeoperatoren
� Konkatenationsoperatoren
� Konditionaler Operator (nur Verilog)
7.1 VHDL
Laut Bhasker[Bha98] ist bei VHDL die Prioritat der Operatoren wie folgt, von hochsterzu niedrigster Prioritat:
1. Absolutwert abs und Exponentiation ** (arithmetisch) und not(logisch)
2. Multiplikationsoperatoren *, /, rem und mod (alle arithmetisch)
3. Additionsoperatoren +, - (arithmetisch) und & (Konkatenation)
4. Schiebeoperatoren sll, srl, sla, sra, rol und ror
5. Relationale Operatoren >, >=, <=, <, = und ! =
6. Logische Operatoren and, or, nand, nor, xor und xnor
7.1.1 Arithmetische Operatoren
Die Operatoren der Grundrechenarten +, -, * und / konnen fur viele Datentypenverwendet werden, solange beide Operanden vom gleichen Typ sind, von ganzen undGleitpunkt-Zahlen bis zu Bitvektoren, die dann als Binarzahlen interpretiert werden.
� “0011“ + “0001“ = “0100“ // Addition von Bitvektoren als Binarzahlen
Ebenfalls ist Multiplikation definiert, wenn ein Operand ein”physikalischer Wert“ (ein
Wert mit Einheit, zum Beuspiel 1 ns) und der andere eine ganze oder Gleitpunkt-Zahlist; das Resultat ist wiederum ein physikalischer Wert. Division ist auch definiert, wennder erste Operand ein physikalischer Wert und der zweite entweder ein physikalischerWert derselben Art oder eine ganze oder Gleitpunkt-Zahl ist:
25
� 10 ns * 100 = 1 us
� 1 us / 10 ns = 100
� 1 ms / 1000 = 1 us
Absolutwert abs ist definiert fur alle numerischen Datentypen; + und - konnen ebenfallsunar als Vorzeichen fur diese Datentypen verwendet werden.
� abs(-3) = 3
Bei Exponentiation ** kann der erste Operand eine ganze oder Gleitpunkt-Zahl sein,der zweite muss eine ganze Zahl sein. Das Resultat ist vom Typ des ersten Operanden.
� 0.5 ** 4 = 0.0625
� 4 ** 0.5 // nicht erlaubt
Bei mod (Modulo) und rem (Rest) handelt es sich um den Rest bei der Division zweierganzer Zahlen, wobei dieser Rest vom Divisor beziehungsweise Dividenden ubernommenwird:
� 5 mod 3 = 2; 5 mod -3 = -1; -5 mod 3 = 1; -5 mod -3 = -2
� 5 rem 3 = 2; 5 rem -3 = 2; -5 rem 3 = -2; -5 rem -3 = -2
7.1.2 Logische Operatoren
Diese konnen zum Berechnen von Bits, Bitvektoren und Boolean-Werten verwendet wer-den; der Datentyp beider Operanden muss dabei ubereinstimmen (bei Bitvektoren auchdie Lange). Bei Verwendung mehrerer logischer Operatoren muss auf die Klammerset-zung geachtet werden, da mit Ausnahme von not alle logischen Operatoren die gleichePrioritat haben:
� ’1’ and TRUE // nicht erlaubt, da verschiedene Datentypen der Operanden
� “101“ and “110“ or “001“ // nicht erlaubt, Klammersetzung notig
� “101“ and (“110“ or “001“) = “101“
7.1.3 Vergleichsoperatoren
Die Vergleichsoperatoren sind fur alle Standarddatentypen definiert, wobei Operandenvom Datentyp ubereinstimmen mussen. Das Resultat ist immer Boolean (true oder fal-se). Bei Bitvektoren werden dabei die Bits lexikographisch von links nach rechts in derangegebenen Reihenfolge verglichen:
� (“10“ > “0111“) = TRUE // weil hier bereits das erste Bit entscheidet
26
7.1.4 Schiebeoperatoren
Bei allen Schiebeoperatoren ist der erste Operand ein Bitvektor und der zweite eineGanzzahl, die die Stellen angibt, um die der Bitvektor verschoben werden soll. Beimlogischen und arithmetischen Schieben verschwindet das herausgeschobene Bit, wobeibeim logischen Schieben jeweils eine Null eingeschoben wird. Beim arithmetischen Schie-ben dagegen wird der Bitwert an der Einschiebestelle kopiert. Beim Rotieren wird dasherausgeschobene Bit jeweils auf der anderen Seite wieder eingeschoben.
� “011“ sll 1 = “110“ (logisches Schieben nach links)
� “011“ srl 1 = “001“ (logisches Schieben nach rechts)
� “011“ sla 1 = “111“ (arithmetisches Schieben nach links)
� “011“ sra 1 = “001“ (arithmetisches Schieben nach rechts)
� “011“ rol 1 = “110“ (Rotieren nach links)
� “011“ ror 1 = “101“ (Rotieren nach rechts)
7.1.5 Konkatenationsoperator
Der Konkatenationsoperator & hangt Elemente oder Ketten aneinander; das Resultatkann ein String oder im Spezialfall ein Bitvektor sein:
� “BA“ & “LL“ = “BALL“
� ’0’ & ’1’ = “01“
7.2 Verilog
Laut Bhasker kennt Verilog[Bha99] neben arithmetischen, logischen, Vergleichs-, Schiebe-und Zusammenfugungsoperatoren noch den konditionalen Operator.
7.2.1 Arithmetische Operatoren
Verilog hat ahnliche arithmetische Operatoren wie VHDL; allerdings haben die Ope-ratoren fur Absolutwert und Exponentiation keine Entsprechung in Verilog. Verilog’sModulo entspricht mehr VHDL’s REM, da es das Vorzeichen des Dividenden verwen-det, wahrend VHDL’s MOD das Vorzeichen des Divisors ubernimmt.
� Multiplikation (*), Division (/) und Modulo (%)
� Addition (+) und Subtraktion (-)
Verilog erlaubt auch das Rechnen mit Bitvektoren, die dabei als Zahlen im Binarsysteminterpretiert werden. Ist dabei eins der Eingabebits unbekannt (x) statt 1 oder 0, wirddadurch auch das gesamte Resultat unbekannt(x).
� 4’b1x01 + 4’b0001 = x
27
7.2.2 Logische Operatoren
Wahrend VHDL nur eine Sorte logischer Operatoren verwendet, wobei das Resultatdenselben Datentyp hat wie beide Operanden, gibt es in Verilog drei verschiedene Sorten:
� Logische Operatoren: Eingabe 1-2 Operanden, Ausgabe 1 Bit
Hier werden die Operanden als 0 bei Wert 0 und als 1 bei allen anderen Werten inter-pretiert, und die Operation dann durchgefuhrt.
� Bitweise Operatoren: Eingabe 1-2 Bitvektoren, Ausgabe 1 Bitvektor
Bitweise Operatoren funktionieren wie bei VHDL, indem sie die Operationen an allenBits der Operanden unabhangig voneinander durchfuhren.
� Reduktionsoperatoren: Eingabe 1 Bitvektor, Ausgabe 1 Bit
Bei Reduktionsoperatoren ist der Eingabevektor der einzige Operand. Zur Berechnungdes Ergebnisses wird der Operator auf alle Bits des Bitvektors angewendet. Ist einsder Eingabebits unbekannt (x) statt 1 oder 0, kann auch das Resultat unbekannt sein(bei bitweisen Operatoren das jeweilige Bit des Resultats), muss aber nicht (bei & gilt0&x=0, bei | gilt 1|x=1).
� &4’b1011 (& als Reduktionsoperator) = 1&0&1&1 (& als normales AND) = 0
7.2.3 Vergleichsoperatoren
Verilog kennt zwei Sorten von Vergleichsoperatoren (statt einem bei VHDL):
� Relationsoperatoren <, <=, >=, >
� Gleichheitsoperatoren ==, !=, ===, !==
Bei Relationsoperatoren ist das Ergebnis 1 oder 0 bei eindeutig bestimmten Eingabe-werten; bei Eingabewerten mit unbekannten (x) oder hochohmigen (z) Bits wird dasErgebnis zu x. Bei den Gleichheitsoperatoren verhalten sich == und != ebenso: 1 beiGleichheit eindeutiger Bits, 0 bei Ungleichheit und x bei Vorhandensein von x oder z.=== und !== dagegen vergleichen die Eingabewerte auf absolute Gleichheit: ist jedesBit, inklusive etwaiger x und z, bei beiden Operatoren gleich, ist das Resultat 1 bei ===und 0 bei !==, in allen anderen Fallen 0 bei === und 1 bei !==.
7.2.4 Schiebeoperatoren
Bei Schiebeoperatoren gibt es in Verilog nur eine Sorte, die den logischen Schiebeopera-toren entspricht. Der erste Operand, ein Bitvektor, wird dabei um den Wert des zweitenOperators verschoben, wobei mit Nullen aufgefullt wird. Die Operatoren heissen hier<< statt SLL und >> statt SRL.
28
7.2.5 Zusammenfugungsoperatoren
Zusammenfugungsoperatoren fugen die Operanden zu langeren Bitvektoren zusammen;zur Benutzung mussen jedoch die Operanden eine festgelegte Lange haben. Es gibt zweiSorten, Anhange- und Replikationsoperatoren. Zum Beispiel sei A=2’b01 und B=3’b111.Dann lassen sich neue Bitvektoren wie folgt zusammensetzen:
� Anhangeoperator { }: C = { A, B, A } = 7’b0111101
� Replikationsoperator { { } }: D = { 2{A}, B } = 7’b0101111
7.2.6 Konditionale Operatoren in Verilog
Der konditionale Operator ? : wirkt wie eine IF-THEN-ELSE-Anweisung. Er hat dreiOperanden, von denen der erste ein Bit ist; ist dieses Bit 1, ist das Ergebnis der zweiteOperand, ist es 0, ist das Ergebnis der dritte Operand. Ist das Bit x, werden zweiterund dritter Operand bitweise verglichen: An den Stellen, an denen beide Operandenubereinstimmen, nimmt auch das Ergebnis diesen Wert an, an allen anderen ist es x.
� 1’b1 ? 4’b0110 : 4’b1100 = 4’b0110
� 1’b0 ? 4’b0110 : 4’b1100 = 4’b1100
� 1’bx ? 4’b0110 : 4’b1100 = 4’bx1x0
8 Konstrukte auf Gatterebene
Auf Gatterebene erlaubt Verilog laut Bhasker die Erstellung eigener Gatter[Bha99],wahrend VHDL diese Moglichkeit nicht bietet[Bha98] auf die bekannten Gatter zuruck-gegriffen werden muss.
8.1 User Defined Privileges in Verilog
In Verilog konnen neue Gatter, sogenannte User Defined Privileges (UDP), erstellt wer-den. Fur diese gilt immer, dass die Eingabewerte eine im UDP bestimmte Anzahl vonBits sind, die Ausgabe dagegen ist immer ein einziges Bit. Mit Hilfe einer Wahrheitsta-belle in der Deklaration kann der Ausgabewert dann bestimmt werden.
8.1.1 Kombinatorische UDP
Bei kombinatorischen UDP ist der Ausgabewert immer direkt von den Eingabewer-ten und nichts anderem abhangig. Der Ausgabewert wird dabei einer Wahrheitstabelleentnommen. In dieser Wahrheitstabelle sollten alle Kombinationen der Eingabewerteabgedeckt werden; bei nicht abgedeckten Kombinationen der Eingabewerte ergibt sichals Ruckgabewert x. Das Fragezeichen in der Wahrheitstabelle steht fur ’0, 1 oder x’.
29
Listing 26: Verilog UDP Multiplexer
primitive udp mux( out , s e l , a , b ) ;
output out ; // Por tdek l a ra t i oneninput s e l , a , b ;
table// s e l a b : out
1 0 ? : 0 ;1 1 ? : 1 ;0 ? 0 : 0 ;0 ? 1 : 1 ;x 0 0 : 0 ;x 1 1 : 1 ;
endtable
endprimitive
8.1.2 Sequentielle UDP
Bei sequentiellen UDP gibt es wichtige Unterschiede zu kombinatorischen UDP:
� Der neue Ausgabewert ist nicht nur von den Eingabewerten sondern auch vom bis-herigen Ausgabewert abhangig. Der Ausgabewert wird hier als Zustand bezeichnet.
� Der Zustand wird in einem Register festgehalten; dieser Registerwert kann auchinitialisiert werden.
� Die Eingabewerte konnen als Werte oder als Ubergange (Flanken) in der Tabelleerscheinen.
� Alle moglichen Kombinationen der Eingabewerte mussen in der Wahrheitstabelleangegeben werden, um unbekannte Ausgabewerte (x) zu vermeiden.
Listing 27: Verilog UDP Flipflop
primitive e d g e d f f (q , d , c lock , c l e a r ) ;
// Dek lara t ionenoutput q ;reg q ;
input d , c lock , c l e a r ;
// S e q u e n t i e l l e I n i t i a l i s i e r u n gi n i t i a l
q = 0 ;
30
table// d c l o c k c l e a r : q : q+
? ? 1 : ? : 0 ; //wenn c l e a r =1, output=0? ? (10) : ? : − ; //Zustand ha l t en1 (10) 0 : ? : 1 ; // ubernehme d be i f a l l e n d e r0 (10) 0 : ? : 0 ; //Flanke von c l o c k? (1 x ) 0 : ? : − ; //Zustand b e i Ubergang zu x ha l t en? (0? ) 0 : ? : − ; //Zustand b e i s te igendem? ( x1 ) 0 : ? : − ; // Ubergang von c l o c k ha l t en
( ?? ) ? 0 : ? : − ; //Zustand ha l t enendtable
endprimitive
9 Beispielprogramm Manchester Code
Als verdeutlichende Beispiele sollen nun zwei Umsetzungen des Manchester Codes vorge-stellt werden, welche in Anlehnung an die UART Funktion Manchester Code encodierenund decodieren. Dabei wird bereits fertiger Source-Code von XILINX verwendet. DieImplementierung des Manchester Code ist dabei in zwei Teile unterteilt: Den Encoder-teil und den Decoderteil. Da die jeweiligen Implementierungen relativ umfangreich sind,wird hier fur VHDL nur der Encoderteil und fur Verilog der Decoderteil vorgestellt.
9.1 Grundlagen des Manchester Code
Digitale Systeme verwenden laut [XIL08] in der seriellen Ubertragung meistens denNon Return to Zero Code (NRZ) zur Ubertragung von binaren Signalen. Der NRZ,welcher auch auf der RS232-Schnittstelle am PC eingesetzt wird, ist mit einem Takt ge-koppelt und hat die simple Kodierung
”High Pegel“ fur logische Eins und
”Low Pegel“
fur logisch Null. Das Verwenden eines Takt Signals wird in der Praxis aber oft durch dieVerwendung von Stop-Bits umgangen.8
Beim Manchester Code (MC) werden immer zwei Signale fur einen binaren Wertubertragen. Sie bilden sich durch eine XOR-Verknupfung zwischen Takt und Daten,was zu einer doppelt so hohen Pegel-Anderung wie beim NRZ fuhrt. Zum Beispiel wirdaus dem NRZ-Datum 0 ein 10 im MC und aus einer 1 wird 01 im MC. Abb. 3 zeigtauch ein Beispiel der Codierung. Wendet man eine XOR-Verknupfung auf encodiertenMC und den fur das Encoding verwendeten Takt an, gewinnt man das NRZ-Datumzuruck. Der MC sendet also zwei Bit um einen ein Bit Wert zu ubertragen, d.h. NRZ istdoppelt so schnell wie MC. Dennoch ergeben sich fur den MC wichtige Vorteile z.B. beiUbertragungen immer einen Gleichspannungsanteil von Null zu haben. Der Gleichspan-nungsanteil von Null entsteht durch den immer gleich bleibenden Anteil an ausgegebenen
8Hierzu mehr unter www.wikipedia.de/NRZ.
31
Einsen und Nullen. In Abbildung 3 ist der MC und NRZ Code im Verhalten dargestellt.Der Manchester Code benotigt nur fur die Codierung in der Praxis ein Taktsignal undist somit sonst selbsttaktend. Neben der hier verwendeten IEEE 802.3 XOR-Variante,gibt es noch einen Standard nach G.E. Thomas, welcher den MC durch eine XNORVerbindung bildet.
Abbildung 3: Manchester Code und NRZ
UART Die Ubertragung der encodierten Manchester Daten zum Decoder findet seriellstatt und ist mit einem dem UART ahnelnden Start- und Stop-Bit Rahmen versehen.Ein solcher Rahmen ist in Abb. 4 fur eine NRZ Datenubertragung dargestellt. Einesolche Start- und Stop-Bit Konfiguration wurden in einer etwas umfangreicheren Um-setzung einer MC-Datenubertragung auch das Taktauslesen aus dem MC ermoglichen.In dieser Version von Xilinx ist die Start- und Stop-Bit Implementierung jedoch ehervon symbolischer Bedeutung.
32
Abbildung 4: UART Ubertragung mit Frage fur NRZ Daten
9.2 Manchester Encoder in VHDL
9.2.1 Grundsatzlich
Der Manchester Encoder (ME) besteht aus der entity me mit seiner zugehorigen architecturev1. In der Architektur v1 gibt es sechs Prozesse (process) und zwei direkte Zuweisun-gen (direkte kombinatorisch logische Funktionen fur den Datenfluss). Im Folgendem wirdnun auf die Parameter des ME, dessen interne Signale, Programmablauf, Prozesse undMankos der hier behandelten Version eingegangen.Auf diese drei Dateien wird im spateren Verlaufe oft verwiesen. Sie sind Grundlage undErgebnis einer Simulation.
Der Source Code ist in der me.vhd-Datei in Listing 44 ab Seite 56 zu finden. Es handeltsich hierbei aber nicht mehr um den original Code wie er in der Xilinx me.vhd-Datei zu finden ist, sondern um eine geanderte Version davon9.
Die Testbench Datei Test me.VHDTST, welche auf die me Entity zugreift, ist im Listing45 ab Seite 59 zu finden. Auch diese Datei entspricht nicht mehr der Vorgabe vonXilinx, da die originale Version nicht anuf anhieb unter der EDA Altium Designfunktionierte. Dabei wurden neben Anderungen der Bindungen auch die Anzahlder Konstanten des Testvektors fur ca. zwei Testlaufe erhoht.
Die Wavefrom des Manchester Encoder unter Verwendung des Testbench ist in denAbbildungen 7-8 ab Seite 52 dargestellt.
9.2.2 Parameter
Die von Xilinx gelieferte Encoder entity me hat folgende Ein- und Ausgabe Parameterin ihrer port Liste:
9Aus dem original Code wurden die internen Signale Parity, wrn1 und wrn2 geloscht. Des weiterenwurde in dieser Version auch die Anzahl der vom Eingabevektor in MC umgewandelten Daten aufdie volle Breite des Vektors angepasst (von 7 auf 8 Bit).
33
Name Typ Bedeutung
rst in std logic Encoder Resetwrn in std logic Write Register Nextclk16x in std logic 16-facher Taktdin in std logic vector (7 downto 0) NRZ Daten Vectortbre out std logic Transceiver Buffer Register Emptymdo out std logic Manchester Data Out
Tabelle 3: Parameter des Encoders
Der tbre Ausgang signalisiert, dass der Encoder bereit ist, neue Daten zu empfangen.Die den Encoder ausfuhrende Einheit kann also nach Empfang einer 1 an tbre, neueDaten an den ME senden. Neue Daten (din) werden zusatzlich mit einer 1 auf demwrn-Signal gekennzeichnet.
9.2.3 Interne Signale
In der architecture v1 werden neben den Ein- und Ausgabe Parametern noch weitereSignale fur die interne Kommunikation deklariert.
Name Typ Bedeutung
clk1x std logic MC Clockclk1x enable std logic Freigabe Status fur clk1xclkdiv std logic vector (3 downto 0) Clock Counter Registertsr std logic vector (7 downto 0) Ausgabe Vektortbr std logic vector (7 downto 0) Temporarer Vektorno bits sent std logic vector (3 downto 0) Ausgabe Bit Counter Register
Tabelle 4: Interne Signale der architecture v1 des Encoders
Zu den ganzen Taktsignalen: Aus dem Eingabesignal clk16x werden, wenn der Takt-Zahler freigegeben ist (clk1x enable=’1’), die Taktzyklen mit dem clkdiv Registermitgezahlt. Aus dem hochstwertigsten Bit vom clkdiv Register wird dann der Takt furden ME generiert; somit hat ein clk1x Taktzyklus eine Gesamtdauer von 16 clk16xTaktzyklen. Abb. 5 zeigt das Ganze nochmal zur Verdeutlichung als Ausschnitt.
Abbildung 5: Bilden des internen Manchester Takts
34
9.2.4 Interner Ablauf
Beim Ausfuhren des Manchester Encoders bzw. der me Entity, werden immer alle Para-meter aus Tabelle 3 ubergeben. Die ausfuhrende Einheit gibt also den Takt an. Eine ganzsimple Ausfuhrung des ME ist im Aktivitatsdiagramm auf folgender Abb. 6 dargestellt10.Gleich beim ersten Aufruf des ME wird das Reset-Signal rst auf 1 gesetzt, um die inter-nen Signale im ME zuruckzusetzen. Der ME setzt daraufhin sein Ausgangs-Signal tbreauf 1, welches der ausfuhrenden Einheit seine Empfangsbereitschaft signalisiert. Nachdem Empfang von tbre=’1’ kann die ausfuhrende Einheit nun ihren zu encodierendenNRZ-Vektor uber das din-Signal ubertragen. Zusatzlich muss aber noch das wrn-Signalauf 1 gesetzt werden, um dem Encoder zu signalisieren, dass neue Daten jetzt auf din
bereit sind. Der Encoder ubernimmt nun die neuen Daten von din in sein internes tem-porares Register tbr und startet den Takt-Zahler clkdiv durch Setzen der internenZustandsvariablen clk enable auf 1. Der ME bereitet nun das Encodieren vor, wahrenddessen auf dem Ausgabeparameter mdo die durch den jetzt eingeschalteten Takt clk1x
generierte Bitfolge 010 erscheint. Der Teil 10 soll dabei wohl das MC Startbit ahnlichwie im UART darstellen. Aus der Dokumentation von Xilinx ist dazu nicht mehr zuerfahren. Die encodierten Daten liegen ab jetzt immer fur eine definierte Zeit auf mdo.Die Gesamtdauer der Ubertragung des gesamten encodierten Vektors betragt:
8 Manchester Daten · 16 Taktzyklen des clk16x Signal = 128 clk16x Taktzyklen
Hierbei gelten immer 8 clk16x Taktzyklen fur eine Halfte des Manchester Codes. Einclk16x-Taktzyklus besteht aus einem alternierendem Wertebereich von 1 und 0. AmEnde der Ubertragung liegt auf mdo eine permanente 1 an, dies konnte sowohl als halbesStop-Bit als auch ein Idle-State-Signal interpretiert werden11.Hiermit ist das Encoding zu Ende. Wenn noch weitere Vektoren encodiert werden sollen,kann man beliebig oft ab dieser Stelle zum
”Daten senden“ Punkt springen. Der Punkt
Mankos bietet spater noch auf Seite 39 Nachteile und Erweiterungsmoglichkeiten zumME.
Prozesse welche sequentielle Anweisungen durchfuhren, werden hier nur unter Ver-wendung der sensitivity list genutzt. Insgesamt gibt es in der me-Architektur sechsProzesse, welche auch zum Teil auf gleiche Variablen reagieren und somit auch malparallel ablaufen. Im Folgendem werden alle Prozesse mit zugehoriger Erlauterung auf-gefuhrt.
10Ein genaueres Beispiel ergibt sich aus der Testbench in welcher die ubergebenen Signale eingesehenwerden konnen und dem daraus resultierende Simulationsergebnis der Waveform.
11Auch hier keine Information aus der Dokumentation von Xilinx [XIL08].
35
Abbildung 6: Aktivitatsdiagramm einer simplen Ausfuhrung des ME
Listing 28: ME-Prozess fur clk1x enable
process ( r s t , c lk16x , wrn , n o b i t s s e n t )begin
i f r s t = ’1 ’ or s t d l o g i c v e c t o r (n o b i t s s e n t ) = ”1010” then
c l k1x enab l e <= ’ 0 ’ ;e l s i f clk16x ’ event and c lk16x = ’1 ’ then
i f (wrn = ’1 ’ ) thenc l k1x enab l e <= ’ 1 ’ ;
end i f ;end i f ;
end process ;
Enable clock:Hier wird durch das wrn-Signalder Manchester-Takt eingeschaltetclk1x enable<=’1’;. Durch einenReset oder das Ende der Ubertra-gung (no bits sent=’1010’) wirdder Takt ausgeschaltet.
36
Listing 29: ME-Prozess fur clkdiv
process ( r s t , c lk16x , c lkd iv , c l k1x enab l e )begin
i f r s t = ’1 ’ thenc l k d i v <= ”0000” ;
e l s i f clk16x ’ event and c lk16x = ’1 ’ theni f c l k1x enab l e = ’1 ’ then
c l k d i v <= c l k d i v + ”0001” ;end i f ;
end i f ;end process ;
Increment clock:Wenn der Takt angeschaltet ist(clk1x enable=’1’), wird das Re-gister clkdiv fur jeden neuen Takt-zyklus am clk16x um 1 erhoht.Da clkdiv vom Typ std logicvector (3 downto 0) ist, kannes den binaren Wertebereich von0000 bis 1111 annehmen. Aus demhochstwertigem Bit wird in einerstandigen Zuweisungen der eigentli-che Manchester-Takt gebildet. EinReset setzt den clkdiv-Wert auf0000 zuruck.
Listing 30: ME-Prozess fur tbre
process ( r s t , c lk16x , wrn , n o b i t s s e n t )begin
i f r s t = ’1 ’ thentbre <= ’ 1 ’ ;
e l s i f clk16x ’ event and c lk16x = ’1 ’ theni f (wrn = ’1 ’ ) then
tbre <= ’ 0 ’ ;e l s i f ( s t d l o g i c v e c t o r ( n o b i t s s e n t )
= ”0010” ) thentbre <= ’ 1 ’ ;
elsetbre <= ’ 0 ’ ;
end i f ;end i f ;
end process ;
Generate the tbre signal:Das Transmit Buffer Register Empty(tbre) Signal, welches die Empfangs-bereitschaft fur neue Daten signa-lisiert, wird immer zum Zeitpunktno bits sent=’0010’ gesendet. Abdiesem Zeitpunkt liegen auch eco-dierte Daten am mdo Ausgangssignalan. Ein Reset setzt ebenfalls tbre auf1.
Listing 31: ME-Prozess fur tbr
process ( r s t , c lk16x , wrn )begin
i f r s t = ’1 ’ thentbr <= ” 00000000 ” ;
e l s i f clk16x ’ event and c lk16x = ’0 ’ theni f wrn = ’1 ’ then
tbr <= din ;end i f ;
end i f ;end process ;
Load tbr:Sobald mit dem Signal wrn=’1’ ge-kennzeichnete neue zu encodierden-de Daten am din-Register anliegen,werden diese in das Transmit Buf-fer Register tbr ubernommen; tbr
uberschreibt spater tsr, um ausgege-ben zu werden. Beim Reset wird hierauch das tbr-Register auf 00000000gesetzt.
37
Listing 32: ME-Prozess fur tsr
process ( r s t , c lk1x , n o b i t s s e n t , t s r )begin
i f r s t = ’1 ’ thent s r <= ” 00000000 ” ;
e l s i f clk1x ’ event and c lk1x = ’1 ’ theni f s t d l o g i c v e c t o r ( n o b i t s s e n t ) = ”
0001” thent s r <= tbr ;
e l s i f s t d l o g i c v e c t o r ( n o b i t s s e n t )>= ”0010”
and s t d l o g i c v e c t o r ( n o b i t s s e n t )<= ”1010” then
t s r <= t s r (6 downto 0) & ’ 0 ’ ;end i f ;
end i f ;end process ;
Load and shift tsr:Das Transmit Source Register (tsr),vom dem das hochstwertige Bit, al-so Bit 7 zur Generierung des MC ge-nutzt wird, wird hier zum Zeitpunktno bits send=’0001’ mit dem Wertdes tbr uberschrieben. Der Zeit-punkt, an dem das tsr-Register mitden neuen NRZ-Daten uberschriebenwird, ist zugleich Start der Encodie-rung. Nach jedem neuem Taktzyklusclk1x=’1’ wird tsr bitweise vonrechts nach links rotiert, wobei eine0 als neuer Wert hinzukommt. Ro-tiert wird aber nur im Encoding Zeit-raum bzw. wenn no bits sent zwi-schen oder gleich den Werten 0010und 1010 ist, was den Zeitraum derEncodierung beschreibt.
Listing 33: ME-Prozess fur no bits sent
process ( clk1x , r s t , c lk1x enab le ,n o b i t s s e n t )
begini f r s t = ’1 ’ or c l k1x enab l e = ’0 ’ then
n o b i t s s e n t <= ”0000” ;e l s i f clk1x ’ event and c lk1x = ’1 ’ then
i f c l k1x enab l e = ’1 ’ thenn o b i t s s e n t <= n o b i t s s e n t + ”0001
” ;end i f ;
end i f ;end process ;
Calculate no bits sent:Das Signal no bits sent kann auchals Status-Variable angesehen wer-den, wobei sein Wert nicht gleich derAnzahl gesendeter mdo-Bits ist. Eherpassend ist fur den Wertebereich von0 bis 2 Initialisierung und von 2 bis10 Datenubertragung. Das Registerno bits sent wird nur zu Beginn ei-nes clk1x-Taktzyklus bei eingeschal-tetem Takt (clk1x enable=’1’) in-krementiert. Beim Reset oder Endeder Ubertragung wird no bits sent
auf 0000 zuruckgesetzt.
Standige Zuweisungen stellen direkte Verknupfungen (durch XOR, NAND usw.) her.In der Architektur werden nur zwei solcher Zuweisungen gemacht:
Listing 34: ME standige Zuweisungen
−− s e t t i n g up the c l k 1 x2 c lk1x <= c l k d i v (3 ) ;−− Generate Manchester data from NRZ
4 mdo <= t s r (7 ) xor c lk1x ;
38
Zum Befehl in Zeile 2: Um nun aus 16 eingehenden clk16x Taktzyklen einen clk1x
Zyklus zu generieren, werden wie schon im Prozess Increment clock beschrieben imclkdiv Register die clk16x Taktzyklen gezahlt. Da der MC einen NRZ Wert mit zweiWerten darstellt, soll clk1x fur 8 clk16x Takzyklen 0 und fur die anderen 8 Takzyklen1 sein. Die hierfur notige Zuweisung nutzt einfach das hochstwertige Bit vom clkdiv,welches den Bitwechsel von 0 auf 1 eh schon bietet.Zum Befehl in Zeile 4: Der eigentliche MC wird hier mit dem xor-Operator aus clk1x
und dem hochstwertigem Bit vom tsr zugewiesen.
9.2.5 Mankos am ME
1. Das Start Bit ist ein valider Manchester Wert; dies konnte durch einen invalidenWert ersetzt werden, welchen ein Decoder nicht mehr mit Daten verwechseln kann.Ein solches Start-Bit ware etwas lang, dafur aber sicher. Im Gegensatz dazu gibtes auch die Moglichkeit, ein ganz kurzes Start-Bit zu verwenden, um Zeit beimEncoding zu sparen. Der aktuell vom Start Bit verwendete Zeitraum betragt 24clk16x Taktzyklen und wird keinem der beiden oben genannten Varianten gerecht.
2. Die Implementierung eines Stapelbetriebs unter Verwendung des trb Registerskann zu etwas schnellerem Encoding fuhren. Als Beispiel: Der ME speichert nochwahrend des aktuellen Encodings den als nachsten zu encodierenden Vektor intrb und setzt sich eine interne Variable, um spater nach Beenden des aktuellenSendevorgangs gleich den nachsten Vorgang starten zu konnen.
3. Der 16-Fach Takt gibt dem ME zwar viel Spielraum fur die interne Datenverarbei-tung, ist aber fur eine solch simple Implementierung wie diese noch etwas zu hochund konnte gegen einen 8- oder 4-Fach Takt ersetzt werden, was den gesamtenProzess um das 2- oder 4-fache beschleunigen wurde.
9.2.6 Simulation
In der hier verwendeten Simulation unter Verwendung von Altium Design interagiertdie Testbench nicht direkt auf das Verhalten des ME, sondern gibt vorher spezifizierteSignale (Konstanten-Vektor) in einer zyklischen Folge von Aufrufen an den ME. Das istauch der Grund fur erkennbare Latenzen in der Waveform.Die Aufrufe der Testbench sind fur den ersten dargestellten Encoding-Vorgang so auf-gebaut:Zuerst wird ein Reset mit rst=1 gesendet, dann im nachsten clk16x Taktzyklus (hierspater nur noch Zyklus genannt) werden die zu encodierenden Daten an din angelegt,was in diesem Fall die Bitfolge 10101010 ist. Einen Zyklus spater liegen die Daten immernoch an din an, werden jetzt aber noch als zu encodierende Daten mit wrn=1 gekenn-zeichnet. Wieder einen Zyklus spater werden nur noch die Daten an din gesendet, wasaber auch uberflussig ware. Die Testbench macht jetzt nur noch denselben Aufruf fureine vorher bestimmte Zeitspanne.Auf der zweiten ME Waveform (Abb. 8) ist das Startverhalten detaillierter angezeigt.
39
Das Verhalten ist wie im Kapitel 9.2.4 und den darauf folgenden Prozess-Beschreibungenbeschrieben.Der zweite Encoding-Vorgang encodiert die Bitfolge 11111111. Zuerst werden die neuenDaten mit din gesendet und ein paar Zyklen spater auch das Bestatigungssignal wrn=1.
9.3 Manchester Decoder in Verilog
Die gesamte Implementierung des Manchester Decoder (MD) ist unter Verilog in einemModul-Block namens md umgesetzt. Wie auch im Encoder gibt es hier Prozesse inForm von always-Statements und direkte Zuweisungen unter Verwendung des Assign-Befehls.Die verwendeten Dateien und das Simulationsergebnis:
Der Source Code ist in der Datei md.v im Listing 46 ab Seite 69 zu finden.
Die Testbench Datei md tf.v, welche auf die md Entity zugreift, ist im Listing 47 abSeite 72 zu finden.
Die Wavefrom des Manchester-Encoder unter Verwendung der Testbench ist in Abbil-dung 9-10 ab Seite 54 dargestellt.
9.3.1 Parameter
Das von Xilinx gelieferte Decoder modul md hat folgende Ein- und Ausgabe Parameter:
Name Typ Bedeutung
rst input Decoder Resetrdn input Lese Kontroll Signalclk16x input 16-Facher Clockmdi input MC Daten Eingangdata ready output Decoding fertig Status Signaldout output [7:0] Array mit den decodierten NRZ Daten
Tabelle 5: Parameter des Decoders
Der Decoder hat wie der Encoder einen Reset und einen 16-fachen Takt-Eingang. Diebeiden Register rdn und data ready sind fur die Statuskommunikation zwischen Deco-der und der ausfuhrenden Einheit gedacht. An mdi werden seriell die zu decodierendenManchester Daten gesendet. Nach dem vollstandigem Decodieren werden die decodiertenNRZ Daten vom dout Register ausgelesen.
40
9.3.2 Interne Signale
Name Typ Bedeutung
clk1x enable reg Freigabe Status fur clk1xmdi1,mdi2 reg Letzter Zustand von mdi
nrz reg NRZ Wert des letzten/aktuellen sampleno bits rcvd reg [3:0] Wort-Zahler/ Operations Statusclkdiv reg [3:0] Clock Counter Registerrsr reg [7:0] Ergebniszwischenspeicher zum shiftenclk1x wire MC Taktsample wire Zeitgeber fur 1/4 und 3/4 Takt Lesungen
Tabelle 6: Interne Signale des Decoders
Wie im ME gibt es hier auch einen internen Taktzahler clkdiv und Manchester Taktclk1x, welche dieselbe Funktion wie im Encoder haben.Interessant fur das Zeitverhalten ist hier das sample-Signal, welches immer zum erstenund dritten Viertel eines Manchester-Takts ein High-Signal erzeugt. Dieses Signal wirdzum Ablesen der encodierten Manchester Daten benutzt. Ein Manchester Wert hat proclk1x-Taktzyklus immer zwei Werte, welche erfasst werden mussen. Beim Erfassen derWerte ist es wichtig, einen zuverlassigen Wert zu erfassen. Am zuverlassigstem sind dieWerte immer genau in der Mitte, weswegen die sample-Zeitpunkte auch 1/4 und 3/4sind.
9.3.3 Interner Ablauf
Der Decoder wird mit einem rst=1 initialisiert. Anschließend wartet der Decoder auf einerstes Signal an mdi, welches etwas verzogert von den internen Echo Registern mdi1 undmdi2 wiedergegeben wird (erst ist der Wert auf mdi, etwas spater auf mdi1 und noch einwenig spater auf mdi2). Ergibt sich dann die Werte-Konstellation mdi1=0 und mdi2=1,wird der interne Manchester-Takt mit clk1x enable=1 eingeschaltet. Der Taktzahlerclkdiv zahlt nun von 0000 bis 1000, ab diesem Zeitpunkt beginnt das Decoding. Espassieren jetzt mehrere Dinge gleichzeitig: Zum einen wird clk1x auf 1 gesetzt, das in-terne Status-Register no bits rcvd von 0000 auf 0001 erhoht (was im legalen DecodingBereich liegt) und mdi2 bekommt den Wert von mdi1 zugewiesen. Der Bereich des ak-tiven Decoding ist mit dem Wertebereich 0001 bis einschließlich 0111 des no bits rcvd
Registers gekennzeichnet. Die Decoding samples werden immer aus clk1x xor mdi2 zumZeitpunkt smaple=1 und steigende Flanke an clk16x gebildet. Gesampelte Werte wer-den erst im Register nrz gespeichert. Spater beim nachsten Decoding-Zyklus werden sieauf das temporare Vektorregister rsr aufgeschoben. Das rsr-Register selbst wird wie-derum einen Zyklus spater auf das Ausgaberegister dout kopiert. Das Decoding ist mitdem erreichten von no bits rcvd=1000 zu Ende und der Takt wird wieder ausgeschal-tet. Auf das Ausschalten des Takts hin wird data ready=1 gesetzt und soll somit der
41
ausfuhrenden Einheit signalisieren, dass die decodierten Daten an dout bereitliegen.Ein weiteres Decoding kann nun wieder gestartet werden. Die ausfuhrende Einheit setztdafur erst einmal data ready durch Senden von rdn=0 zuruck. Danach wird rdn wiederauf 1 gesetzt, der Decoder reagiert jetzt wieder wie oben beschrieben auf das erste Signalvon mdi.
Standige Zuweisung Hier wird im zweiten Befehl wie beim Encoder das clk1x Signalaus dem hochstwertigstem Bit von clkdiv zugewiesen. Der erste Befehl ist fur die SampleZeitpunkte zustandig. Das sample-Signal soll nur an zwei Stellen des clk1x Zyklus 1sein und zwar im ersten und im dritten Viertel. Bei der Umsetzung wird daher auf denclkdiv-Wert zuruckgegriffen. Wenn clkdiv=0011 oder clkdiv=1100 ist also sample=1.Warum fur den 3/4-Wert der Sample erst bei clkdiv=1100 und nicht bei 1011 genommenwird, wird hierbei nicht klar von Xilinx erklart.
Listing 35: MD standige Zuweisungen
// Generate cen ter sample at po in t s 1/4 (0011) and 3/4 (1100) through thedata c e l l
assign sample = ( ! c l k d i v [ 3 ] && ! c l k d i v [ 2 ] && c l k d i v [ 1 ] && c l k d i v [ 0 ] ) | | (c l k d i v [ 3 ] && c l k d i v [ 2 ] && ! c l k d i v [ 1 ] && ! c l k d i v [ 0 ] ) ;
// Generate 1x c l o c kassign c lk1x = c l k d i v [ 3 ] ;
Prozesse in Verilog konnen in ihrer Parameter-Liste genauer als in VHDL beschriebenwerden. So ist es mit dem always-Statement moglich auf einen spezifizierten Flanken-wechsel eines Signals zu reagieren. Laut XILINX [XIL08] soll das sogar Strom sparen(Was sich naturlich auf den gesamten Typ Prozess generalisieren lasst).
Listing 36: MD-Prozess fur mdi1 und mdi2
always @(posedge c lk16x or posedge r s t )begin
i f ( r s t ) beginmdi1 <= 1 ’ b0 ;mdi2 <= 1 ’ b0 ;
endelse begin
mdi2 <= mdi1 ;mdi1 <= mdi ;
endend
mdi Echo:Weist den Registern mdi1 und mdi2
den Wert von mdi zu, jedoch fur mdi1bis zu einen und fur mdi2 bis zuzwei clk16-Taktzyklen spater. BeimReset werden mdi1 und mdi2 auchzuruckgesetzt.Der genaue Zweck dieser beiden EchoRegister ist leider nicht zu erken-nen, denn man konnte genau so gutauch auf das Datum an mdi zugrei-fen. Jedoch stellt die Implementie-rung der beiden Echo Register mdi1
und mdi2 eine beispielhafte synthe-tisierbare Alternative zum wait -Statement, welches nicht nicht syn-thetisiert werden kann, dar.
42
Listing 37: MD-Prozess fur clk1x enable
always @(posedge c lk16x or posedge r s t )begin
i f ( r s t )c l k1x enab l e <= 1 ’ b0 ;
else i f ( ! mdi1 && mdi2 )c l k1x enab l e <= 1 ’ b1 ;
else i f ( ! mdi1 && ! mdi2 && n o b i t s r c v d== 4 ’ b1000 )
c l k1x enab l e <= 1 ’ b0 ;end
Enable clock:Startet den Taktzahler, sobald aufmdi eine fallende Flanke ubertra-gen wurde bzw. die Echo-Signalemdi1=’0’ und mdi2=’1’ sind. BeimReset oder Ende der Ubertragungwird der Takt wieder ausgeschaltet.
Listing 38: MD-Prozess fur nrz
always @(posedge c lk16x or posedge r s t )i f ( r s t )
nrz = 1 ’ b0 ;else
i f ( n o b i t s r c v d > 0 && sample == 1 ’ b1)
nrz = mdi2 ˆ c lk1x ; // ˆ i s XOR
NRZ Daten:Wenn clk1x auf 1/4 oder 3/4 ist,ist das sample Signal 1. Zu die-sem Zeitpunkt soll in diesem Pro-zess, d.h. wenn gerade decodiertwird (no bits rcvd>0) das deko-dierte (mdi2 xor clk1x) Datum aufnrz gespeichert werden. Das nrz-Register wird auf dem Ergebnis Zwi-schenspeicher Register Vektor rsr
gespeichert.
Listing 39: MD-Prozess fur clkdiv
always @(posedge c lk16x or posedge r s t )begin
i f ( r s t )c l k d i v = 4 ’ b0 ;
else i f ( c l k1x enab l e )c l k d i v = c l k d i v + 1 ;
end
Taktzahler:Solange clk1x enable=’1’ ist, in-krementiere zu jeder steigendenFlanke an clk16x clkdiv um 1. So-mit wechselt clkdiv standig seinenZustand von 0000 bis 1111 und be-gint wieder bei Null. Ein Reset setztclkdiv zuruck auf clkdiv=’0000’.
Listing 40: MD-Prozess fur rsr
always @(posedge c lk1x or posedge r s t )i f ( r s t ) begin
r s r <= 8 ’ h0 ;endelse begin
r s r [ 7 : 1 ] <= r s r [ 6 : 0 ] ;r s r [ 0 ] <= nrz ;
end
Serial to parallel conversion:Um die einzelnen decodierten nrz-Daten spater parallel ausgeben zukonnen, werden in diesem Prozessdie nrz-Daten zu jedem beginnendenclk1x Taktzyklus von rechts auf dentemporaren Ergebnisregister-Vektorrsr geschoben. Beim Reset wird dastemporare rsr Register komplett auf0 zuruckgesetzt.
43
Listing 41: MD-Prozess fur dout
always @(posedge c lk1x or posedge r s t )i f ( r s t ) begin
dout <= 8 ’ h0 ;endelse begin
dout <= r s r ;end
Transfer data from receiver shiftregister to data register:Uberschreibt das Ausgabe-Registerdout mit den aktuellen rsr-Daten.Somit liegen an dout immer umeinen clk1x-Taktzykuls spater diersr-Daten an. Bei einem Reset wirddout sofort auf 0 zuruckgesetzt.
Listing 42: MD-Prozess fur no bits rcvd
always @(posedge c lk1x or posedge r s t ornegedge c l k1x enab l e )
begini f ( r s t )
n o b i t s r c v d = 4 ’ b0000 ;else i f ( ! c l k1x enab l e ) begin
n o b i t s r c v d = 4 ’ b0000 ;endelse
n o b i t s r c v d = n o b i t s r c v d + 1 ;end
Determine word size:Sobald das Decodieren gestartet wor-den ist, wird implizit der MC-Takteingeschaltet also clk1x enanble=1.Unter dieser Vorraussetzung wirddas no bits rcvd-Register zu je-dem beginnenden clk1x-Taktzyklusincrementiert. Somit konnen ande-re Prozesse zu bestimmten Zeit-punkten des Decodings reagieren,z.B. das Ende des Decodings durchclk1x enanble=0 einleiten. Das En-de des Decodings oder ein Reset set-zen den Zahler wieder auf 0 zuruck.
Listing 43: MD-Prozess fur data ready
always @(negedge c l k1x enab l e or posedger s t or negedge rdn )
begini f ( r s t )
data ready <= 1 ’ b0 ;else i f ( ! rdn )
data ready <= 1 ’ b0 ;else
data ready <= 1 ’ b1 ;end
Generate data ready status si-gnal:Nachdem das Decoding zu Endegegangen ist, reagiert dieser Pro-zess auf die negative Flanke vonclk1x enable und setzt data ready
auf 1. Zu diesem Zeitpunk konnen dieDaten von der ausfuhrenden Einheitausgelesen werden, welche dem De-coder wiederum mit einer negativenFlanke an rdn zuruck setzt. Auch einReset setzt setzt data ready auf 0zuruck.
9.3.4 Mankos am MD
1. Auch hier ist ein 16-fach Takt zu hoch, 4- oder 8-Fach wurden reichen und fur einschnelleres Decoding sorgen.
44
2. Ein Folge-Decodierung beginnt immer mit clkdiv=1001 statt 0000, dies fuhrtnicht nur zu uberflussiger Wartezeit, sondern auch zur falschen Interpretation derangegebenen Manchester Werte. Ein einfaches Zurucksetzen von clkdiv bei Endedes Decoding sollte diesen Fehler beseitigen.
3. Das Startbit ist undefiniert. Im Moment macht es keinen Unterschied wie langoder kurz das erste Signal zur Initialisierung ist. Ein explizit definiertes Startbitdagegen, kann unbeabsichtigtes oder falsches Aufrufen des MD verhindern.
4. Die Statussignale data ready und rdn sind nicht zwingend zu verwenden undundefiniert. Es ist z.B. noch moglich, den MD ohne Anwendung der Statusregisterzu benutzen; dies sollte aber zwingend sein.
5. Der 3/4-Wert des Sample ist mit clkdiv=1100 und nicht mit 1011 genommen, wasetwas spater als gewollt, also nicht in der Mitte ist.
9.3.5 Simulation
Aus der Testbench werden zu erst lauter Nullen als Manchester Daten zum Decodierengeschickt. Im zweiten Durchlauf sind es auch wieder lauter Nullen. Da aber kein Resetdurchgefuhrt wurde, werden die Manchester-Nullen als lauter Einsen dekodiert. Im drit-ten Durchlauf werden Eins-Null-Kombinationen gesendet. Dieser gesamte Verlauf ist aufder ersten Waveform in Abb. 9 gut einzusehen.Das Initialisierungsverhalten ist noch einmal gesondert in Abb. 10 dargestellt; hierinkann man auch gut den Vorgang des Sampling erkennen, wobei an dieser Stelle Nullwer-te dekodiert werden.
10 Fazit
Die Wahl der Programmiersprache beinhaltet folgende Faktoren:
� Die Kompatibilitat der eingesetzten Entwicklungsumgebung (EDA)
� Vorkenntnisse der Programmierer, so ist z.B. Verilog ahnlich wie C und VHDLahnlich wie Ada.
Positiv an VHDL ist:
� VHDL ist etwas hoher angesiedelt und geht somit bis zur Systemebene.
� Wiederverwendbarkeit
� Starke Typisierung
� Mehr deklarativ als Verilog
Positiv an Verilog ist:
45
� Verilog ist fur eine schnelle simple Umsetzung gut geeignet.
� Bietet auch Einflussmoglichkeiten auf Gatterebene (UDP).
Simulation Beide Sprachen benotigen eine Testbench (TB) zum Simulieren. Die TB’ssind in der jeweiligen Sprache geschrieben und gleichen sich im Einflussbereich.
EDA’s
Altium Design wird hier fur das Bearbeiten und Simulieren des VHDL-Codes einge-setzt. Altium Design bietet von sich aus nicht die Moglichkeit Verilog-Code zusimulieren, jedoch gibt es die Moglichkeit einen Simulator anzugeben.Grundsatzlich ist Altium Design eine machtige EDA, welche viele Sprachen be-herrscht und gute Moglichkeiten zum bearbeiten von Schemetics bietet.
Xilinx ModelSim kann sowohl VHDL, Verilog als auch SystemC bearbeiten und simu-lieren. Die hier durchgefuhrte Simulation des Manchester Decoders ist auch mitModelSim gemacht. Eine interessante Fahigkeit ist es durch einen Doppelklick aufeine Signalanderung in der Waveform direkt auf das dafur verantwortliche (signal-gebende) Gatter in der Schematic Ebene zu kommen. ModelSim ist im Gegensatzzum Altium Designer als kostenfreie Studentenversion erhaltlich.
46
Anhang
Literatur
[Ash08] Ashenden, Peter J.: The VHDL Cookbook. Universitat Hamburg :http://tams-www.informatik.uni-hamburg.de/vhdl/doc/cookbook/
VHDL-Cookbook.pdf, letzter Zugriff: 23.1.2008
[Bha96] Bhasker, Jayaram: Die VHDL Syntax. Munchen : Markt und Technik, 1996
[Bha98] Bhasker, Jayaram: A VHDL Primer. New Jersey : Prentice Hall, 1998
[Bha99] Bhasker, Jayaram: A Verilog HDL Primer. Allentown : Star Galaxy Publis-hing, 1999
[DEO94] Douglas E. Ott, Thomas J. W.: A Designer’s Guide To VHDL Synthesis.Boston : Kluwer Academic Publishers, 1994
[FK06] Frank Kesel, Ruben B.: Entwurf von digitalen Schaltungen und Systemenmit HDLs und FPGAs. Munchen : Oldenburg Wissenschaftsverlag, 2006
[FV07] Frank Vahid, Roman L.: Verilog For Digital Design. New York : John Wileyand Sons Ltd, 2007
[Mad08] Mader, Andreas: VHDL Kompakt. Universitat Hamburg : http:
//tams-www.informatik.uni-hamburg.de/vhdl/doc/kurzanleitung/
vhdl.pdf, letzter Zugriff: 23.1.2008
[Smi07] Smith, Douglas J.: VHDL & Verilog Compared & Contrasted. http://www.
angelfire.com/in/rajesh52/verilogvhdl.html, letzter Zugriff: 16.12.2007
[Unb08a] Unbekannt: Geschichte und Funktionsweise von Verilog. http://wapedia.mobi/de/Verilog, letzter Zugriff: 23.1.2008
[Unb08b] Unbekannt: History Of Verilog. http://www.asic-world.com/verilog/
history.html, letzter Zugriff: 23.1.2008
[Unb08c] Unbekannt: Systemspezifikation mit Verilog HDL. Universitat Frankfurt: http://www.informatik.uni-frankfurt.de/~razi/verilog/Vseminar.
htm#Basis, letzter Zugriff: 23.1.2008
[XIL08] XILINX: Manchester Encoder-Decoder for Xilinx CPLDs. http://www.
xilinx.com/support/documentation/application_notes/xapp339.pdf,letzter Zugriff: 3.1.2008
47
Abbildungsverzeichnis
1 Typischer Designablauf [DEO94] . . . . . . . . . . . . . . . . . . . . . . . 22 Zusammenhang Testbench und DUT [FK06] . . . . . . . . . . . . . . . . 33 Manchester Code und NRZ . . . . . . . . . . . . . . . . . . . . . . . . . 324 UART Ubertragung mit Frage fur NRZ Daten . . . . . . . . . . . . . . . 335 Bilden des internen Manchester Takts . . . . . . . . . . . . . . . . . . . . 346 Aktivitatsdiagramm einer simplen Ausfuhrung des ME . . . . . . . . . . 367 Waveform Manchester Encoder (Input AA, FF) . . . . . . . . . . . . . . 528 Waveform Manchester Encoder (Initialisierung und Start-Bit) . . . . . . 539 Waveform vom Manchester Decoder in Verilog . . . . . . . . . . . . . . . 5410 Waveform vom Manchester Decoder in Verilog Ausschnitt Initialisierung 55
Die Abbildung 1 ist aus [DEO94] Seite 28 ubernommen.Die Abbildung 2 ist aus [FK06] Seite 40 ubernommen.Die Abbildung 3 ist aus http://de.wikipedia.org/wiki/Bild:
Manchester_encoding_both_conventions.svg ubernommen.Die Abbildung 4 ist aus http://de.wikipedia.org/wiki/Bild:RS-232_timing.png
ubernommen.Die Abbildung 5 ist ein etwas abgeandertes Bild einer Waveform in ModelSim.Die Abbildung 6 ist mit Dia erstellt worden.Die Abbildungen 7 und 8 sind mit Altium Design erstellt worden.Die Abbildungen 9 und 10 sind mit ModelSim erstellt worden.
Tabellenverzeichnis
1 Datentypen in Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Anwendungen der Datentypen in Verilog . . . . . . . . . . . . . . . . . . 123 Parameter des Encoders . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Interne Signale der architecture v1 des Encoders . . . . . . . . . . . . . 345 Parameter des Decoders . . . . . . . . . . . . . . . . . . . . . . . . . . . 406 Interne Signale des Decoders . . . . . . . . . . . . . . . . . . . . . . . . . 41
Die Tabellen 1 und 2 sind aus http:
//chipdesign.uni-hannover.de/chipdesign/downloads/verilog_referenz.pdf
ubernommen.
Listings
1 Verilog DoorOpener . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 VHDL DoorOpener . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
48
3 VHDL Entity als Pseudocode . . . . . . . . . . . . . . . . . . . . . . . 84 VHDL Architecture als Pseudocode . . . . . . . . . . . . . . . . . . . 85 Verilog Module als Pseudocode . . . . . . . . . . . . . . . . . . . . . . 96 VHDL Beispiel fur Record Datentyp . . . . . . . . . . . . . . . . . . 107 Aufbau einer function . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 Aufbau einer procedure . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Aufbau einer task . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1410 Aufbau einer function . . . . . . . . . . . . . . . . . . . . . . . . . . . 1511 Verilog Volladdierer ruft Halbaddierer auf . . . . . . . . . . . . . . 1712 VHDL Volladdierer ruft Halbaddierer auf . . . . . . . . . . . . . . 1713 VHDL Package als Pseudocode . . . . . . . . . . . . . . . . . . . . . . 1814 VHDL Beispielpaket Synth Pack . . . . . . . . . . . . . . . . . . . . . 1815 VHDL Beispielpaket Program Pack . . . . . . . . . . . . . . . . . . . 1816 VHDL Package Body als Pseudocode . . . . . . . . . . . . . . . . . . . 1917 VHDL Beispielpaketkorper Program Pack . . . . . . . . . . . . . . . 1918 Verilog always- und initial-Statements . . . . . . . . . . . . . . . . 2019 Verilog Verzogerungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2120 Verilog Nichtblockierende Zuweisungen . . . . . . . . . . . . . . . . . 2121 Verilog Parallele und sequentielle nichtblockierende Zuweisungen 2122 Verilog Gabelung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2223 Verilog Gatteraddierer mit Verzogerungen . . . . . . . . . . . . . . . 2324 VHDL Add-Or-Invert als sequentieller Prozess . . . . . . . . . . . 2325 VHDL Add-Or-Invert als kontiniuierliche Zuweisung . . . . . . . 2426 Verilog UDP Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . 3027 Verilog UDP Flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3028 ME-Prozess fur clk1x enable . . . . . . . . . . . . . . . . . . . . . . . . 3629 ME-Prozess fur clkdiv . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3730 ME-Prozess fur tbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3731 ME-Prozess fur tbr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3732 ME-Prozess fur tsr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3833 ME-Prozess fur no bits sent . . . . . . . . . . . . . . . . . . . . . . . . 3834 ME standige Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . 3835 MD standige Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . 4236 MD-Prozess fur mdi1 und mdi2 . . . . . . . . . . . . . . . . . . . . . . . 4237 MD-Prozess fur clk1x enable . . . . . . . . . . . . . . . . . . . . . . . . 4338 MD-Prozess fur nrz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4339 MD-Prozess fur clkdiv . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4340 MD-Prozess fur rsr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4341 MD-Prozess fur dout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4442 MD-Prozess fur no bits rcvd . . . . . . . . . . . . . . . . . . . . . . . . 4443 MD-Prozess fur data ready . . . . . . . . . . . . . . . . . . . . . . . . . 4444 VHDL me.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5645 VHDL Test me.VHDTST . . . . . . . . . . . . . . . . . . . . . . . . . . . 5946 Verilog md.v . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
49
47 Verilog md tf.v . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Der Source Code aus den Beispielen 1 und 2 ist aus [FV07] ubernommen.
50
51
Waveforms
Abbildung 7: Waveform Manchester Encoder (Input AA, FF)
52
Abbildung 8: Waveform Manchester Encoder (Initialisierung und Start-Bit)
53
Abbildung 9: Waveform vom Manchester Decoder in Verilog
54
Abbildung 10: Waveform vom Manchester Decoder in Verilog Ausschnitt Initialisierung
55
Programmcode und Testbenches
Manchester Encoder VHDL
Listing 44: VHDL me.vhd
−− F i l e Name: me. vhd2 −− Version : 1 .0−− Date : January 22 , 2000
4 −− Model : Manchester Encoder Chip−−
6 −− Company : X i l i n x−−
8 −−−− Disc la imer : THESE DESIGNS ARE PROVIDED ”AS IS” WITH NO
WARRANTY10 −− WHATSOEVER AND XILINX SPECIFICALLY DISCLAIMS ANY−− IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
12 −− A PARTICULAR PURPOSE, OR AGAINST INFRINGEMENT.−−
14 −− Copyright ( c ) 2000 Xi l inx , Inc .−− Al l r i g h t s r e s e rved
16
l ibrary i e e e ;18 use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
use i e e e . s t d l o g i c a r i t h . a l l ;20 use i e e e . s t d l o g i c u n s i g n e d . a l l ;
22 entity me i sport (
24 r s t , c lk16x , wrn : in s t d l o g i c ;din : in s t d l o g i c v e c t o r (7 downto 0) ;
26 tbre : out s t d l o g i c ;mdo : out s t d l o g i c
28 ) ;end me;
30
architecture v1 of me i s32
signal c lk1x : s t d l o g i c ;34 signal c l k1x enab l e : s t d l o g i c ;
signal c l k d i v : s t d l o g i c v e c t o r (3 downto 0) ;36 signal t s r : s t d l o g i c v e c t o r (7 downto 0) ;
signal tbr : s t d l o g i c v e c t o r (7 downto 0) ;38 signal n o b i t s s e n t : s t d l o g i c v e c t o r (3 downto 0) ;
40
56
begin42
−− Make t h i s f o r ever ! −−−−−−−−−−−−−−−−−−−44
−− s e t t i n g up the c l k 1 x46 c lk1x <= c l k d i v (3 ) ;−− Generate Manchester data from NRZ
48 mdo <= t s r (7 ) xor c lk1x ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
50
52 −− Enable c l o c k when d e t e c t edge on wr i t e pu l s e
54 process ( r s t , c lk16x , wrn , n o b i t s s e n t )begin
56 i f r s t = ’1 ’ or s t d l o g i c v e c t o r ( n o b i t s s e n t ) = ”1010” thenc l k1x enab l e <= ’ 0 ’ ;
58 e l s i f clk16x ’ event and c lk16x = ’1 ’ theni f (wrn = ’1 ’ ) then
60 c l k1x enab l e <= ’ 1 ’ ;end i f ;
62 end i f ;end process ;
64
66 −− Increment c l o c k
68 process ( r s t , c lk16x , c lkd iv , c l k1x enab l e )begin
70 i f r s t = ’1 ’ thenc l k d i v <= ”0000” ;
72 e l s i f clk16x ’ event and c lk16x = ’1 ’ theni f c l k1x enab l e = ’1 ’ then
74 c l k d i v <= c l k d i v + ”0001” ;end i f ;
76 end i f ;end process ;
78
80 −− Generate Transmit Buf fer Reg i s t e r Empty s i g n a l
82 process ( r s t , c lk16x , wrn , n o b i t s s e n t )begin
84 i f r s t = ’1 ’ thentbre <= ’ 1 ’ ;
86 e l s i f clk16x ’ event and c lk16x = ’1 ’ then
57
i f (wrn = ’1 ’ ) then88 tbre <= ’ 0 ’ ;
e l s i f ( s t d l o g i c v e c t o r ( n o b i t s s e n t ) = ”0010” ) then90 tbre <= ’ 1 ’ ;
else92 tbre <= ’ 0 ’ ;
end i f ;94 end i f ;
end process ;96
98 −− Detect edge on wr i t e pu l s e to load transmi t b u f f e r
100 process ( r s t , c lk16x , wrn )begin
102 i f r s t = ’1 ’ thentbr <= ” 00000000 ” ;
104 e l s i f clk16x ’ event and c lk16x = ’0 ’ theni f wrn = ’1 ’ then
106 tbr <= din ;end i f ;
108 end i f ;end process ;
110
112 −− Load TSR from TBR, s h i f t TSR
114 process ( r s t , c lk1x , n o b i t s s e n t , t s r )begin
116 i f r s t = ’1 ’ thent s r <= ” 00000000 ” ;
118 e l s i f clk1x ’ event and c lk1x = ’1 ’ theni f s t d l o g i c v e c t o r ( n o b i t s s e n t ) = ”0001” then
120 t s r <= tbr ;e l s i f s t d l o g i c v e c t o r ( n o b i t s s e n t ) >= ”0010”
122 and s t d l o g i c v e c t o r ( n o b i t s s e n t ) <= ”1010” thent s r <= t s r (6 downto 0) & ’ 0 ’ ;
124 end i f ;end i f ;
126 end process ;
128
−− Ca l cu l a t e the number o f b i t s sen t130
process ( clk1x , r s t , c lk1x enab le , n o b i t s s e n t )132 begin
58
i f r s t = ’1 ’ or c l k1x enab l e = ’0 ’ then134 n o b i t s s e n t <= ”0000” ;
e l s i f clk1x ’ event and c lk1x = ’1 ’ then136 i f c l k1x enab l e = ’1 ’ then
n o b i t s s e n t <= n o b i t s s e n t + ”0001” ;138 end i f ;
end i f ;140 end process ;
142 end ;
Manchester Encoder VHDL Testbench
Listing 45: VHDL Test me.VHDTST
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−2 −− VHDL Testbench f o r me−− 2007 12 28 12 18 48
4 −− Created by ”EditVHDL”−− ”Copyright ( c ) 2002 Altium Limited”
6 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
8 Library IEEE ;Use IEEE . s t d l o g i c 1 1 6 4 . a l l ;
10 Use IEEE . s t d l o g i c t e x t i o . a l l ;Use STD. t e x t i o . a l l ;
12 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
14 −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−entity Testme i s
16 end Testme ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
18
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−20 architecture s t imulus of Testme i s
f i l e RESULTS: TEXT open WRITE MODE i s ” r e s u l t s . txt ” ;22 procedure WRITE RESULTS(
c lk16x : s t d l o g i c ;24 din : s t d l o g i c v e c t o r (7 downto 0) ;
mdo : s t d l o g i c ;26 r s t : s t d l o g i c ;
tbre : s t d l o g i c ;28 wrn : s t d l o g i c
) i s30 variable l o u t : l i n e ;
begin
59
32 wr i t e ( l out , now , r i ght , 15) ;wr i t e ( l out , c lk16x , r i ght , 2) ;
34 wr i t e ( l out , din , r i ght , 9) ;wr i t e ( l out , mdo , r i ght , 2) ;
36 wr i t e ( l out , r s t , r i ght , 2) ;wr i t e ( l out , tbre , r i ght , 2) ;
38 wr i t e ( l out , wrn , r i ght , 2) ;w r i t e l i n e (RESULTS, l o u t ) ;
40 end procedure ;
42 component meport (
44 c lk16x : in s t d l o g i c ;din : in s t d l o g i c v e c t o r (7 downto 0) ;
46 mdo : out s t d l o g i c ;r s t : in s t d l o g i c ;
48 tbre : out s t d l o g i c ;wrn : in s t d l o g i c
50 ) ;end component ;
52
signal c lk16x : s t d l o g i c ;54 signal din : s t d l o g i c v e c t o r (7 downto 0) ;
signal mdo : s t d l o g i c ;56 signal r s t : s t d l o g i c ;
signal tbre : s t d l o g i c ;58 signal wrn : s t d l o g i c ;
60 −−constand d e c l a r a t i on :
62 type t e s t r e c o r d i s record
64 r s t : s t d l o g i c ;wr : s t d l o g i c ;
66 din : s t d l o g i c v e c t o r (7 downto 0) ;ready : s t d l o g i c ;
68 mdo : s t d l o g i c ;
70 end record ;
72 type t e s t a r r a y i s array ( p o s i t i v e range<>) of t e s t r e c o r d ;
74 constant t e s t v e c t o r s : t e s t a r r a y := ( −− . . . cons tant a s s o c i a t e s ava lue
−− to a symbol o f a g iven data type . . . . so a t e s t v e c t o r s cons tant76 −− o f type t e s t a r r a y
60
78 −− r s t , wr , din , ready , mdo( ’ 1 ’ , ’ 0 ’ , ” 00000000 ” , ’ 0 ’ , ’ 0 ’ ) , −− 40
80 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 80( ’ 0 ’ , ’ 1 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 120
82 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 160( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 200
84 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 240( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 280
86 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 320( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 360
88 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 400( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 440
90 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 480( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 520
92 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) , −− 560( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
94 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
96 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
98 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
100 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
102 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
104 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
106 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
108 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
110 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
112 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
114 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
116 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
118 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
120 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
122 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
61
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,124 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,126 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,128 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,130 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,132 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,134 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,136 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,138 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,140 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,142 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,144 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,146 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,148 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,150 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,152 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,154 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,156 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,158 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,160 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,162 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,164 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,166 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,168 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
62
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,170 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,172 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,174 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,176 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,178 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,180 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,182 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,184 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,186 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,188 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,190 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,192 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,194 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,196 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,198 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,200 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,202 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,204 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,206 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,208 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,210 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,212 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,214 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
63
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,216 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,218 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,220 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,222 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,224 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,226 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,228 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,230 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,232 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,234 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,236 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,238 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,240 ( ’ 0 ’ , ’ 0 ’ , ” 10101010 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,242 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 1 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,244 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,246 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,248 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,250 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,252 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,254 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,256 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,258 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,260 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
64
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,262 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,264 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,266 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,268 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,270 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,272 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,274 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,276 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,278 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,280 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,282 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,284 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,286 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,288 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,290 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,292 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,294 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,296 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,298 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,300 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,302 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,304 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,306 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
65
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,308 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,310 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,312 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,314 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,316 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,318 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,320 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,322 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,324 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,326 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,328 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,330 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,332 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,334 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,336 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,338 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,340 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,342 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,344 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,346 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,348 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,350 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,352 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
66
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,354 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,356 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,358 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,360 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,362 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,364 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,366 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,368 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,370 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,372 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,374 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,376 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,378 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,380 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,382 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,384 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,386 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,388 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,
( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ ) ,390 ( ’ 0 ’ , ’ 0 ’ , ” 11111111 ” , ’ 0 ’ , ’ 0 ’ )
) ;392
−− end cons tant394
396 beginDUT:me port map (
398 c lk16x => clk16x ,
67
din => din ,400 mdo => mdo,
r s t => r s t ,402 tbre => tbre ,
wrn => wrn404 ) ;
406
408 STIMULUS0 : processvariable vec to r : t e s t r e c o r d ;
410 begin−−
412 for index in t e s t v e c t o r s ’ range loopvec to r := t e s t v e c t o r s ( index ) ;
414
r s t <= vector . r s t ;416 wrn <= vector . wr ;
din <= vector . din ;418 tbre <= vector . ready ;
mdo <= vector . mdo ;420
c lk16x <= ’0 ’ ;422 wait for 20 ns ;
c lk16x <= ’1 ’ ;424 wait for 20 ns ;
c lk16x <= ’0 ’ ;426
assert tbre = t e s t v e c t o r s ( index ) . ready428 report ”Output ready i s i n c o r r e c t . ” severity note ;
assert mdo = t e s t v e c t o r s ( index ) . mdo430 report ”Output mdo i s i n c o r r e c t . ” severity note ;
432 end loop ;
434 −− i n s e r t s t imu lu s herewait ;
436 end process ;
438 WRITE RESULTS(clk16x ,
440 din ,mdo ,
442 r s t ,tbre ,
444 wrn
68
) ;446
end architecture ;
Manchester Decoder Verilog
Listing 46: Verilog md.v
1 /********************************************************************
*
3 * F i l e Name: md. v* Version : 1 .1
5 * Date : January 22 , 2000* Model : Manchester Decoder
7 *
* Company : X i l i n x9 *
*
11 * Disc la imer : THESE DESIGNS ARE PROVIDED ”AS IS” WITH NO WARRANTY* WHATSOEVER AND XILINX SPECIFICALLY DISCLAIMS ANY
13 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR* A PARTICULAR PURPOSE, OR AGAINST INFRINGEMENT.
15 *
* Copyright ( c ) 2000 Xi l inx , Inc .17 * Al l r i g h t s r e s e rved
*
19 *******************************************************************
*/
21 module md ( rs t , c lk16x , mdi , rdn , dout , data ready ) ;
23 input r s t ;input c lk16x ;
25 input mdi ;input rdn ;
27 output [ 7 : 0 ] dout ;output data ready ;
29
reg c l k1x enab l e ;31 reg mdi1 ;
reg mdi2 ;33 reg data ready ;
reg nrz ;35 reg [ 7 : 0 ] dout ;
69
reg [ 3 : 0 ] n o b i t s r c v d ;37 reg [ 3 : 0 ] c l k d i v ;
reg [ 7 : 0 ] r s r ;39 wire sample ;
wire c lk1x ;41
// Generate cen ter sample at po in t s 1/4 (0011) and 3/4 (1100)through the data c e l l
43 assign sample = ( ! c l k d i v [ 3 ] && ! c l k d i v [ 2 ] && c l k d i v [ 1 ] && c l k d i v [ 0 ] )| | ( c l k d i v [ 3 ] && c l k d i v [ 2 ] && ! c l k d i v [ 1 ] && ! c l k d i v [ 0 ] ) ;
// Generate 1x c l o c k45 assign c lk1x = c l k d i v [ 3 ] ;
47
// Generate 2 FF r e g i s t e r to accep t s e r i a l Manchester data in49
always @(posedge c lk16x or posedge r s t )51 begin
i f ( r s t ) begin53 mdi1 <= 1 ’ b0 ;
mdi2 <= 1 ’ b0 ;55 end
else begin57 mdi2 <= mdi1 ;
mdi1 <= mdi ;59 end
end61
63 // Enable the 1x c l o c k when the r e i s an edge on mdi
65 always @(posedge c lk16x or posedge r s t )begin
67 i f ( r s t )c l k1x enab l e <= 1 ’ b0 ;
69 else i f ( ! mdi1 && mdi2 )c l k1x enab l e <= 1 ’ b1 ;
71 else i f ( ! mdi1 && ! mdi2 && n o b i t s r c v d == 4 ’ b1000 )c l k1x enab l e <= 1 ’ b0 ;
73 end
75
// Decode Manchester in t o NRZ code77
always @(posedge c lk16x or posedge r s t )79 i f ( r s t )
70
nrz = 1 ’ b0 ;81 else
i f ( n o b i t s r c v d > 0 && sample == 1 ’ b1 )83 nrz = mdi2 ˆ c lk1x ; // ˆ i s XOR
85
// Increment c l o c k counter87
always @(posedge c lk16x or posedge r s t )89 begin
i f ( r s t )91 c l k d i v = 4 ’ b0 ;
else i f ( c l k1x enab l e )93 c l k d i v = c l k d i v + 1 ;
end95
97 // S e r i a l to p a r a l l e l convers ion
99 always @(posedge c lk1x or posedge r s t )i f ( r s t ) begin
101 r s r <= 8 ’ h0 ;end
103 else beginr s r [ 7 : 1 ] <= r s r [ 6 : 0 ] ;
105 r s r [ 0 ] <= nrz ;end
107
109 // Transfer data from r e c e i v e r s h i f t r e g i s t e r to data r e g i s t e r
111 always @(posedge c lk1x or posedge r s t )i f ( r s t ) begin
113 dout <= 8 ’ h0 ;end
115 else begindout <= r s r ;
117 end
119
// Determine word s i z e121
always @(posedge c lk1x or posedge r s t or negedge c l k1x enab l e )123 begin
i f ( r s t )125 n o b i t s r c v d = 4 ’ b0000 ;
71
else i f ( ! c l k1x enab l e ) begin127 n o b i t s r c v d = 4 ’ b0000 ;
end129 else
n o b i t s r c v d = n o b i t s r c v d + 1 ;131 end
133
// Generate da ta ready s t a t u s s i g n a l135
always @(negedge c l k1x enab l e or posedge r s t or negedge rdn )137 begin
i f ( r s t )139 data ready <= 1 ’ b0 ;
else i f ( ! rdn )141 data ready <= 1 ’ b0 ;
else143 data ready <= 1 ’ b1 ;
end145
endmodule
Manchester Decoder Verilog Testbench
Listing 47: Verilog md tf.v
/* Te s t f i x t u r e f o r Manchester decoder2 Xi l inx , Inc
Jan 26 , 2000 */4
6 ’ t i m e s c a l e 1 ns / 1 ns
8 module md tf ;reg r s t ;
10 reg c lk16x ;reg mdi ;
12 reg c l k1x enab l e ;reg c lk1x ;
14 reg nrz ;reg [ 3 : 0 ] n o b i t s r c v d ;
16 reg sample ;reg rdn ;
18 wire [ 7 : 0 ] dout ;
20 md u1 ( r s t , c lk16x , mdi , rdn , dout , data ready ) ;
72
22 i n i t i a l beginr s t = 1 ’ b0 ;
24 c lk16x = 1 ’ b0 ;mdi = 1 ’ b0 ;
26 rdn = 1 ’ b1 ;end
28
integer md chann ;30 i n i t i a l begin
md chann=$fopen ( ”md. rpt ” ) ;32 $t imeformat (−9 , , ,5) ;
end34 parameter c l o c k p e r i o d = 100 ;
always #( c l o c k p e r i o d /2) c lk16x = ˜ c lk16x ;36 i n i t i a l begin
$fdisplay ( md chann , ” Ver i l og s imu la t i on o f Manchester decoder \n\n” ) ;38 $shm open ( ”md. shm” ) ;
$shm probe ( ”AS” ) ;40
$fmonitor ( md chann , ”Time=%t , r s t=%b , c lk16=%b , c lk1x=%b , mdi=%b , nrz=%b ,n o b i t s r c v d=%b , sample=%b , dout=%h , data ready=%b” , $time , r s t , c lk16x,md. c lk1x enab le ,md. clk1x , mdi ,md. nrz ,md. no b i t s r cvd ,md. sample ,dout , data ready ) ;
42
#1 r s t = 1 ’ b1 ;44 #100 r s t = 1 ’ b0 ;
46 // Input 8 l o g i c 0 s
48 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
50 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
52 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
54 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
56 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
58 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
60 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
62 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
73
64
#1600 rdn = 1 ’ b0 ;66 #800 rdn = 1 ’ b1 ;
68 #3200
70 // Input 8 l o g i c 1 s
72 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
74 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
76 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
78 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
80 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
82 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
84 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
86 #800 mdi = 1 ’ b1 ;#800 mdi = 1 ’ b0 ;
88
#2400 rdn = 1 ’ b0 ;90 #800 rdn = 1 ’ b1 ;
92
// Input a l t e r n a t i n g 1s , 0 s94
#1600 mdi = 1 ’ b1 ;96 #1600 mdi = 1 ’ b0 ;
#1600 mdi = 1 ’ b1 ;98 #1600 mdi = 1 ’ b0 ;
#1600 mdi = 1 ’ b1 ;100 #1600 mdi = 1 ’ b0 ;
#1600 mdi = 1 ’ b1 ;102 #1600 mdi = 1 ’ b0 ;
104 #1600 r s t = 1 ’ b1 ;
106 $fdisplay ( md chann , ”\nSimulat ion o f Manchester decoder i s complete .” ) ;
$ f inish ;108 end
74
endmodule
75
