Die erste Schaltung: 1-Bit Komparator

Xilinx Spartan3

Hier zeige ich euch wie ihr eine erste Schaltung in VHDL entwickelt. Als Einstiegsbeispiel habe ich hierfür einen einfachen 1-Bit Komparator gewählt.

-> Die Schaltung:

Bevor ich damit beginnen kann die Schaltung zu beschreiben, muss ich mir erst mal Gedanken dadrüber machen wie sich die Schaltung verhalten soll.
Meine Schaltung soll zwei 1-Bit Werte am Eingang vergleichen und eine 1 ausgeben wenn die Werte gleich sind.
Die Funktion der Schaltung habe ich in einer Wahrheitstabelle verdeutlicht:

BAQ
001
010
100
111

Jetzt da die Funktion der Schaltung definiert wurde, können wir damit beginnen die Schaltung zu beschreiben.

-> Der Code:

Als erstes legt ihr euch ein Projekt mit Namen Ein_Bit_Komparator an.
Wie das geht habe ich hier beschrieben. Nachdem das Projekt angelegt und geöffnet wurde klickt ihr oben in dem Reiter auf Project und anschließend auf New Source.
Das sich öffnende Fenster füllt ihr dann so aus (VHDL Module auswählen):

1_Bit_Komparator(1)

Nach einem Klick auf Next erscheint ein neues Fenster.
In diesem Fenster könnt ihr die benötigten Pins deklarieren und den Namen der Architektur festlegen. Dies erspart euch ein wenig Schreiberei im Code.
Die Anforderungen an die Schaltung besagen, das der Komparator zwei Eingänge (A und B) und einen Ausgang (Q) haben soll.
Dies tragt ihr in die Maske ein und klickt dann auf Next und anschließend auf Finish:

1_Bit_Komparator(2)

Jetzt gelangt ihr zur Entwicklungsumgebung. Nehmt euch einen Moment Zeit und schaut euch in Ruhe um.
Wie ihr in dem Code-Fenster seht, hat das Programm euch schon recht viele Eingaben abgenommen.
Es ist ein ausführliches Kommentarfeld eingefügt worden und das Grundgerüst für das Programm ist auch schon vorhanden.
Mit den ersten beiden Zeilen

werden Standardfunktionen für FPGAs eingefügt.
Diese Zeilen dürfen in keinem Programm fehlen!
Die nächsten Zeilen sind diese hier:

Mit einer entity (dt. Einheit) wird die Schaltung nach außen hin beschrieben.
Sie ist dabei wie folgt aufgebaut:

entity [Name der entity] is
   Generic
   Port
end [Name der entity];

Die Schaltung wird dabei als Blackbox angesehen, wo die Funktion erstmal komplett egal ist.
Hier wird beschrieben welche Signale aus der Schaltung laufen und welche sonstigen Eigenschaften die Schaltung besitzt.
Ein Signal wird dabei wie folgt beschrieben:

Name : Richtung Typ

Beispiel:

B : in STD_LOGIC;

Damit wird ein Signal beschrieben, welches den Namen „B“ hat, ein Input ist und vom Typ STD_LOGIC ist. STD_LOGIC ist dabei ein Datentyp. Für unsere ersten Versuche reicht es zu wissen, dass der Typ nur 0 und 1 annehmen kann.
Eine genauere Beschreibung zu diesem Datentyp findet ihr hier.
Zusammengefasst kann man also sagen, dass die Blackbox drei Anschlüsse besitzt, von denen zwei Inputs sind die nur 0 und 1 annehmen können und einer ein Output ist, der auch nur 0 und 1 annehmen kann kann.
Damit wäre die Schaltung nach außen hin fertig beschrieben.
Nun folgt die innere Beschreibung.
Hierfür gibt es die sogenannte architecure.
Sie ist wie folgt aufgebaut:

architecture [Name der Architektur] of [Name der entity] is
   Signaldeklarationen
begin
   Schaltungsbeschreibung
end [Name der Architektur]

Für den Komparator sieht die fertige Architektur so aus:

Wie ihr seht, habe ich die Architektur Komparator_Arch genannt und zwei Signale mit dem Namen P0 und P1 vom Typ STD_LOGIC definiert.
Dieses Signal ist sowas wie eine lokale Variable. Ich nutze es um Zwischenergebnisse zu speichern.
Zwischen den Zeilen begin und end wird dann die Schaltung beschrieben.
Bei VHDL ist es egal in welcher Reihenfolge ihr die Beschreibung eingebt, da die Schaltung nicht sequenziell ausgeführt wird (wie ein Programm für einen Mikrocontroller), sondern parallel.
Die Zeile

legt das Signal P0 ODER P1 auf den Ausgang Q.
Eine Zuweisung geschieht dabei immer wie folgt:

Ziel <= Wert;

Mit den nächsten beiden Zeilen

formuliere ich die Wahrheitstabelle aus.
Das Signal P0 soll dabei den Wert von NICHT A UND NICHT B annehmen und das Signal P1 den Wert von A UND B.
Die drei Zeilen können theoretisch auch so zusammen gefasst werden:

Dadurch erspart ihr euch die beiden Signale P0 und P1, aber bei längeren Ausdrücken kann dies schnell zur Unübersichtlichkeit führen.
Damit ist die Schaltungsbeschreibung abgeschlossen.

-> Synthese und Bitstream generieren:

Jetzt, da die Beschreibung abgeschlossen ist, muss die Schaltung synthetisiert werden. Hierfür speichert ihr das Projekt ab und doppelklickt anschließend auf diesen Button:

1_Bit_Komparator(3)

Je nach Rechner dauert die Synthese unterschiedlich lange. Sobald die Synthese abgeschlossen ist (und keine Fehler aufgetreten sind), erscheint vor den beiden Pfeilen ein grüner Haken (siehe Bild bei 1).
Der nächste Schritt ist, dass den Eingangs- und Ausgangssignalen, die wir in der Schaltung deklariert haben, Pins zugewiesen werden.
Hierfür gibt es das Programm PlanAhead, welches ihr durch einen Doppelklick öffnet (bei 2):

1_Bit_Komparator(4)

Ein sich eventuell öffnendes Fenster beendet ihr mit einem Klick auf Yes.
Jetzt öffnet ihr den Ordner Scalar ports und dann seht ihr dort die im VHDL Code definierten Signale.
Diesen Signalen könnt ihr nun Spannungspegel, Pins, Pulldown oder Pullup Widerstände und sonstige Dinge zuweisen.
Fürs erste bekommen die Eingänge Pulldown Widerstände, werden an Pin 85 und Pin 86 gelegt und der Ausgang wird an Pin 90 gelegt (der Haken bei Fixed erscheint automatisch sobald ihr einen Pin eintragt):

1_Bit_Komparator(5)

Anschließend speichert ihr das alles. Unter dem Menü Schematic könnt ihr euch noch eure Schaltung als Schaltplan anschauen:

1_Bit_Komparator(6)
Die LUT beinhaltet dabei die Funktion des Komparators, sprich die Wahrheitstabelle die oben definiert wurde.
Wenn ihr fertig seid, könnt ihr PlanAhead beenden.
Der nächste Schritt ist das implementieren des Designs. Hierfür doppelklickt ihr auf diesen Button:

1_Bit_Komparator(7)

Dieser Vorgang dauert wieder ein Weilchen. Sobald er abgeschlossen ist, macht ihr einen Links klick auf den Punkt Generate Programming File, welcher sich direkt dadrunter befindet.
In dem sich öffnenden Fenster müsst ihr nun folgende Punkte anpassen:

  1. Unter General Options
    -> Haken bei Create Binary Configuration File
  2. Unter Configuration Options
    -> Configuration Pin Programm auf Float ändern
    -> Unused IOB Pins auf Float ändern

Anschließend schließt ihr das Fenster mit einem Klick auf OK und danach könnt ihr den Bitstream mit einem Doppelklick auf Generate Programming File generieren.
Als letzten Schritt öffnet ihr den Projektordner und kopiert die .bin Datei auf eure SD-Karte:

1_Bit_Komparator(8)

Nach dem Kopiervorgang müsst ihr die Datei auf der SD-Karte nur noch in config.bin umändern und in euer FPGA Board stecken.
Wenn ihr alles richtig gemacht habt leuchtet die LED sobald die beiden Anschlüsse 24 und 25 (Pin 85 und 86 vom FPGA) unterschiedliche Pegel haben und sie hört auf zu leuchten sobald die Pegel gleich sind (die LED ist aktive Low beschaltet worden):

1_Bit_Komparator(10)

Die Synthese und die Implementierung sind für alle Schaltungen gleich und können, bis auf die Pinzuweisung, auf alle anderen Projekte übertragen werden.

 

Dokumentation:

 

-> Zurück zum FPGA + VHDL Tutorial

4 thoughts on “Die erste Schaltung: 1-Bit Komparator
  1. Hallo,

    danke erstmal für dein Tutorial. Ich interessiere mich für FPGAs und habe mir jetzt auch das elektor board gekauft. Leider funktioniert der 1-Bid Komperator bei mir nicht :(
    Leider gibt es zu diesem board keine Doku. Oder ich hab sie nicht gefunden….
    Ich bin Anfänger und brauch ein wenig mehr hilfe. Ich habe evtl ein paar probleme mit der Beschaltung. Das Board wird mit 3,3 Volt versorgt, richtig? Das sind die beiden Anschlüsse links oben, also Masse ganz links und 3,3V rechts daneben.
    Woher weiss ich welche Pins die P85 und P86 sind? Ich hab mir das datasheet runtergeladen aber finde mich da nicht so zurecht….
    Und welche LED müsste denn leuchten? Die müsste ja dann theoretisch an P90 liegen oder? Das rechte obere gelbe kabel geht auch auf masse oder? Wenn ja warum?
    Danke schon mal für deine Hilfe :)

  2. Danke für die schnelle Antwort und die Bilder. Das wird mir sicher weiterhelfen. Kann es eigentlich auch sein das die SD Karte nicht gelesen werden kann? Evtl weil sie zu groß ist. 8GB hab ich.

    • Hey Alex,

      ich weiß gerade nicht ob nach der Konfiguration des FPGAs eine LED aufleuchtet.
      Aber ich meine 8GB sollten funktionieren….aber kannst ja mal eine 4GB testen, falls du eine hast.

      Gruß
      Daniel

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Time limit is exhausted. Please reload CAPTCHA.