Gehaxelts Blog

In diesem Blogpost soll es um VHDL und dessen Simulation auf Linuxrechnern gehen.

VHDL steht für Very High Speed Integrated Circuit Hardware Description Language und dient zur Schaltungssynthese, z.B. für Prozessoren.

Was genau ist VHDL?

Wie schon gesagt, ist VHDL eine Art Programmiersprache für Logikschaltungen. Es wurde vor einiger Ewigkeit entwickelt und laut meinem Prof nutzen es die großen Firmen, wie Intel oder AMD, um ihre Prozessoren zu designen bzw. zu optimieren.

Denn wie schon im letzten Blogpost über die Tison Methode vorgestellt, kann man vieles einfacher machen, wenn man an bestimmten Stellen optimiert. Das können die Designwerkzeuge für einen übernehmen.

Wie programmiert man darin?

Bisher wurden uns zwei Grundlegende Dinge beigebracht, nämlich das es Entitäten und Architekturen gibt. Die Entitäten beschreiben die Ein- bzw. Ausgänge des Moduls und in der Architecture ist der eigentliche Verhaltenscode abgelegt.

Dazu mal ein Beispiel:

1
2
3
4
5
6
7
8
9
10
11

entity andor is
  port( x,y: in bit;
      z: out bit);
end entity andor;

architecture behave of andor is
  signal w : bit;
  begin
      w <= (x or y);
      z <= (x and y) or w;
end architecture behave;

Zunächst sagen wir in der Entität, dass es zwei Eingänge und einen Ausgang geben soll.

In der Architecture nehmen wir uns zunächst ein Zusatzbit w, welches die Disjunktion von x und y speichern soll. Auf den Ausgang z legen wir dann die Verundung bzw. Verorderung der Werte.

Schaltnetz & Wertetabelle

Das Schaltnetz dazu sieht so aus:

Falls jemand ein nettes Tool kennt, mit dem man schöne Schaltnetze erstellen kann, dann werde ich hier eins nachreichen.

1
2
3
4
5
6

x|y|z
-----
0|0|0
0|1|1
1|0|1
1|1|1

Wie man es aus der Wertetabelle erkennt, macht unsere Funktion nichts weiter als ein einfaches “or” nur etwas umständlicher, aber das ist auch erstmal egal.

Testbench

Wenn wir die Schaltung simulieren wollen, dann müssen wir uns eine Testbench schreiben, also unsere Komponente als Blackbox betrachten und die Ein- bzw. Ausgabe protokollieren.

Eine Testbench könnte so aussehen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

entity testbench is
end entity testbench;

architecture behave of testbench is
  signal testx, testy, testz: bit;
  
  component andor is
      port( x,y: in bit;
          z: out bit);
  end component andor;
  
  begin 
      gate1: andor
          port map(x => testx, y => testy, z => testz);
          
  testx <= '0', '1' after 100 ns, '0' after 200 ns, '1' after 300 ns;
  testy <= '0', '1' after 200 ns;
  
end architecture behave;

Schaltung simulieren

Ich komme nun zum eigentlichen Inhalt des Blogposts, nämlich dem Simulieren der Schaltung mit ghdl und gtkwave.

Diese beiden Tools müssen wir zunächst installieren:

sudo apt-get install ghdl gktwave

Nachdem die Installation fertig ist, können wir den oben geschriebenen Code in eine Datei “projekt.vhdl” schreiben und abspeichern.

Danach führen wir folgende Kommandos hintereinander aus:

ghdl -a projekt.vhdl

Das analysiert den Code, und zeigt ggf. Syntaxfehler auf.

ghdl -e testbench

Wir geben die Entität an, welche erstellt werden soll.

ghdl -r testbench

Das führt eine Simulation der Schaltung aus.

Jetzt möchten wir noch den VCD Code aus der erstellten Datei “testbench” auspacken.

./testbench --vcd=testbench.vcd

Diesen Dump können wir uns dann mittels gtkwave anzeigen lassen.

gtkwave testbench.vcd

Nachdem man dort die Variablen “importiert” hat, und ein wenig rangezoomt (Time->Zoom->Zoom to best fit)hat, dann kann man die Verläufe sehr gut nachvollziehen.

Fazit

Man braucht also nicht unbedingt übertrieben teuere Software um VHDL-Code bzw. entsprechend entworfene Schaltungen zu Simulieren. Das alles geht auch mit mehreren open source Tools.

Gruß

gehaxelt