Quelltext der Seite 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<ref>{{Literatur |Titel=IEEE Standard for VHDL Language Reference Manual |Sammelwerk=IEEE Std 1076-2019 |Datum=2019-12 |DOI=10.1109/IEEESTD.2019.8938196 |Seiten=1–673 |Online=https://ieeexplore.ieee.org/document/8938196/ |Abruf=2023-07-08}}</ref> 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 [[Auszeichnungssprache|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ändigkeit|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<!-- (sprich: „wisig“) // Beleg? -->, die von der US-amerikanischen Regierung 1980 aufgesetzt wurde, um einen gegenüber der Privatwirtschaft entstandenen Technologierückstand bei der Entwicklung von [[Integrierter Schaltkreis|''Very High Speed Integrated Circuits'']] aufzuholen.<ref>VHSIC Program Office: [https://apps.dtic.mil/sti/pdfs/ADA230012.pdf Very High Speed Integrated Circuits - VHSIC - Final Program Report 1980-1990] vom 30. September 1990. Website des ''Defense Technical Information Centers''. Abgerufen am 15. Januar 2011.</ref> Die Sprachdefinition war das Produkt von Normierungsbestrebungen eines Komitees, in dem die meisten größeren [[Computer-aided design|CAD]]-Anbieter und CAD-Nutzer, aber auch Vereinigungen wie die [[IEEE]], vertreten waren. Als großer nordamerikanischer Auftraggeber hat dann das [[Verteidigungsministerium der Vereinigten Staaten|US-Verteidigungsministerium]] (engl. ''Department of Defense'') VHDL zum Durchbruch verholfen. Es forderte, dass alle in ihrem Auftrag nach dem 30. September 1988 entwickelten [[Anwendungsspezifische integrierte Schaltung|ASIC]]s 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|IEEE-1076]]-Standard von 1993 genormt. Gegenüber dem ersten Standard von 1987 (IEEE 1076-1987<ref>{{Literatur |Titel=IEEE Standard VHDL Language Reference Manual |Sammelwerk=IEEE Std 1076-1987 |Datum=1988-03 |DOI=10.1109/IEEESTD.1988.122645 |Seiten=1–218 |Online=https://ieeexplore.ieee.org/document/26487/ |Abruf=2023-07-08}}</ref>) 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 für analoge Schaltungen, VHDL-AMS|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 [[Simulation|Systemsimulation]] erfassen zu können.

Aktuelle [[Electronic Design Automation|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 [[Elektronische Schaltung|Schaltung]] auf einer höheren Abstraktionsebene. 
VHDL ermöglicht das schnelle Entwickeln großer und komplexer Schaltungen (z.&nbsp;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 [[Verifikation|formal]] möglich.

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

Neben VHDL existieren [[Verilog]] und [[Advanced Boolean Expression Language|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 [[Synthese (Elektrotechnik)|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.

<div class="mw-collapsible mw-collapsed rahmenfarbe1" style="clear:both; border-style:solid; padding:.1em;">
<div class="hintergrundfarbe5" style="padding:.1em;">'''Codebeispiele'''<br>'''Beispiel: D-Flipflop (behavioural)  nicht synthetisierbar'''</div>
<div class="mw-collapsible-content">
<syntaxhighlight lang="vhdl">
  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;
</syntaxhighlight>
</div>
<div class="hintergrundfarbe5" style="padding:.1em;">'''Beispiel: D-Flipflop (behavioural) synthetisierbar, aber "AFTER T_Clk_Q" wird ignoriert'''</div>
<div class="mw-collapsible-content">
<syntaxhighlight lang="vhdl">
  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;
</syntaxhighlight>
</div>
<div class="hintergrundfarbe5" style="padding:.1em;">'''Beispiel: D-Flipflop (behavioural)  synthetisierbar, asynchroner Reset'''</div>
<div class="mw-collapsible-content">
<syntaxhighlight lang="vhdl">
  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;
</syntaxhighlight>
</div>
<div class="hintergrundfarbe5" style="padding:.1em;">'''Beispiel: D-Flipflop (behavioural)  synthetisierbar, synchroner Reset'''</div>
<div class="mw-collapsible-content">
<syntaxhighlight lang="vhdl">
  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;
</syntaxhighlight>
</div>
<div class="hintergrundfarbe5" style="padding:.1em;">'''Beispiel: Andere Architektur (Herstellerbibliothek)'''</div>
<div class="mw-collapsible-content">
<syntaxhighlight lang="vhdl">
   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;
</syntaxhighlight>
</div>
</div>

== Simulation und Verifikation von VHDL-Code ==

Mittlerweile ist VHDL praktisch der Standard für die Beschreibung der Simulationsmodelle von [[IP-Core|Intellectual Property]] (IP). 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.&nbsp;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.<ref>[http://www.gaisler.com/doc/vhdl2proc.pdf 2-Prozess Methode] (engl.; PDF; 33&nbsp;kB)</ref> 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 [[Debugger|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 [[Differentialgleichung]]en zur Beschreibung von elektrischen Netzwerkelementen wie [[Spule (Elektrotechnik)|Spulen]] oder [[Kondensator (Elektrotechnik)|Kondensatoren]] zu modellieren. 

Bis 2006 waren noch keine [[Synthesetool]]s 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 (Software)|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 [[Microsoft Windows|Windows]]
* ''DataFlow'': grafische Eingabe unter [[Unix|UNIX]]
* ''zamiaCAD'': Open-Source-Plugin für [[Eclipse (IDE)|Eclipse]]
* ''Signs'': Plugin für [[Eclipse (IDE)|Eclipse]]
* ''Sigasi'': Eclipse-basierter Editor für VHDL und Verilog unter Windows x86/x64, [[Linux]] x86/x64, Mac
* ''VHDPlus'': Kostenfreie [[Integrierte Entwicklungsumgebung|IDE]] für VHDL, Verilog und VHDP<ref>[https://vhdplus.com/ www.vhdplus.com] Offizielle Seite von VHDPlus</ref>

Weiterhin gibt es für viele gängige [[Texteditor]]en Zusatzpakete für die VHDL-Unterstützung, beispielsweise für [[vi]], [[Notepad++]] und [[Emacs]].<ref>[http://www.iis.ee.ethz.ch/~zimmi/emacs/vhdl-mode.html Emacs VHDL Mode] Entwicklerseite an der ETH Zürich</ref>

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''<ref>GHDL-Internetseite http://ghdl.free.fr/</ref>, [[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, {{Webarchiv | url=https://www.itiv.kit.edu/653.php | wayback=20100611160521 | text=kostenloser Download}}
* 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 ==
{{Wikibooks|VHDL-Tutorium}}
{{commonscat|VHDL}}
* [http://tams.informatik.uni-hamburg.de/research/vlsi/vhdl/ The Hamburg VHDL Archive] (englisch und deutsch)
* [http://tams.informatik.uni-hamburg.de/research/vlsi/vhdl/doc/ajmMaterial/vhdl.pdf Andreas Mäder: ''VHDL Kompakt''] VHDL Einführung (deutsch; PDF-Datei; 444 kB)
* [https://github.com/fabriziotappero/Free-Range-VHDL-book FREE RANGE VHDL Bryan Mealy, Fabrizio Tappero] online Buch (englisch)
* [https://www.fpga4student.com/2017/08/verilog-vs-vhdl-explain-by-example.html Verilog vs VHDL: Explain by Examples] (englisch)

== Einzelnachweise ==
<references />

{{Navigationsleiste programmierbare Logik}}

{{Normdaten |TYP=s |GND=4254792-1}}

[[Kategorie:Beschreibungssprache]]
[[Kategorie:Programmierbare Logik]]
[[Kategorie:Hardwarebeschreibungssprache]]
[[Kategorie:Digitaltechnik]]