VHDL

[dvajda]

Also, meine Damen jetzt habe ich ein neues Ziel

1.) Erst Mal: Auf (n...) wiedersehen Wäscherei 4 ever
2.) Wieder - nie weggewesen, willkommen volles Programm Fernuni Hagen.

Aber jetzt werde ich gleich ein altes Projekt aufwärmen - sie wissen noch wo wir stehen geblieben sind - ich schon. Ich habe ja den Kurs Computersysteme I und II belegt. Da geht es um Hardware. Der simpelste quelloffene Prozessor der Welt wird vorgestellt. Und zwar nicht einfach als eine photographische Ansicht. Glauben sie mir, wenn sie die Vorstellung verstanden haben, sind sie in der Lage ihn wirklich zu bauen - mit vorhandenen mitteln - kein Spass!

Gut, ich war noch während der Wäscherei mit PHP und Servern beschäftigt. Das Thema war nie gegessen. Server bedeutet, Linux, es ging mir um Daemonen und PHP. Damit war ich ja beschäftigt.

Nur nicht mehr mit Hardware. Aber jetzt kommt es. Wo ich aufgehört hatte, bei Hardware - sie erinnern sich - ich habe Schaltungen gebastelt. Aber ich hatte auch einen FPGA gekauft. Einen von Xilinx. Und das ist ein Baustein, mit vielen Gatern, nur werden die programmiert verdrahtet. Darauf kann man Schaltungen programmiert unterbringen. Mit der Programmiersprache VHDL. Die beschreibt Hardware.

Warum ich nicht weiter machte, war. Teilweise sogar der Rechner. Ich habe inzwischen viele neue, der an dem ich gerade arbeite, ist perfekt. Und die müssen die Software für VHDL echt packen. Weil das ist eine echt aufwendige Software zur Abwechlung. Und es braucht Festplattenspeicher. Beides habe ich jetzt. Damals hatte ich schnellen Prozessor und keinen Speicher oder Speicher und schlechten Prozessor.

Mein Computer hier ist das Richtige. Damit probiere ich es erneut. Man muss halt VHDL wirklich genau lernen. Vom Prinzip kein Problem und trotzdem. Man muss lernen. Ich installiere jetzt erst mal die Software.

[dvajda]

Sorry, liebe leute. Aber xilinx vivado installieren, dauert lange. Ich habe eine download Geschwindigkeit von 500Mbit/s. Und da wo man es lädt, 4MBit/s uplaod. Das heisst, Gesetz der sanduhr geht nicht schneller als 4MBit/s. Aber: Es gibt einen installer. Der ist in 1s da. Und 2GByte oder wie viel gross? Aber der lädt etwas neues. Und das dauert ewig. 20GByte nur die small Version. Und dazu verwendet bereits der installer extrem viel Ressourcen.

Das ist so, wenn man bei Debian Linux 11, bullseye, so weit ich weiss, Firefox hinten herum laufen hat, wird es lustig. Denn wenn die Ressourcen verbraucht sind, ich weiss nicht, was Firefox hinten herum macht, aber wenn Facebook läuft, ich weiss nicht was da passiert. Cross Site Scripting. XSS. Plötzlich hängt der. Und: Ich habe xilinx vivado jetzt schon direkt installieren wollen, ging nicht. Probiere jetzt erst das Image und dann.

Aber: Ich war gerade solange beim ohrenarzt. Gleich müsste es fertig sein. Ich kann ihnen die Stichwörter schreiben. Die habe ich nicht geposted. Ich habe auch Screenshots Vom installer. Dir poste ich auch.

[dvajda]

Solange erkläre ich ihnen, was ein fpga ist. Solange sie es noch nicht wissen. Ich habe schaltungen mit 74xx ttl gattern gebaut. Ein Gatter erfüllt genau die Funktion AND, OR, NOT. Eines der dreien. Es gibt auch höhere, die flip Flops, alu. Oder sonst was realisieren. Generell ist der einfachste Prozessor nicht schwer zu verstehen. Was uns das Leben am Prozessor oft schwer macht, ist unser Verständnis eines mikroprogramm steuerwerks. Wir haben von diesem Schaltwerk beim Prozessor eine zu hohe Vorstellung. In Wirklichkeit besteht die Idee beim einfachsten Prozessor aus zwei Phasen.. Befehl holen und Befehl dekodieren. Das Befehl dekodieren führt den Befehls bereits aus. Wie müssen wir uns das vorstellen. ein Prozessor ist vom operationswerk etwas ganz einfaches. Er besteht aus alu, Registern und Speicher + befehlszähler. Da wir bei einer arithemtischen Operation zwei operanden, verknüpfen, und einen zieloperand haben..von einer Kasse, ganz einfach zu verstehen: ein Kreislauf, dir ALU verknüpft zwei register und schreibt das Ergebnis in eines der beiden zurück. Der Akku. Diese werden wieder verknüpft und zurück

Nun, was tut das steuerwerk. Da wir mehr Befehle haben, liegen die Operationen in form von Zahlen im RAM. Hintereinander. Sind aber im opcode nicht grösser, als ein Byte. Gut, was tut die dekodiereinheit. Wer brav die schaltnetze gelernt hat, weiss, ein dekoder ist nichts als ein schaltnetz, dass den Code eines zeichenvorrats in einen anderen umsetzt. Das bedeutet: was ist das Ziel? Das Ziel ist nicht kompliziert zu verstehen. Es gibt 4 Leitungen an der alu, minimum, die 00, 01, 10, 11, vorgeben +,-,/,*. Bei einfachen alu +,- und shiften ist vom CPU abhängig. Auch die Leitungen. Dann haben wir 8 oder 32 register. Zwei wählen für für eingangsoperanden. Daher die steuerleitungen. Das dekoder übersetzt den opcode in die entsprechenden steuerleitungen, ,0,1. Das ist alles. Doch, wenn der Befehl dekodiert sind, sind die Steuerleitungen bereits alle so geschaltet wie sie müssen und die Operanden laufen bereits ins nächste Register

Deswegen gibt es nichts mehr, als Befehl holen und Befehl ausführen. Befehl ausführen ist Befehl dekodieren. Das Ergebnis landet auch da wo es hin muss - warum? Weil es entsprechend an der Steuerleitung frei ist.

Dafür brauchen wir tatsächlich kein grösseres Schaltwerk. Es muss nur holen und ausführen. Also zwischen zwei Phasen hin und her wechseln. Im Kreis nach. Hat also zwei Zustände.

Unser Steuerwerk ist mehr als das Schaltwerk. Es ist das Befehlsdekoder. Und das ist ein Schaltnetz, also nichts mit Zuständen. Es übersetzt den Opcode in die entsprechenden Bits für die Steuerleitungen.

Warum eigentlich haben wir 5 Pipeline Stufen, oder wie bei Intel üblich über 20. Das ist relativ ungewöhnlich, zu erklären.

Angenommen, sie nehmen 100 TTL Gatter. Alles ALU's. Sie addieren einen Wert, der sagen wir verrückt Hoch ist. Also nehmen wir nicht 100, sondern 128. Weil das ist ein Informatik Wert. Aber: Wr gehen davon aus, dass die ALU's extreme Breite haben. Ein einzelnes ist 4 Bit. Ich würde jetzt mal sagen. 512. Wie auch immer. Es geht durch 128 hintereinander geschaltet. Sie werden sich nichts dabei denken. Schnell ist schnell. Denken sie an ihren Lichtschalter. Kaum gedrückt, Licht an.

Vajda denkt was anderes. Würden sie ein Signal sehr lange durch viele Transistoren laufen lassen - es dauert extrem lange, bis alle Stufen geschaltet haben. Sagen wir bei 128 hintereinander geschalteten IC's. 1s. Na gut 1s. Warum müssen Computer schnell sein.

Warum dafür gibt es viele Gründe. Aber: Wenn eine Operation 1s dauert. Dann denken sie drüber nach: Sie sagen: Ihr Programm ist 8 Zeilen lang. Sagen wir es dauert 8s. Falsch, sie haben Informatik nicht verstanden.

Vajda, schreibt auch ein Programm. Es durchläuft eine Schleife von 0 bis 2047. Und das wären 2048s. Sie dürfen ausrechnen wie viel das in Minuten ist. Macht nichts sagen sie. Soll er lange zählen.

Gut, sagt Herr Vajda: Sie mögen Kassen. Aber um die Kasse zu bestellen werden sie sich einen PC nehmen. Darauf läuft eine Software für Internet. Und was hat die? Ein Fenster. Gut: Und sie wissen, dass es MMX gibt. Was ist eigentlich MMX. MMX ist eine Methode bei Graphik die Anzahl der Additionen oder Operationen für jeden Pixel zu reduzieren, indem die gleiche Operation mit 8 Pixeln auf ein Mal stattfindet. Wie viele Pixel hat ihr Monitor?

2048*1024

Etwas um den dreh. Dann denken sie nach. Bis ihr Bild entstanden ist, wären das 2048*1024s.

Da hätten auch sie keinen Spass.

Deswegen: Je mehr hintereinander geschaltet sind, um so grösser wird die Signallaufzeit.

Und da hat man sich einen Trick ausgedacht.

Es gibt eingangsregister, ausgangsregister, ALU. Und so weiter. Man schaltet vor allem ein Register. oder mehrere. Die die Werte jeweils erhalten. Man teilt den Befehl für jede Einheit in Stufen. Und da jeder Befehl die ALU verwenden wird?!!! Und jeder Befehl Eingangsregister. Macht man das so - dass sich die Befehle überlappen. Und jetzt hat man Pipelining

Und wenn man das hat. Hat man 5 Stufen. IF, ID, EX, MEM, WB

Aber ansonsten ist das Schaltwerk und das Steuerwerk easy. So könnten sie sich einen Prozessor löten

Was macht der FPGA? Während sie jetzt einfach die Gatter nahmen und sie wissen, dass jedes ALU und so aus AND und OR und NOT und XOR besteht, gibt es Bausteine, da sind Millionen dieser Gatter drauf. Wir müssen sie blos verbinden

Diese Verbindungen sind beim FPGA in einem Speicher untergebracht. Es ist eine Logik, die mittels Wörter festlegt, was wie verbunden ist. Damit man das hinbekommt, muss man den Speicher beschreiben, wie jeden normalen

Und so kann man VHDL nehmen. es ist eine Hardware beschreibungssprache. Damit schreibe ich eine Schaltung in Form von Worten und nicht bildern. Diese wird übersetzt und landet auf dem FPGA - die Gatter sind verbunden. Damit haben wir einen ganz einfachen Prozessor ohne Pipelining, der tatsächlich ganz klein ist, untergebracht.

[dvajda]

[dvajda]

Ich installiere das jetzt, dasbrauch extrem viel Ressourcen, sollte es hängen macht das nichts, weil dies mal ist das Installations Verzeichnis des downloaders da. Ich habe es gesichert.

[dvajda]

Code: Alles auswählen

/bin/bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)

[dvajda]

Code: Alles auswählen

apt-get install locales-all
apt-get install libncurses5

[dvajda]

Code: Alles auswählen

apt-get install locales-all

Code: Alles auswählen

apt-get install libncurses5

weil:

Code: Alles auswählen

david@git:~/Xilinix-bin/Vivado/2023.1/bin$ ./vivado 
application-specific initialization failed: couldn't load file "librdi_commontasks.so": libtinfo.so.5: cannot open shared object file: No such file or directory

[dvajda]

http://ghdl.free.fr/ghdl/index.html

[dvajda]

1. Block
2. Signal

Blöcke: Zähler, Multiplexer, Dekoder, ...

Blöcke werden über Signale miteinander verbunden


1.) Konventionen
1.1.) Namensregeln
1.2.) Kommentare
1.3.) Zuweisungen
2.) Typologie
3.) Vektoren
4.) Aufbau der Schaltungsbeschreibung
4.1.) Header mit Bibliothek und Packageeinbindungen
4.2.) Entity für Schnittstellendefinition
4.3.) Architecture für Funktionsbeschreibung
5.) Nebenläufige oder sequentielle Umgebungen
5.1.) Nebenläufig
5.2.) Sequentiell
6.) Anweisungen
6.1.) Einfache Verknüpfungen
6.2.) Arithmetische Operatoren
6.3.) with/select
6.4.) when/else
6.5.) if/then
6.6.) case/is


1.) Konventionen
1.1.) Namensregeln

- Zwischen Gross und Kleinschreibung wird in VHDL nicht unterschieden
- ... das übliche

1.2.) Kommentare
- Komentare werden durch doppelten Bindestrich eingeleitet --s

1.3.) Zuweisungen
- Zuweisungen
- Signal an ein anderes Signal
- konstanter Wert an Signal
- Zeichenkombination <=
- Von rechts nach links

Beispiel:

Code: Alles auswählen

Y <= S;
Y <= A or B;
-- Falsch A => Y; -- Falsch

2.) Typologie
- VHDL ist streng typgebundene Sprache

Es genügt:
- boolean
- bit
- std_logic

1.) Typ: boolean
1.1.) Wertevorrat: true, false
1.2.) Verwendung: logische Abfragen (if)
2.) Typ: bit
2.1.) Wertevorrat: 0, 1
2.2.) Verwendung: Entwurf
3.) Typ: std_logic:
2.1.) Wertevorrat: 0, 1, Z, -, L, H, X, W
2.2.) Entwurf und Simulation

Deklartion:

Code: Alles auswählen

signale <signalname>: typ;

signal x0, x1, x2, x3: bit;
signal EN: std_logic;
signal on_of: boolean;

Bei Verknüpfungen müssen einzelne Signale vom selben Typ sein

0: starke 0
1: starke 1
Z: hochohmig
-: don't care
U: unbekannt
X: konflikt
L: Schwache 0
H: Schwache 1
W: Schwaches X

3.) Vektoren
3.1.) Deklaration

Code: Alles auswählen

signal <signalname>: typ (<lower> to <upper>);
signal <signalname>: typ (<upper> downto <lower>);

signal x: bit_vector(0 to 7);
signal a: std_logic_vector(2 to 4);
signal r: bit_vector(3 downto 0);

3.2.) Zuweisungen

Code: Alles auswählen

c <= a or b;
c <= ('1', '0', '0', '0');
c <= "1000";

4.) Aufbau der Schaltungsbeschreibung
4.1.) Header mit Bibliothek und Packageeinbindungen
4.2.) Entity für Schnittstellendefinition
4.3.) Architecture für Funktionsbeschreibung

4.1.) Header
- Definitionen die für Schaltungsbeschreibung gelten sollen

Code: Alles auswählen

library ieee;
use ieee.std_logic_1164.all
use ieee.std_logic_unsigned.all

4.2.) Entity

1.) Eingang
2.) Ausgang
3.) Bidirektional

1.) Eingang: in
2.) Ausgang: out
3.) Bidirektional: inout

Code: Alles auswählen

entity <blockname> is
port
(
    <signalnamen>: <richtung> <typ>;
    <signalnamen>: <richtung> <typ>;
    <signalnamen>: <richtung> <typ>
);
end;

Code: Alles auswählen

entity multiplexer is
port
(
    a0, a1, a2, a3: in bit;
    b0, b1, b2, b3: in bit;
    s:              in bit;
    y0, y1, y2, y3: out bit;
);
end;

Code: Alles auswählen

entity counter is
port
(
    clk: in bit;
    rst: in bit;
    q: out bit_vector (3 downto 0)
);
end;

3.) Die Funktion - Architecture

Code: Alles auswählen

architecture <beschreibungsname> of <blockname> is
-- locale signale 
begin 
-- functionsbeschreibung
end;

Code: Alles auswählen

  
architecture mymux of multiplexer is 
    signal a, b, y: bit_vector (0 to 3);
begin 
    a <= (a0, a1, a2, a3);
    b <= (b0, b1, b2, b3);
    
    y <= a when (s='0') else b;
    
    y0 <= y(0);
    y1 <= y(1);
    y2 <= y(2);
    y3 <= y(3);
end mymux

5.) Nebenläufige oder sequentielle Umgebungen
5.1.) Nebenläufige
5.2.) sequentielle Umgebungen

- In C werden alle Anweisungen hintereinander abgearbeitet
- Anweisungen in VHDL in der Regel nebenläufig, d.h. parallel
- Befindet man sich in einer nebenläufigen oder Sequentiellen Umgebung?


Aus:

Code: Alles auswählen

architecture verhalten of multiplexer is 
    signal a, b, y: bit_vector (0 to 3);
begin 
    a <= (a0, a1, a2, a3);
    b <= (b0, b1, b2, b3);
    
    y <= a when (s='0') else b;
    
    y0 <= y(0);
    y1 <= y(1);
    y2 <= y(2);
    y3 <= y(3);
end verhalten

Wird:

Code: Alles auswählen

architecture mymux of multiplexer is 
    signal a, b, y: bit_vector (0 to 3);
begin 
    a <= (a0, a1, a2, a3);
    b <= (b0, b1, b2, b3);
    
    y <= a when (s='0') else b;
    
    y0 <= y(0);
    y1 <= y(1);
    y2 <= y(2);
    y3 <= y(3);
end mymux

- Die erste umgebung ist nebenläufig


5.2.) Squentielle Umgebung
5.2.1.) Prozess

Code: Alles auswählen

process <empfindlichkeitsliste>
-- lokale signale   
begin 
-- sequentielle umgebung
end process;

- Ist eine Sequentielle Umgebung abgearbeitet, startet die Ausführung von vorne
- Eine parallele Umgebung kann mehrere sequentielle enthalten, die parallel ausgeführt werden
- Empfindlichkeitsliste: Alle signale die sich potentiell ändern können

Code: Alles auswählen

architecture verhalten of counter is
    signal qint: std_logic_vector ( 3 downto 0);
begin 
    process (reset, clk)
    begin 
        if (reset='0') then 
            quint <= x"0";
        elseif (clk='1') and clk'event
        then 
            qint <= qint+1;
        end if;
    end process;
    
    q<=qint;
end;

Variablen im Prozess

Code: Alles auswählen

process ..
    variable V std_logic_vector (3 downto 0);
begin 
    V := ...
end;

6.) Anweisungen
6.1.) Einfache Verknüpfungen
- not
- and
- or
- nand
- nor
- xor
- not
6.2.) Arithmetische Operatoren
- Addition +
- Subtraktion -
- gleich =
- ungleich /=
- kleiner <
- kleiner gleich <=
- groesser >
- groesser gleich >=
6.3.) with/select
- nebenläufig

Code: Alles auswählen

with <auswahlsignal> select 
ergebnis <= <Verknüpfung_1> when <auswahlwert_1>,
            <Verknüpfung_2> when <auswahlwert_2>,
            <Verknüpfung_n> when others;

6.4.) when/else

- nebenläufig

Code: Alles auswählen

<ergebnis> <=   <Verknüpfung_1> when <Bedingung_1>, 
                else <Verknüpfung_2> when <Bedingung_2>, 
                else <Vernüpfung_n>;

6.5.) if/then
- sequentiell

Code: Alles auswählen

if <Bedingung_1>        then <Sequentielle Anweisungen 1>;
elseif <Bedingung_2>    then <Sequentielle Anweisungen 2>;
elseif <Bedingung_3>    then <Sequentielle Anweisungen 3>;
else                         <Sequentielle Anweisungen n>;
end if;

Bedingung muss vom Typ Boolean sein

6.6.) case/is
- wie with/select nur in sequentiell

Code: Alles auswählen

case <testsignal> is
    when <Wert_1> => <Sequentielle Anweisungen 1>;
    when <Wert_2> => <Sequentielle Anweisungen 2>;
    when <Wert_3> => <Sequentielle Anweisungen 3>;
    when others   => <Sequentielle Anweisungen n>; 
end case;

Beispiel Codes:

Code: Alles auswählen

-- 2_zu_1 Multiplexer

entity multiplexer is
port
(
    S:      in bit;
    A, B:   in bit;
    Y:      out bit;
);
end;