Very High Speed Integrated Circuit Hardware Description Language

Very High Speed Integrated Circuit Hardware Description Language (auch VHSIC Hardware Description Language), kurz VHDL, ist eine Hardwarebeschreibungssprache, mit der es möglich ist, digitale Systeme textbasiert zu beschreiben. VHDL ist seit 1987 als IEEE-Standard festgelegt und es gibt inzwischen einige ebenfalls standardisierte Spracherweiterungen. Darüber hinaus gibt es Sprachderivate wie zum Beispiel VHDL-AMS, mit deren Hilfe auch analoge oder Mixed-Signal-Systeme beschrieben werden können.

VHDL ist als Beschreibungssprache keine Programmiersprache; da sie jedoch Objekte beschreibt, deren Aufgabe meist die Informationsverarbeitung ist, kann über deren Simulation dennoch Datenverarbeitung stattfinden, indem für diesen Simulationslauf  mitgegebene „Eingangsdaten“ von der (simulierten) Hardware zu „Ergebnisdaten“ verarbeitet werden. Durch diesen Umweg kann VHDL (in Kombination mit einem Simulator) wie eine Programmiersprache Turing-vollständige Datenverarbeitung beschreiben.

Durch fortschrittliche Schaltungsgeneratoren ist es mitunter sogar möglich, anstatt des Hardwareaufbaus für einen Algorithmus nur den Algorithmus selbst anzugeben; die dazugehörige Schaltung wird vollautomatisch erzeugt. Dies nähert VHDL einer Programmiersprache weiter an.

Geschichte 
VHDL entstand im Rahmen der VHSIC-Initiative, die von der US-amerikanischen Regierung 1980 aufgesetzt wurde, um einen gegenüber der Privatwirtschaft entstandenen Technologierückstand bei der Entwicklung von Very High Speed Integrated Circuits aufzuholen. Die Sprachdefinition war das Produkt von Normierungsbestrebungen eines Komitees, in dem die meisten größeren CAD-Anbieter und CAD-Nutzer, aber auch Vereinigungen wie die IEEE, vertreten waren. Als großer nordamerikanischer Auftraggeber hat dann das US-Verteidigungsministerium (engl. Department of Defense) VHDL zum Durchbruch verholfen. Es forderte, dass alle in ihrem Auftrag nach dem 30. September 1988 entwickelten ASICs in VHDL dokumentiert werden müssten. Es wurde aber nur gefordert, dass wirklichkeitsgetreue Verhaltensbeschreibungen in VHDL entstehen müssten. Die Implementierungssprache – sei es VHDL, VerilogHDL oder die bis dahin übliche grafische Eingabe – blieb für die Auftragnehmer offen. Ziel war es, mindestens die Schaltungs-Dokumentation zu vereinheitlichen und die Simulation komplexer digitaler Systembeschreibungen aus verschiedensten Quellen zu ermöglichen. Die erste kommerzielle Version wurde 1985 veröffentlicht. Sie entstand aus einer Zusammenarbeit der Unternehmen IBM, Texas Instruments und Intermetrics.

VHDL ist durch den IEEE-1076-Standard von 1993 genormt. Gegenüber dem ersten Standard von 1987 (IEEE 1076-1987) wurde die Sprache ergänzt, aber auch einige Konstrukte der alten Syntax entfernt und in wenigen Einzelfällen die Semantik von Konstrukten verändert.

Eine Erweiterung der Beschreibung auf den analogen Bereich elektrischer Systeme wurde mit AHDL erzielt. Derzeit gibt es Bestrebungen, eine allgemeine Sprache zur Beschreibung technischer Systeme zu schaffen – siehe VHDL-AMS (VHDL analog/mixed signal). Diese soll den Rahmen der rein elektronischen Schaltungen verlassen und zusätzlich mechanische Elemente, Sensoren und Aktoren modellieren, um auch diese mit in einer Systemsimulation erfassen zu können.

Aktuelle EDA-Tools unterstützen derzeit die Version VHDL-2002 und VHDL-2008.

Funktionsweise 
Bei VHDL arbeitet man nicht mit einzelnen elektronischen Bauteilen, sondern beschreibt das gewünschte Verhalten einer Schaltung auf einer höheren Abstraktionsebene. 
VHDL ermöglicht das schnelle Entwickeln großer und komplexer Schaltungen (z. B. Mikroprozessor mit über 20 Mio. Transistoren), die hohe Effizienz erfordern (zeitlich wie ökonomisch) und unterstützt den Entwickler bei allen Arbeiten.

So kann ein System simuliert, synthetisiert und schließlich eine Netzliste erstellt werden. Eine Verifikation ist sowohl durch vollständige Simulation als auch formal möglich.

Aus der Netzliste können Masken für die Herstellung von MPGAs (mask programmable gate array) oder ähnlichen LSI (Large scale integration)-Chips produziert werden oder sie kann (nach Konvertierung in einen geeigneten Bitstream) direkt in ein FPGA (Field Programmable Gate Array) oder CPLD (Complex Programmable Logic Device) geladen werden.

Neben VHDL existieren Verilog und ABEL. Die weltweit meist genutzten Hardwarebeschreibungssprachen sind VHDL und Verilog.

VHDL hat sich zum „Quasistandard“ in Europa entwickelt, in den USA ist dagegen Verilog die meist verwendete Sprache.

Synthesefähiger und funktionaler VHDL-Code 
Es ist notwendig, zwischen synthesefähigem und funktionalem Code zu unterscheiden, weil es Konstrukte gibt, die sich zwar simulieren lassen, aber nicht in reale Hardware und damit in eine Netzliste übersetzt werden können. Was aus dem breiten Spektrum an funktionalem VHDL-Code tatsächlich synthesefähiger VHDL-Code ist, bestimmt primär das zur VHDL-Synthese gewählte Übersetzungsprogramm (Synthesetool). Funktionaler, nicht synthesefähiger Code wird vor allem im Bereich der Schaltungssimulation und zur Erstellung sogenannter Testbenches eingesetzt, teilweise auch, um neue Verfahren wie beispielsweise das Verhalten von Schnittstellenprotokollen vorab zu prüfen.

Synthesefähigen VHDL-Code herzustellen, ist im Regelfall aufwändiger und der Entwickler muss dabei auf große Teile der Sprachmöglichkeiten von VHDL bewusst verzichten und die Zielhardware und deren genauen Eigenschaften näher kennen. So ist beispielsweise VHDL-Code zur Ein- und Ausgabe über das Betriebssystem (textio) wie dem Schreiben und Lesen von Dateien oder auch die Ausgabe von Texten auf den Bildschirm nicht synthesefähig.

            Codebeispiele
    
          Beispiel: D-Flipflop (behavioural)  nicht synthetisierbar
    
      ENTITY DFlipflop IS
    PORT(D,Clk: IN Bit;
         Q: OUT Bit);
  END DFlipflop;
  ARCHITECTURE Behav OF DFlipflop IS 
      CONSTANT T_Clk_Q: time := 4.23 ns;
  BEGIN 
      PROCESS
      BEGIN
         WAIT UNTIL Clk'EVENT AND Clk'Last_Value='0' AND Clk='1';
         Q <= D AFTER T_Clk_Q;
      END PROCESS;
  END Behav;

    
          Beispiel: D-Flipflop (behavioural) synthetisierbar, aber "AFTER T_Clk_Q" wird ignoriert
    
      ENTITY DFlipflop IS
    PORT(D,Clk: IN Bit;
         Q: OUT Bit);
  END DFlipflop;
  ARCHITECTURE Behav OF DFlipflop IS 
      CONSTANT T_Clk_Q: time := 4.23 ns;
  BEGIN 
      PROCESS
      BEGIN
         WAIT UNTIL Clk'EVENT AND Clk='1';
         Q <= D AFTER T_Clk_Q;
      END PROCESS;
  END Behav;

    
          Beispiel: D-Flipflop (behavioural)  synthetisierbar, asynchroner Reset
    
      ENTITY DFlipflop IS
    PORT(D,Clk, nResetAsync: IN Bit;
         Q: OUT Bit);
  END DFlipflop;
  ARCHITECTURE Behav OF DFlipflop IS 
  BEGIN 
      PROCESS(Clk,nResetAsync)
      BEGIN
         IF nResetAsync = '0' THEN
            Q <= '0';
         ELSIF Clk'EVENT AND Clk = '1' THEN
            Q <= D;
         END IF;
      END PROCESS;
  END Behav;

    
          Beispiel: D-Flipflop (behavioural)  synthetisierbar, synchroner Reset
    
      ENTITY DFlipflop IS
    PORT(D,Clk, nResetSync: IN Bit;
         Q: OUT Bit);
  END DFlipflop;
  ARCHITECTURE Behav OF DFlipflop IS 
  BEGIN 
      PROCESS(Clk)
      BEGIN
         IF Clk'EVENT AND Clk = '1' THEN
            IF nResetSync = '0' THEN
               Q <= '0';
            ELSE
               Q <= D;
            END IF;
         END IF;
      END PROCESS;
  END Behav;

    
          Beispiel: Andere Architektur (Herstellerbibliothek)
    
       LIBRARY VendorLib;
   ARCHITECTURE Vendor OF DFlipflop IS
      COMPONENT Dff PORT(D, Clk: IN Bit; Qout: OUT Bit); END COMPONENT;
   BEGIN 
      Ff1: Dff PORT MAP (D => D , Clk => Clk, Qout => Q );
      FOR ALL : Dff USE ENTITY VendorLib.Component.Dff;
   END Vendor;

Simulation und Verifikation von VHDL-Code 

Mittlerweile hat sich VHDL als Standard für die Simulationsmodelle von Intellectual Property (IP) durchgesetzt. In einem Simulationsmodell wird der eigentlich zu testende und synthesefähige VHDL-Code bzw. VHDL-Modul eingebettet und die Hardware darum in einem sogenannten ‚Test-Bench‘ möglichst getreu nachgebildet. Das Simulationsmodell wird dabei meistens in nicht synthetisierbarem VHDL verfasst, was das Modellieren des Zeitverhaltens oder bestimmter physikalischer Parameter der externen Schaltungsteile erlaubt. 

Ein Beispiel soll diesen Vorgang erläutern:

 Bei der Erstellung eines SDRAM-Controllers, einer Schaltung zum Ansteuern von SDRAM-Speichermodulen, wird das SDRAM mit seinem Speicher und sein zeitliches Verhalten im Simulationsmodell möglichst genau wie die reale SDRAM-Hardware nachgebildet. Damit kann der Controller in seiner logischen Funktion simuliert und auch das Verhalten in den zeitlichen Extrembedingungen verifiziert werden, ohne dass dafür reale Hardware notwendig wäre. Bei Bedarf wird der SDRAM-Controller funktionell entsprechend nachgebessert, um die Simulationsrandbedingungen zu erfüllen. Erst wenn diese Simulation erfolgreich war, wird der so erstellte SDRAM-Controller auf Hardware, beispielsweise in einem FPGA, in Kombination mit ‚echten‘ SDRAM-Bausteinen in Betrieb genommen. Damit ist der Entwicklungsprozess von IP-Cores weitgehend unabhängig von konkreter Hardware.

Die Erstellung von guten Testbenches, die entsprechende Aussagen zulassen, ist dabei eine meist unterschätzte Aufgabenstellung, die ca. 50 % der gesamten Entwicklungszeit für IP-Cores ausmacht. Sie ist aber, neben systematischem Vorgehen in der Entwicklung, wesentlich effizienter als frühzeitig mit meist nicht auf Anhieb funktionierenden Schaltungsteilen auf reale Hardware zu gehen – die dann nur schwer und umständlich in allen ihren Parametern verifiziert werden können.

Weiter unterscheidet man bei der Simulation unterschiedliche Simulationsarten: 

 Eine reine Verhaltenssimulation (engl. behavioral simulation) des zu implementierenden IP-Core. Dabei werden die funktionellen Zusammenhänge in der Schaltung grundsätzlich geprüft. Beispielsweise ob logische Verknüpfungen einzelner Signale passen. Der Vorteil besteht im geringen Rechenaufwand, womit zeitlich längere Abschnitte simuliert werden können. 
 Eine Simulation des fertig platzierten IP-Core (engl. post-fit simulation). Dabei wird der IP-Core zunächst synthetisiert, geroutet und platziert, dann werden aus der fertigen Schaltungsanordnung die Netzliste und die zugehörigen Laufzeitinformationen der Zielhardware ermittelt. Die Anwendung der Laufzeitparameter auf den VHDL-Code (engl. back annotation) wird entweder von entsprechenden Werkzeugen übernommen, die daraus nicht synthetisierbaren VHDL-Code erzeugen, oder sie geschieht unmittelbar im Simulationsprogramm. Der Vorteil besteht in dem genaueren Modell, um beispielsweise Zeitablaufprobleme in der Zielhardware bereits in der Simulation erkennen zu können. Nachteilig sind der damit verbundene hohe Rechenaufwand und die auch auf schnellen Rechnern sehr langen Simulationszeiten, die sich je nach Komplexität der Schaltung im Bereich von einigen Tagen bewegen können.

Weiter kann unterschieden werden zwischen Testbenches mit eigener Fehlererkennung und Testbenches, die nur den reinen Zeitverlauf darstellen. Im ersten Fall werden im Testbench die zu bestehenden Prüfungen aufgrund von fixen Entscheidungen („Prüfvektoren“) festgelegt und automatisch durch entsprechende Textausgaben festgestellt. Die Erstellung solcher Testbenches ist aufwendiger, aber bietet den Vorteil, bei späteren Änderungen leichter die Veränderungen der Implementierung vollständig und sicher prüfen zu können (engl. regression test). Im zweiten Fall wird die zu simulierende Schaltung in ihrem Zeitverhalten (engl. wave diagram) nur dargestellt, ohne dass eine automatische Bewertung der Ausgabe durchgeführt wird. Die Entscheidung, ob das Verhalten der Schaltung korrekt ist, obliegt der Person, die dieses Zeitverhalten manuell überprüfen muss. Der Vorteil dieser Methode ist die Einfachheit bei der Erstellung der Testbenches, weshalb sie vor allem bei einfachen Schaltungen angewendet wird. Ein Nachteil ist, dass dabei Fehler in der Implementierung durch die manuelle Prüfung leicht übersehen werden können, vor allem bei komplexen Schaltungen. Ein anderer Nachteil ist, dass eine manuelle Prüfung nach jeder Änderung des VHDL-Codes erneut von Hand durchgeführt werden muss.

Skelett eines VHDL-Bausteines 
       ENTITY Bausteinname IS
       GENERIC (Parameterliste, optional);
               - dieses Statement erlaubt die Übergabe modellabhängiger
                 Parameter (z. B.: Verzögerungszeiten) an einem Baustein;
       PORT (Schnittstellenliste, optional);
               - hier werden die Signalschnittstellen des Bausteins nach außen
                 definiert; folgende Modi sind möglich IN, OUT, INOUT, BUFFER;
               - an dieser Stelle können diverse Deklarationen vorgenommen werden,
                 die in verschiedenen Architekturrümpfen benutzt werden können,
                 das sind unter anderem Unterprogramme, Typendeklarationen,
                 Konstantendeklarationen und Signaldeklarationen;
       BEGIN (Anweisungen, optional);
               - hier können Anweisungen stehen, die für alle Architekturrümpfe
                 durchzuführen sind; das verkürzt die Architekturbeschreibung,
                 denn in Bausteindeklarationen aufgeführte Anweisungen müssen
                 nicht mehr in den Architekturrümpfen stehen;
       END Bausteinname;
               - Ende der Bausteindeklaration

Architekturrumpf: 
   
       ARCHITECTURE Rumpfname OF Bausteinname IS
          - an dieser Stelle können optional diverse Deklarationen für
            Typen, Konstanten und Signale vorgenommen werden,
            im Gegensatz zu den Bausteindeklarationen sind diese hier
            nur für den vorliegenden Architekturrumpf gültig;
       BEGIN
          - Anweisungen, die das Verhalten oder die Struktur des
            Bausteins beschreiben;
       END Rumpfname;

Programmierstile 
Die im Architekturrumpf verwendeten Programmierungsstile lassen sich im Bereich von synthetisierbaren VHDL auf einige wenige grundlegende Formen reduzieren. Manchmal ist die Verwendung bestimmter VHDL-Stile im Rahmen bestimmter Entwicklungsprojekte auch vorgegeben:

 Der vor allem bei Hardware-Entwicklern und Anfängern verbreitete Dataflow-Stil. Charakteristisch ist, dass pro Architecture eine Vielzahl parallel ablaufender und meist im Umfang kleiner und synchroner Prozesse und nebenläufige Anweisungen verwendet werden, die über Signale miteinander verbunden sind. Mit den Prozessen werden einzelne, meist elementare Hardwarestrukturelemente direkt in VHDL abgebildet und die Signale dienen sowohl zur Zustandsspeicherung innerhalb der einzelnen Prozesse als auch zur Informationsübermittlung zwischen diesen Prozessen. Während bei kleinen Architectures dieser Stil durchaus noch beherrschbar ist, wird die Unübersichtlichkeit des Programmcodes bei größeren Modellen zum Nachteil. Durch die Parallelität der einzelnen Prozesse und deren Interaktionen kann das Verhalten der gesamten Schaltung nur schwer nachvollzogen werden.
 Die so genannte 2-Prozessmethode. Bei diesem, vor allem im synchronen FPGA-Design vorteilhaften VHDL-Stil, besteht die Architecture nur noch aus zwei Prozessen: Einem meist sehr komplexen rein kombinatorischen Prozess, der den kompletten Algorithmus und das Verfahren beinhaltet und einem sehr simplen getakteten Prozess, der alle Register (Zustandsspeicher) beinhaltet. Durch das Zusammenfassen von einzelnen Signalen in records lassen sich damit auch komplexe Algorithmen übersichtlich beschreiben. Durch das Abbilden des Verfahrens in nur einem kombinatorischen Prozess lassen sich die beim dataflow-Stil nur schwer nachvollziehbaren Nebenläufigkeiten mehrerer Prozesse vermeiden und ähnlich wie bei einer Programmiersprache mit Variablen, mit einem sequentiellen Ablauf beschreiben. Auch das Debuggen des VHDL-Codes kann aufgrund der sequentiellen Abarbeitung innerhalb des einen kombinatorischen Prozesses mit ähnlichen Methoden wie in der Softwareentwicklung erfolgen.

Unterschiede und Gemeinsamkeiten zu klassischen Programmiersprachen 
In einer Hardwarebeschreibungssprache wird der Aufbau einer physikalischen Schaltung modellhaft beschrieben. Es werden keine Algorithmen beschrieben, sondern Hardware, die einen Algorithmus berechnen kann. Erst in der Bauteilsimulation, mit „angelegten Eingangsdaten/-signalen“ findet eine (simulierte) Datenverarbeitung statt, die mit der Ausführung eines Programms einer klassischen Programmiersprache vergleichbar ist.

In den meisten Programmiersprachen sind parallele Abläufe beschreibbar; analog kann VHDL Hardwaremodule beschreiben, die gleichzeitig existent sind und simultan arbeiten.

In VHDL unterscheidet man
 Entitäten ('entity'), die Vorlagen für Schaltungsblöcke sowie deren Ein- und Ausgänge beschreiben, und
 Komponenten ('component'), die Instanzen dieser Vorlagen repräsentieren (vgl. Klasse und Objekt in objektorientierten Programmiersprachen), und
 Prozesse ('process'), die parallele Anweisungen zusammenfassen.

Daten können in VHDL verschiedene Typen besitzen, die oft reale Schaltungszustände nachbilden, aber auch Rechengrößen wie Integer. Zur Verarbeitung gibt es Signale, Variablen und Konstanten.
 Signale werden als Ein- und Ausgänge und auch zur Datenübertragung zwischen nebenläufigen Prozessen in derselben Komponente verwendet. In einer getakteten Schaltung dient ein Signal überdies zur Speicherung von Werten. Hierbei wird es im Fall einer Synthese als Register modelliert.
 Variablen werden innerhalb von Prozessen verwendet und dienen dort zur übersichtlichen Gliederung und Vereinfachung des Codes. Wird in einem getakteten Prozess eine Variable (sequentiell gesehen) gelesen, bevor sie geschrieben wird, so wird bei der Synthese implizit ein Register erstellt.
 Konstanten stellen physikalisch eine harte Verdrahtung dar, in der Simulation sind sie synonym mit Konstanten herkömmlicher Programmiersprachen.

Der funktionale Unterschied zwischen Signalen und Variablen besteht des Weiteren darin, dass Signale ihren neuen Zustand erst am Ende eines sequentiellen Prozesses annehmen, während Variablen ein Verhalten ähnlich wie bei Programmiersprachen zeigen und Zuweisungen unmittelbar wirken. Dieser Umstand ist vor allem für Anfänger meist verwirrend, wird jedoch klar ersichtlich, sobald verinnerlicht wurde, dass ein Prozess keine sequentielle Abfolge von Befehlen darstellt, sondern alles gleichzeitig geschieht.

VHDL für analoge Schaltungen, VHDL-AMS 
Seit 1999 laufen im Rahmen der IEEE verschiedene Bestrebungen, VHDL auch für die Simulation und künftig auch Synthese von analogen und gemischt analog-digitalen Schaltungen einzusetzen. Die Bezeichnung für diese erweiterte Sprache ist VHDL-AMS und sie ist im Standard IEEE 1076.1-1999 definiert.

Im Rahmen von VHDL-AMS können beispielsweise analoge Temperatursensoren mit ihren elektrischen Signalverhalten als Funktion der Temperatur an den Anschlussklemmen modelliert werden. Ebenso besteht die Möglichkeit, in VHDL-AMS Differentialgleichungen zur Beschreibung von elektrischen Netzwerkelementen wie Spulen oder Kondensatoren zu modellieren. 

Bis 2006 waren noch keine Synthesetools für Schaltungen erhältlich, die in VHDL-AMS beschrieben sind. Lediglich für die Schaltungssimulation waren bereits verschiedene kommerzielle Softwarepakete wie Saber von Synopsys, AdvanceMS von Mentor Graphics oder SMASH von Dolphin Integration am Markt verfügbar. Diese Simulationsprogramme sind ergänzend zu etablierten analogen Schaltungssimulationsprogrammen der SPICE-Klasse (Eldo, Spectre, hSpice etc.) zu sehen. Sie ermöglichen die gemeinsame Simulation von Verhaltensmodellen zusammen mit Schaltungen auf Bauelementebene (Spice). Das ist eine Grundvoraussetzung für die Top-Down-Methode im Schaltungsentwurf. Da VHDL-AMS eine Obermenge von VHDL darstellt, ist die Simulation zusammen mit rein digitalen Schaltungsteilen in VHDL ebenso möglich.

VHDL-Editoren 
 HDL-Designer ist ein kommerzielles grafisches Eingabewerkzeug für VHDL und Verilog.
 Crimson Editor für Windows
 DataFlow: grafische Eingabe unter UNIX
 zamiaCAD: Open-Source-Plugin für Eclipse
 Signs: Plugin für Eclipse
 Sigasi: Eclipse-basierter Editor für VHDL und Verilog unter Windows x86/x64, Linux x86/x64, Mac
 VHDPlus: Kostenfreie IDE für VHDL, Verilog und VHDP

Weiterhin gibt es für viele gängige Texteditoren Zusatzpakete für die VHDL-Unterstützung, beispielsweise für vi, Notepad++ und Emacs.

Ebenso ist in gängigen VHDL-Simulatoren ein eigener VHDL-Editor mit Texthighlighting und ähnlichem vorhanden. Dieser ermöglicht nicht nur die Eingabe des Codes, sondern hilft durch seine Integration auch bei der Fehlersuche, da beispielsweise Codestellen vom Compiler/Simulator/... aus Fehlermeldungen heraus angesprungen werden können und Breakpoints im Quelltext umsetzbar sind.

VHDL-Simulatoren 
 ModelSim von Mentor Graphics, für Windows, Linux und Unix
 ActiveHDL von Aldec, für Windows
 RivieraPro von Aldec, für Windows und Linux
 Portunus von Adapted Solutions, für Windows
 SimPlorer von Ansoft, für Windows
 SMASH von Dolphin Integration, für Windows, Linux und Unix
 ISE Simulator (ISim) von Xilinx, auch in kostenlosem ISE WebPACK, für Windows und Linux
 Quartus II von Altera, auch kostenlose Web Edition, für Windows und Linux
 GHDL, Open-Source, für Windows, Linux, FreeBSD und Apple OS X
 SystemVision von Mentor Graphics, für Windows
 NCSim von Cadence Design Systems, für SunOS und Linux

Siehe auch 
 PSL (Property Specification Language)
 BSDL (Boundary Scan Description Language)

Literatur 
 Jürgen Reichardt, Bernd Schwarz: VHDL-Synthese, Entwurf digitaler Schaltungen und Systeme. 7. Auflage. De Gruyter Oldenbourg, Berlin 2015, ISBN 978-3-11-037505-3.
 Paul Molitor, Jörg Ritter: VHDL – Eine Einführung. Pearson-Studium, München 2004, ISBN 3-8273-7047-7.
 Gunther Lehmann, Bernhard Wunder, Manfred Selz: Schaltungsdesign mit VHDL, Franzis-Verlag, Poing 1994, ISBN 3-7723-6163-3, 
 Peter J. Ashenden: The Designer’s Guide to VHDL. Morgan Kaufmann Publishers, San Francisco 2002, ISBN 1-55860-674-2.
 Peter J. Ashenden: VHDL – 2008. Just the new stuff. (Systems on Silicon). Morgan Kaufmann Publishers, San Francisco 2008, ISBN 978-0-12-374249-0.
 Yannick Herve: VHDL-AMS. Oldenbourg, München 2006, ISBN 3-486-57787-5.
 VASCO – RTL VHDL Application on Synthesis. MABEX – Multimedia Limited, Zielona Góra 1999, ISBN 83-907288-9-3.
 Frank Kesel, Ruben Bartholomä: Entwurf von digitalen Schaltungen und Systemen mit HDLs und FPGAs: Einführung mit VHDL und SystemC. Oldenbourg, München 2006, ISBN 3-486-57556-2.

Weblinks 

 The Hamburg VHDL Archive (englisch und deutsch)
 Andreas Mäder: VHDL Kompakt VHDL Einführung (deutsch; PDF-Datei; 444 kB)

Einzelnachweise 

Beschreibungssprache
Programmierbare Logik
Hardwarebeschreibungssprache
Digitaltechnik