Sie sind auf Seite 1von 23

Namen: Torsten Thieme

U-Nr.: U20470
Matrikel-Nr.: 11963
Uwe Kemnitz
U-Nr.: U21434
Matrikel-Nr.:

Beschreibungssprache: VHDL (Very High Speed Integrated Circuit Hardware


Description Language).

Aufgabe: serieller Addierer und serieller Subtrahierer

Aufgabe:

Die Aufgabe bestand darin mit 4 Platinen gleicher Bauart eine Addition und
Subtraktion im Hexadezimalbereich durchzuführen und das Ergebnis auszugeben.
Inhaltsverzeichnis

1. Allgemeine Problemstellung

1.1 Aufgabe

2. Benutzerhandbuch

2.1 Ablaufbedingungen

2.2 Programminstallation und Programmstart

2.3 Bedienungsanleitungen

2.4 Fehlermeldungen

2.5 Wiederanlaufbedingungen

3. Programmierhandbuch

3.1 Entwicklungskonfigurationen

3.2 Problemanalyse und Realisation

3.3 Beschreibungen grundlegender Datenstrukturen

3.4 Programmorganisationen

3.5 EVA-Diagramme

4. Kommentierung
1.Allgemeine Problemstellung:

1.1 Aufgabe :

Die Aufgabe bestand darin mit 4 Platinen gleicher Bauart eine serielle Addition und
Subtraktion im Hexadezimalbereich durchzuführen und das Ergebnis auszugeben.

Die Platine 1 und die Platine 2 dienen bei dieser Aufgabe als Eingabegeräte, diese werden
mit 3 Tastern bedient. Zum Freischalten der Einzelsegmente und Weiterschalten dient der
unten markierte Taster 1, dadurch werden die 7 Segmente der jeweiligen Anzeige zum
Blinken angesteuert, so ist festzustellen welche der 3 verschiedenen Zahlen eingeben
werden.

Taster UP zum
Spannung Hochzählen
Versorgung 5V

Taster Down
Übertragungskabe zum Runter
l zählen
Programmierbar
er Chip

7 Segmentanzeigen
Taster 1
Weiterschalten

Sobald eine der 7 Segmentanzeigen ausgewählt wurde, ist es möglich mit dem Taster UP
oder Down die jeweiligen Ziffern von 0 bis F eingeben zu können. Um Hochzuzählen wird
der jeweilige Taster betätigt bis die gewünschte Zahl erreicht wird.

Nach dem die Zahlen eingegeben sind, ist es möglich auf der Platine 3 zwischen Addition
und Subtraktion auf der Segmentanzeige umzuschalten. Dies kann mit den Schaltern UP
und Down der Platine 3 realisiert werden. Die Platine 3 kann eine serielle Addition und eine
serielle Subtraktion ausführen.

Es muss auch mit den entsprechenden Problemen gerechnet werden die bei einer Addition
oder Subtraktion auftreten, wie z.B. Übertrag bzw. Borgen.

Durch Betätigung mit dem Taster1 der Platine 3 werden die in der 1. und 2. Platine enthalten
Werte, durch die 3x4 Bit Verschiebung in die 3. Platine transferiert. Dort wird die
entsprechende Addition oder Subtraktion durchgeführt und das Ergebnis in die letzte Platine
geschoben (Hexadezimal).
2.Benutzerhandbuch

2.1 Ablaufbedingung

Es müssen alle 4 Platinen mit der Betriebsspannung von 5V betrieben werden und
verbunden sein, sodass man diese auch dementsprechend ansteuern kann. Die
Einzelplatinen lassen sich durch je 3 Taster bedienen.

2.2 Programminstallation und Programmstart

Die Einzelprogramme werden mit Hilfe einer seriellen Schnittstelle auf die einzelnen Platinen
von dem Programm ispLEVER classic aufgespielt.

Sobald das geschehen ist, können die jeweiligen Platinen verwendet werden.

2.3 Bedienungsanleitung

Platine 1 Platine Platine 3 Platine 4


2

Platine 1:

Mit dieser Platine kann man zwischen den 7 Segment Anzeigen durchschalten. Wenn eine
Anzeige gewählt wurde, kann sie mit dem Taster Up oder Taster Down erhöht oder
minimiert werden (Hexadezimal).

Platine2:

Platine2 besitzt dieselbe Funktionalität wie Platine 1.

Platine3:

Bei dieser Platine kann man zwischen Addition und Subtraktion umschalten. Die Werte der
Platine 1 und 2 werden in die Platine 4 mit einem Schieberegister weitergeleitet.

Platine4:

In dieser Platine wird das Ergebnis der zuvor in Platine 3 berechneten Werte gespeichert
und angezeigt.
2.4 Fehlermeldungen

Es sollen keine Fehlermeldungen in den Einzelplatinen angezeigt werden. Es können Fehler


in Programmfragmenten erscheinen die auf dem Rechner erzeugt werden. Diese kommen
zustande, wenn ein CPLD (Complex Programmable Logic Device) grenzwertig wird und zu
einem Programmfehler führt.

2.5 Wiederanlaufbedingung

Wenn die Addition oder Subtraktion durchgeführt wird, können jederzeit die Werte geändert
werden um eine Berechnung durchführen zu können.

3.Programmierhandbuch

3.1 Entwicklungskonfigurationen

Das gesamte Programm wurde auf einem Rechner mit Windows XP mit der dazugehörigen
Software ispLever, isp VM System erstellt und aufgespielt.

3.2 Problemanalyse und Realisation

Problematisch ist es, sich mit den Einzelkomponenten auseinander zu setzen. Diese werden
auf einer Testplatine getestet mit den jeweilig selbst geschriebenen Programmen
Taster zum
Hochzählen
Programm
Schnittstelle
Taster zum
Runterzählen

Spannungsv
ersorgung
über USB 7 Segmentanzeigen

Programmierbar
er Chip Taster zum
Weiterschalten

Platine 1 und 2 sind fast identisch, sie unterscheiden sich nur in der Pin Belegung zur
Weiterleitung, es ist zu überlegen, wie man die Zahlen darstellt und zwischen den
Segmenten durchschaltet und diese weitergibt zur Platine3.

Es ist wie folgt vorzugehen: Es wird ein Zähler mit der entsprechenden Segmentansteuerung
realisiert. Dort ist ein Fehler aufgetreten, der von dem weiterschaltenden Signal bei
ansteigender Flanke, Prellen (mehrfaches Schalten bei einer Schaltsequenz) verursacht
wird. Dieses wird mit einem 2 flankengesteuertem D-FlipFlop und einer logischen &
Verknüpfung gelöst.
Nach dem das erledigt ist, können die Zähler hochlaufen bzw. runter laufen. Damit die
Zahlen weitergereicht werden, musste ein 3x4 Bit Schieberegister entwickelt werden welche
später direkt in die zähler indigiert wurden um Macrozellen zu sparen . Die Schieberegister
sind dazu notwendig die 7 Segmente der einzelnen Anzeigen zu verschieben, sodass die
Zahlen in die 3. Platine übertragen werden.

Probleme: Es sind folgende Probleme aufgetreten. Die Größe der Einzelkomponenten


konnten nicht auf denn CPLD (Complex Programmable Logic Device)
aufgebracht werden, da in diesem nicht so viel Speicherplatz vorhanden ist.

Es werden folgende Programme aufgespielt:

- Entprellung, zum Verhindern des Mehrfachzählens bei der Flankensetzung

- ZT1 zum hoch oder runter zählen

- ZT2 zum Durchlaufen der Segmentanzeigen

In der 3. Platine ist ein seriellen Addierer und einen seriellen Subtrahierer realisiert, so dass
die von Platine 1 und Platine 2 Werte addiert oder subtrahiert wurden.

Die Anzeige für Add und Sub wurde wie in Platine 1 und 2 ausgegeben, so dass es
ersichtlich ist in welcher Operation die Platine 3 arbeitet.

Probleme: Geringfügige Probleme gab es nur mit dem Überlauf und dem Borgen bei der
Addition und bei der Subtraktion.

Es werden folgende Komponenten aufgespielt:

-serieller Addierer welcher aus einem Volladdierer Entstanden ist

-serieller Subtrahierer welcher aus einem Vollsubtrahierer Entstanden ist

-Ausgabe von ADD / SUBtrahend

-Eine komponente welche speichert ob Addiert oder subtrahiert werden soll

-Eine Komponente die endweder die Ergebnisse von ADD oder SUB weitergibt

-Ein Zähler der die länge der Übertragung festlegt

In der 4. Platine wird nur eine Ausgabe realisiert. Die Werte die in diese Platine geschoben
werden sind auf der 7 Segmentanzeige ersichtlich.

Die 7 Segmentanzeige aus Platine 1 und 2 wird identisch übernommen um die Zahlen
auszugeben.
3.3 Beschreibung grundlegender Datenstrukturen

Jedes der Programme besteht aus einem Grundgerüst wo Eingänge und Ausgänge
beschrieben werden.

Bild:

In diesem Rahmen werden jetzt alle anderen Prozesse oder Komponenten festgelegt auch
die logischen Abfragen wie if und else Anweisungen. (if/else in Prozess)

Um die Übersichtlichkeit zu gewährleisten werden diese Programme in einem


übergeordneten Programm eingebunden, dies nennt man Instanziieren.

Die entsprechenden
Komponenten zu den
Instanzen

Instanzen
3.4 Programmorganisation 7
Segmentanzeigen
Übertragungsleitungen

Platine 1 Platine Platine 4 Platine 3


2
3.5 EVA-Diagramme

Platine 1 und Platine 2

Entprellu Zähler zum


ng durchschalte
n

Zähler zum
hoch und
runter zählen
mit der
Ausgabe auf
die 7
Segmente der
Anzeige

Weitergabe
der Zahlen zur
Platine 3
Platine 3
Weitergabe der
umgerechneten
Zahlen in Platine
4
Zahlen von
Platine 1 und 2

Auswahl der
Addition oder
Subtraktion

Übertrag oder
Borgen bei
Addition und
Anzeige über
Subtraktion
Addition oder
Subtraktion

Schieberegiste
r

Platine 4

Schieberegiste
r
Anzeige des
Ergebnisses
aus Platine 3

Zahlen von
Platine 3
Kommentierung
library ieee;
use ieee.std_logic_1164.all;

entity Platiene1 is
port ( schalterUp :in std_logic; -- Taster zum hochzählen
schalterDown :in std_logic; -- Taster zum runterzählen
schalterWahl :in std_logic; -- Taster zum segmente durschalten
clock:in std_logic; -- Schiebe und zähltakt (systemtakt)
clockslow:in std_logic; -- Takt zum Blinken
UebertragungAktiv :in std_logic; -- Bit um Übertragung aktiv zu schalten
S0: out std_logic_vector (0 to 6);
S1: out std_logic_vector (0 to 6);
S2: out std_logic_vector (0 to 6);
BitLeitung: out std_logic); -- Serieller ausgang der platiene
end;

architecture struktur of Platiene1 is


-------------------------------------------------
component entprel
port (schalter : in std_logic ; -- asynchroner Eingang
clk : in std_logic ; -- Abtasttakt
quit : out std_logic); -- Ausgangssignal
end component;
-----&&&&&&-----
component zt1
port (up, clk: in std_logic; -- up zähler hochzählen, clk event Takt
q: out std_logic_vector (2 downto 0));-- ausgang des multiplexers
end component;
-----&&&&&&-----
component zt2
port ( clk: in std_logic; -- Takt 32 Hz
-- Übertragungstakt und der Takt für den Zähler st der gleich da sonst
-- ein Multiplever mit dem Takt erzeugt wird
blink: in std_logic; -- langsammer Takt um segmente blinken zu lassen
Send_Enable: in std_logic;--wenn aktiv, Uebertragung mit Bitrate 32 Hz
Count_Enable, Count_Up, Count_Down : in std_logic;-- Steuersig. Zähler
Seriell_In: in std_logic; -- serieller eingang der vorwerte beim schieben
Seriell_Out: out std_logic; -- serieller ausgang beim Schieben
SevSeg: out std_logic_vector(0 to 6)); -- sieben segment ausgang
end component;
-----------------------------------------------------
signal schalterUpE, schalterDownE, schalterWahlE: std_logic; -- Signalleitungen
-- von den enprell instanzen in die anderen bausteine
signal Mode: std_logic_vector(2 downto 0);-- Signalleitungen vom ZT1 in die ZT2's
signal BN0, BN1, BN2: std_logic;-- Serielle Leitungen zwichen den Bausteinen

begin
inst1: entprel port map (clock,schalterUp,schalterUpE);
-- Entprell instanz für den HochSchalter
inst2: entprel port map (clock,schalterDown,schalterDownE);
-- Entprell instanz für den RunterSchalter
inst3: entprel port map (clock,schalterWahl,schalterWahlE);
-- Entprell instanz für den WahlSchalter
inst4: zt1 port map (schalterWahlEn,clock,Mode);
--ZT1 instanz um festzulegen welcher ZT2 aktiv ist
inst5:zt2 port
map(clock,clockslow,UebertragungAktiv,Mode(0),schalterUpE,SchalterDownE,BN1,BN0,S0)
;
inst6:zt2 port
map(clock,clockslow,UebertragungAktiv,Mode(1),schalterUpE,SchalterDownE,BN2,BN1,S1)
;
inst7:zt2 port
map(clock,clockslow,UebertragungAktiv,Mode(2),schalterUpE,SchalterDownE,BN0,BN2,S2)
;
-- 3 mal ZT2 istanzen zum zählen schieben und sieben segment ausgabe
Bitleitung <= BN0;
end struktur;
Zählertyp 2
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

entity zt2 is
port ( clk: in std_logic; -- Takt 32 Hz
-- Übertragungstakt und der Takt für den Zähler st der gleich da sonst
-- ein Multiplever mit dem Takt erzeugt wird
blink: in std_logic; -- langsammer Takt um segmente blinken zu lassen
Send_Enable: in std_logic;--wenn aktiv, Uebertragung mit Bitrate 32 Hz
Count_Enable, Count_Up, Count_Down : in std_logic;-- Steuersig. Zähler
Seriell_In: in std_logic; -- serieller eingang der vorwerte beim schieben
Seriell_Out: out std_logic; -- serieller ausgang beim Schieben
SevSeg: out std_logic_vector(0 to 6)); -- sieben segment ausgang
end;

architecture behavioral of zt2 is


-- ########## ########## ########## ########## ########## ##########
function SegFkt (BiCode: std_logic_vector(3 downto 0))
return std_logic_vector is variable SevSegCode: std_logic_vector(0 to 6);

begin -- Umkodierungsnetzwerk Bin aud siebensegment ausgelagert


CASE BiCode IS
WHEN "0000" => SevSegCode := "0000001"; -- 0
WHEN "0001" => SevSegCode := "1001111"; -- 1
WHEN "0010" => SevSegCode := "0010010"; -- 2
WHEN "0011" => SevSegCode := "0000110"; -- 3
WHEN "0100" => SevSegCode := "1001100"; -- 4
WHEN "0101" => SevSegCode := "0100100"; -- 5
WHEN "0110" => SevSegCode := "0100000"; -- 6
WHEN "0111" => SevSegCode := "0001111"; -- 7
WHEN "1000" => SevSegCode := "0000000"; -- 8
WHEN "1001" => SevSegCode := "0000100"; -- 9
WHEN "1010" => SevSegCode := "0001000"; -- A
WHEN "1011" => SevSegCode := "1100000"; -- B
WHEN "1100" => SevSegCode := "1110010"; -- C
WHEN "1101" => SevSegCode := "1000010"; -- D
WHEN "1110" => SevSegCode := "0110000"; -- E
WHEN OTHERS => SevSegCode := "0111000"; -- F
END CASE;
return SevSegCode;
end function;
-- ########## ########## ########## ########## ########## ##########
signal BinWert : std_logic_vector (3 downto 0);
signal SevWert : std_logic_vector (0 to 6);

begin
process (clk)
begin
-- ########## ########## ########## ########## ########## ##########
if clk'event and clk='1' then -- bei ansteigender Taktflanke
if (Send_Enable='0' ) then --wenn nicht übertragen wird dann zähler aktiv

if(Count_Up and Count_Enable)='1' then--wenn zähler aktiv und hochzählen


BinWert <= BinWert + '1'; --dann zähler erhöhen
elsif(Count_Down and Count_Enable)='1'then--wenn zähler akt.und runterz.
BinWert <= BinWert - '1'; -- dann zähler vermindern
end if;

if(Count_Enable and blink)='1'then--wenn zähl.und blink dann ausschalten


-- um aktiven zähler blinken zulassen
SevSeg<="1111111"; -- segment ausschalten
else
SevSeg<=SegFkt(BinWert);--zählerwert ausgeben wenn display aktiv
end if;
else
BinWert<=Seriell_In & BinWert(3 downto 1);--wenn ubertr.akt.dann schiebe
end if;
end if;
-- ########## ########## ########## ########## ########## ##########
end process;

Seriell_Out <= BinWert(0); -- Taktunabhänige signalweitergabe


end behavioral;
Zählertyp 1
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity zt1 is
port (up, clk: in std_logic; -- up zähler hochzählen, clk event Takt
q: out std_logic_vector (2 downto 0));-- ausgang des
multiplexers
end;

architecture bhv of zt1 is

signal value : std_logic_vector (1 downto 0); -- Zähler


register/FlipFlop's

begin
process (clk) -- syncon abhängig von clk
begin
if clk'event and clk = '1' then -- bei TaktFlanke
if (up = '1') then -- und erhöhungsbedinging
value <= value +"01"; -- erhöhen um eins
end if;
end if;
end process;
q(0)<= value(0) and not value(1); -- Taktunabhängiger Multiplexer
q(1)<= not value(0) and value(1); -- Taktunabhängiger Multiplexer
q(2)<= value(0) and value(1); -- Taktunabhängiger Multiplexer
end bhv;

Entprellung

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

entity entprel is
port (schalter : in std_logic ; -- asynchroner Eingang
clk : in std_logic ; -- Abtasttakt
quit : out std_logic); -- Ausgangssignal
end;

architecture behavioral of entprel is


signal D, DD : std_logic; -- zwei FlipFlop's
begin
process(clk)
begin
if(clk'event and clk = '1')then -- reaktion auf Taktflanke
D <= schalter; -- Bei Taktflanke übernehmen
DD <= D; -- Bei Taktflanke übernehmen
end if;
end process;
quit <= D and not DD; -- Taktunabhänige und Verknüpfung
end behavioral;
HaupProgramm Platiene 3

library ieee;
use ieee.std_logic_1164.all;

entity platiene3 is -- Platiene 3 ist das Main File für die


-- Platiene die die addition und subtraktion
realisiert
-- hier wird auch der Takt und die Übertragung
organisiert
port (Tplus: in std_logic; -- Taster um in Add Mode zu gehen
Tminus: in std_logic; -- Taster um in Sub Mode zu gehen
clk: in std_logic; -- Eingangstakt vom Platienenquarz
platiene1: in std_logic; -- Serieller Eingang von Platiene 1
platiene2: in std_logic; -- Serieller Eingang von Platiene 2
start:in std_logic; -- Taster um die Übertragung zu starten

platiene4: out std_logic; -- Serieller Ausgang mit dem Ergemniss


Uebertragung: out std_logic; -- Zeigt den anderen Platienen,
-- das übertragen werden soll
SystemTakt: out std_logic; -- Giebt den Quarztakt auf die Leitung
segm1: out std_logic_vector (0 to 6); -- Ausgabe von Sub oder Add
segm2: out std_logic_vector (0 to 6); -- Ausgabe von Sub oder Add
segm3: out std_logic_vector (0 to 6)); -- Ausgabe von Sub oder Add
end;

architecture behavioral of platiene3 is

----------------------------------------------
component Serieladd -- Serieller addierer welcher aus dem
-- volladdierer entseht und den ubertrag speichert
port (ai: in std_logic; -- 1. Summand seriell
bi: in std_logic; -- 2. Summand seriell
clk: in std_logic; -- Takt
ergebniss: out std_logic); -- Ergebniss seriell
end component;
----------------------------------------------
component Serielsub -- Serieller subtrahierer welcher aus dem
-- vollsubtrahierer entseht und den ubertrag speichert
port (ai: in std_logic; -- Minuend seriell
bi: in std_logic; -- Subtrahend seriell
clk: in std_logic; -- Takt
ergebniss: out std_logic); -- Ergebniss seriell
end component;
----------------------------------------------
component ZT3 -- ein zähler der bis 12 zält und sich dan zurücksetzt
-- und solage die übertragung aktiv hält
port ( clk: in std_logic; -- Takt
Los: in std_logic; -- Startsignal um 12 Takte Aktiv zu sein
aktiv : out std_logic); -- wird während des zählens aktiv gesetzt
end component;
----------------------------------------------
component seg -- giebt abhängig von zustand add oder sub
-- auf den ersten 3 segmenten aus
port (zustand: in std_logic;-- zustand add oder sub
seg1: out std_logic_vector(0 to 6); -- ausgabe segmente
seg2: out std_logic_vector(0 to 6); -- ausgabe segmente
seg3: out std_logic_vector(0 to 6)); -- ausgabe segmente
end component;
----------------------------------------------
component zustand -- speichert ob plus oder minus
port (plus :in std_logic; -- setzt auf Plus
minus :in std_logic; -- setzt auf minus
Aktiv :in std_logic; -- sperrt/erlabt änderungen
zustand: out std_logic); -- ausgabe des gespeicherten zustands
end component;
----------------------------------------------
component Wahl -- je nach zustand von zustand wird die addition
-- oder subtraktion durchgereicht
port (add :in std_logic; -- serieller eingang von der addition
sub :in std_logic; -- serieller eingang von der subtraktion
zustand :in std_logic; -- zustand ob add oder sub
ausgang :out std_logic); -- serieller ausgang
end component;
----------------------------------------------

signal modus: std_logic; -- Signalleitung für add oder sub modus


signal uetakt: std_logic; -- Signalleitung für Takt
signal InProccess: std_logic; -- Signalleitung für serielle
-- Übertragung Aktiv/inaktiv
signal subL: std_logic; -- Signalleitung für Additions ergebnisse
signal addL: std_logic; -- Signalleitung für Subtraktions ergebnisse

begin

inst1: Serieladd port map (platiene1, platiene2,uetakt, addL );


-- instanz für die serielle addition
inst2: Serielsub port map (platiene1, platiene2,uetakt,subL );
-- instanz für die serielle subtraktion
inst3: ZT3 port map (clk, start, InProccess);
-- instanz für den zähler der die übertragungslänge bestimmt
inst4: seg port map (modus,segm1,segm2,segm3);
-- instanz für das register welche den modus an den uder ausgiebt
inst5: zustand port map (Tplus,Tminus,InProccess,modus);
-- instanz welche den modus/zustand speichert
-- und anderen zur verfügung stellt
inst6: Wahl port map (addL,subL,modus,platiene4);
-- instanz welche je nach modus die addition oder subtraktion
durchreicht

SystemTakt<= clk; -- Leitungsverbindung des Taktes


Uebertragung<=InProccess; -- Leitungsverbindung Übertragung
Aktiv/inaktiv

end behavioral;
Segmentansteuerung

Volladdierer
Serieller Addierer
Vollsubtrahierer
Serieller Subtrahierer

Wahl Add / Sub


Speicher für Den Zustand

ZählerTyp 3
Main Platiene 4
library ieee;
use ieee.std_logic_1164.all;

entity platine4 is
port( BitLeitung: in std_logic; --Serielle Biteing. Leitung von
Platiene 3
Systemtakt: in std_logic; -- Systemtakt von Platiene 3
Uebertragung: in std_logic; -- Signal ob Übertragung aktiv
Seg0: out std_logic_vector (0 to 6); -- Segmentanzeigen ausgänge
Seg1: out std_logic_vector (0 to 6); -- Segmentanzeigen ausgänge
Seg2: out std_logic_vector (0 to 6)); -- Segmentanzeigen ausgänge
end;

architecture struktur of platine4 is


----------------------------------------------
component SREG12B -- Serielles Schieberegister mit paralelem Ausgang
port (SeriellerEingang: in std_logic; -- Serieller Eingang von
Plattiene 3
clock: in std_logic; -- Übertragungstakt
Aktiv: in std_logic; -- darf übertragen werden?
Quit: out std_logic_vector(11 downto 0)); -- paraleler ausgang
end component;
----------------------------------------------
component Binausgabe -- Codiert von Binär auf 7 segment und speichert
port ( uebernahme :in std_logic; -- Eingang des Übertragung-aktiv
signals
BinWert :in std_logic_vector(3 downto 0); -- Eingang für die
Binwerte
segm: out std_logic_vector (0 to 6)); -- Ausgabe in sieben Seg.
code
end component;
----------------------------------------------

signal BinWert: std_logic_vector(11 downto 0);-- signalleitung zum


-- Durchreichen der
Binwerte
begin

inst1: SREG12B port map (BitLeitung,Systemtakt,Uebertragung,BinWert);


-- instanz des Eingangs Schieberegisters
inst2: Binausgabe port map (Uebertragung, BinWert(11 downto 8),Seg2);
-- instanz der Ausgabe für ein Segment
inst3: Binausgabe port map (Uebertragung, BinWert( 7 downto 4),Seg1);
-- instanz der Ausgabe für ein Segment
inst4: Binausgabe port map (Uebertragung, BinWert( 3 downto 0),Seg0);
-- instanz der Ausgabe für ein Segment

end struktur;
Ausgabenetzwerk mit speicher

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

entity Binausgabe is -- Codiert von Binär auf 7 segment und speichert


port ( uebernahme: in std_logic; -- Eingang des Übertragung-aktiv
signals
BinWert: in std_logic_vector(3 downto 0); -- Eingang für die
Binwerte
segm: out std_logic_vector (0 to 6)); -- Ausgabe in siben
Segmentcode
end;

architecture behavioral of Binausgabe is

begin
process (uebernahme) -- prozess syncron abhängig von der übernahme
begin

if uebernahme'Event and uebernahme = '0' then --Wenn übertragung


zuende
if (BinWert = "0000") then segm <= "0000001"; --0
elsif (BinWert = "0001") then segm <= "1001111"; --1
elsif (BinWert = "0010") then segm <= "0010010"; --2
elsif (BinWert = "0011") then segm <= "0000110"; --3
elsif (BinWert = "0100") then segm <= "1001100"; --4
elsif (BinWert = "0101") then segm <= "0100100"; --5
elsif (BinWert = "0110") then segm <= "0100000"; --6
elsif (BinWert = "0111") then segm <= "0001111"; --7
elsif (BinWert = "1000") then segm <= "0000000"; --8
elsif (BinWert = "1001") then segm <= "0000100"; --9
elsif (BinWert = "1010") then segm <= "0001000"; --A
elsif (BinWert = "1011") then segm <= "1100000"; --B
elsif (BinWert = "1100") then segm <= "1110010"; --C
elsif (BinWert = "1101") then segm <= "1000010"; --D
elsif (BinWert = "1110") then segm <= "0110000"; --E
elsif (BinWert = "1111") then segm <= "0111000"; --F
end if; -- entsprechenden Wert übernehmen
end if;

end process;
end behavioral;
Schieberegister mit paralelem ausgang

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

entity SREG12B is -- Serielles Schieberegister mit paralelem Ausgang


port (SeriellerEingang: in std_logic; -- Serieller Eingang von
Plattiene 3
clock: in std_logic; -- Übertragungstakt
Aktiv: in std_logic; -- darf übertragen werden?
Quit: out std_logic_vector(11 downto 0)); -- paraleler ausgang
end SREG12B;

architecture behavior of SREG12B is

signal Q: std_logic_vector(11 downto 0);-- Speicher register 12 Bit


begin
process(clock) -- syscroner process
begin
if clock'event and clock = '1' then -- Bei steigender Flanke
if Aktiv = '1' then -- und aktiver übertragung
Q <= SeriellerEingang & Q(11 downto 1); --
Schieben
end if;
end if;
end process;
Quit <= Q; -- Signalzuweisung
end behavior;