Praktikum vorlesungsbegleitend zu Signale und Systeme B...6 Beispielprogramm (2:1 Multiplexer) ... Signale und Systeme B – Praktikum – Programmierung logischer Schaltungen 7 Ein

Fakultät für Elektrotechnik und Informationstechnik

AG Bildsignalverarbeitung Prof. Dr. rer. nat. Christian Wöhler

Praktikum vorlesungsbegleitend zu

Signale und Systeme B

"Programmierung logischer Schaltungen"

Anleitung

Version: Juni 2017

Betreuung:

M.Sc. Malte Lenoch

Telefon: 0231 / 755-4518

Raum: P1-04-212 (Physikgebäude)

E-Mail: [email protected]

Versuchsraum:

P1-04-207

Aktuelle Informationen: http://www.bv.e-technik.tu-dortmund.de/

Ursprünglicher Versuch: "V203: Programmierung logischer Felder"

AG Schaltungen der Informationsverarbeitung, Prof. Dr.-Ing. Hartmut Schröder

Signale und Systeme B – Praktikum – Programmierung logischer Schaltungen 2

Inhalt

1 Einleitung ...................................................................................................................... 2

2 Grundlagen logischer Schaltungen ................................................................................. 2

2.1 Schaltnetze .................................................................................................................... 2

2.2 Minimierung Boolescher Funktionen ............................................................................ 3

2.2.1 Minimierung nach dem Verfahren von Quine-McCluskey 3

2.3 Schaltwerke ................................................................................................................... 6

2.3.1 Entwurf von Schaltwerken 7

3 Programmierbare Logikbausteine .................................................................................. 9

4 Literaturverzeichnis ..................................................................................................... 17

5 Testboard ................................................................................................................... 18

6 Beispielprogramm (2:1 Multiplexer) ............................................................................ 20

7 Aufgabenstellung ........................................................................................................ 25

7.1 Implementierung eines Multiplexers .......................................................................... 25

7.2 Dualzahlausgabe auf einer Siebensegmentanzeige .................................................... 25

7.3 Modulo-4-Zähler mit Reset ......................................................................................... 28

7.4 ALU mit 4 Rechenarten ............................................................................................... 31

1 Einleitung Logische Schaltungen lassen sich auf verschiedenen Integrationsebenen realisieren. Neben integrierten Standardbauelementen stehen dem Entwickler u.a. programmierbare ICs wie PROMs, FPLAs, PALs und GALs zur Verfügung. Der Versuch soll den Entwurf digitaler Schaltun-gen mit programmierbaren Logikbausteinen (Programmable Logic Devices, PLDs) vorstellen.

Der im Versuch verwendete Baustein M4LV-64/32 der Firma Lattice vereinigt 4 PAL-Blöcke in einem Baustein und ermöglicht die Verschaltung dieser Blöcke untereinander. Dies ermöglicht die Implementierung wesentlich komplexerer logischer Schaltungen als mit einfachen PAL-Blöcken. Daher wird der Baustein zur Familie der Complex Programmable Logic Devices (CPLDs) gezählt.

Die höhere Komplexität der Bausteine führt dazu, dass ein Handentwurf nicht mehr möglich ist, sondern ein von einem Rechner unterstützter Entwurf erforderlich ist. Die heutige Ent-wicklungssoftware ermöglicht zusätzlich eine weitgehende Schaltungssimulation, mit deren Hilfe bereits vor dem Hardwareaufbau logische Fehler entdeckt werden können.

2 Grundlagen logischer Schaltungen

2.1 Schaltnetze Als Basis für die Entwicklung logischer Schaltungen dient die Boolesche Algebra. Sie geht zu-rück auf den englischen Mathematiker Boole, der logische Zusammenhänge in einer zweiwer-tigen Logik formulierte.


Schaltnetze stellen die schaltungstechnische Realisierung Boolescher Funktionen dar. Die Ausgangsgrößen a1, a2

... am hängen zu jedem beliebigen Zeitpunkt allein von den Werten der

Eingangsvariablen e1, e2 ... en ab. Rückführungen von Ausgangsgrößen auf die Eingänge sind

nicht erlaubt, bzw. sie müssen in eine rückführungsfreie Anordnung umzuformen sein.

Bild 2.1: Logische Schaltung

2.2 Minimierung Boolescher Funktionen Um Boolesche Funktionen mit einem möglichst einfachen Schaltnetz zu realisieren, werden verschiedene Minimierungsverfahren angewandt. Man unterscheidet

1. algebraische Verfahren,

2. graphische Verfahren und

3. tabellarische und algorithmische Verfahren

Erstere Verfahren beruhen auf der Anwendung der Rechenregeln der logischen Algebra. Sie erfordern Intuition und Erfahrung, während sich die übrigen Verfahren weitgehend systema-tisieren lassen. Zu den graphischen Verfahren gehört die Minimierung mit Hilfe von Karnaugh-Veitch (KV)-Diagrammen. Es eignet sich zur Minimierung von Booleschen Funktionen bis ma-ximal 6 Variablen. Für eine genaue Darstellung des Verfahrens sei hier auf die Literatur ver-wiesen. Die heutige Entwurfssoftware führt bereits eine automatische Minimierung durch, die eine Vereinfachung der Funktionen per Hand überflüssig macht. Ein für die Rechnerim-plementierung günstiges Verfahren, das auch in der Lage ist, Funktionen mit einer großen Zahl von Variablen zu minimieren, wurde von Quine und McCluskey entwickelt. Es soll im Fol-genden näher beschrieben werden.

2.2.1 Minimierung nach dem Verfahren von Quine-McCluskey

Das Quine-McCluskey-Verfahren basiert wie die Übrigen auf der Vereinfachung von Termen, die sich nur in einer Variable unterscheiden. In diesem Fall wird jedoch die Suche nach sol-chen Termen systematisch betrieben. Am Ende des Suchverfahrens sind die "Primterme" der Funktion ermittelt. Ein "Primterm" einer Funktion ist eine Konjunktion (UND-Verknüpfung), aus der sich keine Variable streichen lässt, ohne den Wert der Funktion zu ändern. Im KV-Diagramm sind Primterme anschaulich Blöcke mit einer maximalen Zahl von Einsen. In dem in Bild 2.2 dargestellten KV-Diagramm sind die Blöcke 1, 2 und 3 Primterme. Ein Primterm wird als "wesentlicher Primterm" bezeichnet, falls er eine 1 enthält, die in keinem anderen Primterm enthalten ist. Dies trifft hier nur für die Blöcke 1 und 3 zu.


Bild 2.2: Wesentliche Primterme im KV-Diagramm

Zu Beginn des Verfahrens wird die Wertetabelle der zu vereinfachenden Funktion aufgestellt. In unserem Beispiel ist es die Funktion y, die von Variablen a, b, c und d abhängt (Tabelle 2.1).

Nr. a b c d y

0 0 0 0 0 0

1 0 0 0 1 1

2 0 0 1 0 1

3 0 0 1 1 0

4 0 1 0 0 1

5 0 1 0 1 1

6 0 1 1 0 1

7 0 1 1 1 0

8 1 0 0 0 0

9 1 0 0 1 0

10 1 0 1 0 1

11 1 0 1 1 0

12 1 1 0 0 1

13 1 1 0 1 1

14 1 1 1 0 1

15 1 1 1 1 0

Tabelle 2.1: Beispielfunktion zum Quine-McCluskey-Verfahren

In einer weiteren Tabelle werden alle Minterme eingetragen, für die die Funktion erfüllt ist, d.h. den Wert 1 annimmt. Die Minterme werden nach der Anzahl der Einsen gruppiert (Tabelle 2.2).


Nr. a b c d zusammen-

gefasste Terme 1. Ordnung

a b c d zusammen-

gefasste Terme 2. Ordnung

a b c d

1 0 0 0 1 √ 1,5 0 - 0 1 A 2,6;10,14 - - 1 0 B

2 0 0 1 0 √ 2,6 0 - 1 0 √ 2,10;6,14 - - 1 0 (doppelt)

4 0 1 0 0 √ 2,10 - 0 1 0 √ 4,5;12,13 - 1 0 - C

5 0 1 0 1 √ 4,5 0 1 0 - √ 4,6;12,14 - 1 - 0 D

6 0 1 1 0 √ 4,6 0 1 - 0 √ 4,12;5,13 - 1 0 - (doppelt)

10 1 0 1 0 √ 4,12 - 1 0 0 √ 4,12;6,14 - 1 - 0 (doppelt)

12 1 1 0 0 √ 5,13 - 1 0 1 √

13 1 1 0 1 √ 6,14 - 1 1 0 √

14 1 1 1 0 √ 10,14 1 - 1 0 √

12,13 1 1 0 - √

12,14 1 1 - 0 √

Tabelle 2.2: Minimierung mit dem Quine-McCluskey-Verfahren

Jeder Term einer Gruppe wird nun mit den Termen der benachbarten Gruppen verglichen. Ausdrücke, die sich jeweils nur in einer Variablen unterscheiden, werden durch Streichen der unterschiedlichen Stelle vereinfacht. Die zusammengefassten Terme werden mit einem Ha-ken gekennzeichnet. Die nicht abgehakten Terme lassen sich nicht weiter vereinfachen und stellen somit Primterme dar.

Die Terme werden nun erneut zu Gruppen zusammengefasst, und nach dem gleichen Verfah-ren weiter vereinfacht. Gleichzeitig wird mit in die Tabelle aufgenommen, aus welchen Aus-drücken die Terme hervorgegangen sind. Durch die Vereinfachungen kann es vorkommen, dass verschiedene Zusammenfassungen auf gleiche Terme führen, von denen nur jeweils ei-ner berücksichtigt werden muss. Die mit A, B, C und D gekennzeichneten Ausdrücke stellen die Primterme dar. Die disjunktive Verknüpfung aller Primterme ergibt

𝑦 = 𝑎 ∧ 𝑐 ∧ 𝑑 ∨ 𝑐 ∧ 𝑑 ∨ 𝑏 ∧ 𝑐.

In der minimalen disjunktiven Form sind nicht notwendigerweise alle Primterme enthalten. Im KV-Diagramm (Bild 2.3) ist ersichtlich, dass der Term 𝑏 ∧ 𝑑 nicht "wesentlich" ist.

Bild 2.3: Bestimmung wesentlicher Primterme im KV-Diagramm


√ 1

√ 2

√ 4

√ 5

√ 6

√ 10

√ 12

√ 13

√ 14

A: 1, 5 * *

B: 2, 6; 10, 14 * * * *

C: 4, 5; 12, 13 * * * *

D: 4, 6; 12, 14 * * * *

Tabelle 2.3: Bestimmung wesentlicher Primterme beim Quine-McCluskey-Verfahren

Das Quine-McCluskey-Verfahren verwendet zur Bestimmung der wesentlichen Primterme eine Tabelle, in der die Minterme in den Spalten und die Primterme in den Zeilen eingetragen sind (Tabelle 2.3). Innerhalb der Tabelle sind die Minterme, die in einem Primterm zusam-mengefasst sind, mit einem Stern gekennzeichnet. In der ersten Zeile für Primterm A werden z.B. die Spalten 1 und 5 mit einem Stern markiert.

Dann werden die Spalten gewählt, die nur einen Stern enthalten. Im betrachteten Beispiel sind dies die Spalten 1, 2, 10 und 13. Damit sind die wesentlichen Primterme A, B und C fest-gelegt. Die Minterme, die mit den Primtermen A, B und C erfasst sind, können abgehakt wer-den. Jetzt muss überprüft werden, ob Spalten in der Tabelle enthalten sind, die noch nicht mit den Primtermen A, B und C erfasst wurden. Dies ist nicht der Fall, und die Lösung ergibt sich zu:

𝑦 = 𝑎 ∧ 𝑐 ∧ 𝑑 ∨ 𝑐 ∧ 𝑑 ∨ 𝑏 ∧ 𝑐.

Falls irgendwelche Terme noch nicht erfasst sind, müssen weitere Zeilen ausgewählt werden, bis alle Terme abgedeckt sind. Ziel ist es dann, alle Terme mit einer minimalen Zahl von Zeilen zu erfassen, und dabei, falls möglich, die Primterme mit den wenigsten Variablen zu verwen-den.

2.3 Schaltwerke Schaltnetze sind dazu geeignet, kombinatorische Operationen wie z.B. Addition oder Codie-rung zu realisieren. Schaltnetze können jedoch aufgrund der fehlenden Rückkopplung keine Informationen speichern oder sequentielle Algorithmen abarbeiten. Für diese Aufgaben müs-sen Schaltwerke erstellt werden. Das allgemeine Blockschaltbild eines Schaltwerks entspricht der in Bild 2.4 dargestellten Skizze.

SCHALTNETZ

VERZÖGERUNGbzw. Zustands-

speicher

Ausgangsvektor yEingangsvektor x

Zustands-vektor u

Registerkontroll-vektor v

Bild 2.4: Blockschaltbild eines Schaltwerkes


Ein Schaltwerk besteht prinzipiell aus einem rückgekoppelten Schaltnetz mit Verzögerungs- bzw. Speicherbausteinen als Zustandsspeicher in der Rückführung. Die Variablen, welche die früheren Eingaben oder den Zustand des Schaltkreises vor den momentanen Eingaben spei-chern, heißen entsprechend Zustandsvariablen. Zur Kennzeichnung der zeitlichen Abhängig-keit wurde der Sequenzindex n eingeführt. Es gilt für den:

• Eingangsvektor: 𝑥𝑛 = { 𝑥1𝑛, 𝑥2

𝑛 , . . . . , 𝑥𝑀𝑛}

• Ausgangsvektor: 𝑦𝑛 = { 𝑦1𝑛,𝑦2

𝑛 , . . . . ,𝑦𝐼𝑛}

• Zustandsvektor: 𝑢𝑛 = { 𝑢1𝑛, 𝑢2

𝑛 , . . . . ,𝑢𝐾𝑛}

• Registerkontrollvektor: 𝑣𝑛 = { 𝑣1𝑛, 𝑣2

𝑛 , . . . . , 𝑣𝐿𝑛}

Eingangs- und Zustandsvektor bestimmen nun einerseits den Ausgangsvektor, andererseits den Folgezustand. Die Verknüpfungen sind gegeben durch Boolesche Vektorfunktionen:

• Ausgangsfunktion: 𝑦𝑛 = 𝑓(𝑥𝑛,𝑢𝑛)

• Registerkontrollfunktion: 𝑣𝑛 = 𝑔2(𝑥𝑛,𝑢𝑛)

• Übergangsfunktion: 𝑢𝑛+1 = 𝑔1�𝑣𝑛� = 𝑔1 �𝑔2�𝑥𝑛, 𝑢𝑛�� = 𝑔(𝑥𝑛,𝑢𝑛)

Je nachdem, wie die Schaltfunktion realisiert ist, wird unterschieden zwischen

• asynchronen Schaltwerken, deren Gedächtnis durch ein Verzögerungsglied ver-wirklicht ist, oder

• synchronen Schaltwerken, deren Gedächtnis aus einem zeitäquidistant getakte-tem Speicherbaustein besteht.

Hier sollen nur die weiterverbreiteten synchronen Schaltwerke betrachtet werden. Das be-sondere Kennzeichen synchroner Schaltwerke ist der extern aufgeprägte Takt, zu dessen Takt-flanken eine Änderung der Zustandsspeicher zugelassen wird. Eine Änderung des Zustands-vektors u aufgrund sich asynchron ändernder Eingangsvariablen ist dann nur zu den durch die Taktflanken definierten Zeitpunkten möglich.

2.3.1 Entwurf von Schaltwerken

Zu Beginn des Schaltwerkentwurfes wird die Problemanalyse durchgeführt. Aus den verbal vorgegebenen Eigenschaften des Schaltwerks muss eine formale Beschreibung zur Definition der Gesamtfunktion einschließlich der Ein- und Ausgangsvariablen mit ihrem Zeitverhalten bestimmt werden: Dazu gehört

• die Definition aller zu durchlaufenden Zustände,

• die Angabe der zu den Zuständen gehörigen Zustandsvariablen,

• die Angabe der Übergänge mit ihren logischen Übergangsbedingungen,

• die Angabe der zu den Übergängen gehörigen Ausgangsvariablen.

Das Entwurfsverfahren soll am Beispiel eines mod4 Vorwärts-Rückwärts-Zählers mit D-Flip-Flops als Zustandsspeicher erläutert werden. D-Flip-Flops geben das Eingangssignal um eine Taktperiode verzögert am Ausgang aus. Der Registerkontrollvektor ist somit gleich dem Zu-standsvektor zum Zeitpunkt (n+1): 𝑢𝑛+1 = 𝑣𝑛. Der Zähler besitzt 4 Zustände. In Abhängigkeit der Eingangsvariable x zählt das Steuerwerk vorwärts (𝑥 = 1) bzw. rückwärts (𝑥 = 0). Die Ausgangsfunktion yn entspricht dem Zustandsvektor un. Das Verhalten des Zählers unter den


verschiedenen Eingangsbedingungen wird mit Hilfe eines Zustandsgraphen beschrieben. Die Zustände werden durch Kreise symbolisiert; die Pfeile stellen die Übergänge zwischen den Zuständen dar. Die Beschriftung der Pfeile legt die Eingaben und die Ausgaben des Schaltwer-kes in dem Zustand fest, von dem man aktuell ausgeht. Zum Beispiel bedeutet die Kombinati-on 1/01, dass die Eingangsvariable 𝑥 auf 1 liegt und der Ausgangsvektor 𝑦 im Zustand, von dem der Pfeil ausgeht, den Wert 01 annimmt.

00 01

11 10

1/00

0/01

0/11

1/10

1/011/11 0/00 0/10

Bild 2.5: Zustandsgraph eines Mod-4-Vorwärts-Rückwärts-Zählers

In einem zweiten Schritt wird nun der Zustandsgraph in eine Übergangstabelle umgesetzt. Jeder Pfeil im Zustandsgraphen liefert eine Zeile in der Übergangstabelle.

𝑥 𝑢2𝑛 𝑢1𝑛

𝑢2𝑛+1 𝑢1𝑛+1 𝑦2𝑛

𝑦1𝑛

0 0 0 1 1 0 0

0 0 1 0 0 0 1

0 1 0 0 1 1 0

0 1 1 1 0 1 1

1 0 0 0 1 0 0

1 0 1 1 0 0 1

1 1 0 1 1 1 0

1 1 1 0 0 1 1

Tabelle 2.4: Übergangstabelle zum Mod-4-Vorwärts-Rückwärts-Zähler

Durch Verwendung von D-Flip-Flops als Zustandsspeicher erhält man als Registerkontrollglei-chungen 𝑣1𝑛 = 𝑢1𝑛+1und 𝑣2 = 𝑢2𝑛+1. Damit man ein möglichst einfaches Schaltnetz erhält, wird versucht, die Ausdrücke mit Hilfe von KV-Diagrammen zu vereinfachen.


Bild 2.6: Minimierung der Ausdrücke mit KV-Diagrammen

𝑢1𝑛+1 = 𝑢1𝑛

𝑢2𝑛+1 = 𝑥 ∧ 𝑢1𝑛 ∧ 𝑢2

𝑛 ∨ 𝑥 ∧ 𝑢1𝑛 ∧ 𝑢2𝑛 ∨ 𝑥 ∧ 𝑢1𝑛 ∧ 𝑢2𝑛 ∨ 𝑥 ∧ 𝑢1

𝑛 ∧ 𝑢2𝑛 = (𝑥 ≢ 𝑢1𝑛) ≡ 𝑢2𝑛

Es zeigt sich, dass sich nur 𝑢1𝑛+1 vereinfachen lässt. Für die Ausgangsfunktionen 𝑦1 und 𝑦2 wird kein Schaltnetz benötigt, da die Zustände mit den Ausgangsvariablen identisch sind.

Damit ergibt sich folgende Realisierung: :

Bild 2.7: Schaltwerk-Realisierung des Mod-4-Vorwärts-Rückwärts-Zählers

3 Programmierbare Logikbausteine Für die programmierbaren Logikbausteine wird zumeist die englische Abkürzung PLD (Pro-grammable Logic Device) verwendet. Es handelt sich hierbei um Schaltungen mittlerer bis hoher Komplexität zur Programmierung logischer Funktionen. Diese Programmierung kann beim Anwender oder direkt beim Hersteller erfolgen.

Die allgemeine Struktur der PLDs ist im unten gezeigten Blockschaltbild dargestellt.

Signale und Systeme B – Praktikum – Programmierung logischer Schaltungen 10 D i e allg em eine S t ruk t ur der P L D s ist im unten g e z e ig ten B l ock schaltbild darg estellt.

Bild 3.1: Allgemeine PLD-Struktur

Erkennbar sind folgende Elemente:

• der Eingabeblock

• das programmierbare UND- und ODER-Feld

• der Ausgabeblock

• die programmierbare Rückkopplung

Nicht in allen PLD müssen diese Elemente realisiert sein. Der gemeinsame Kern aller PLD liegt in der programmierbaren UND/ODER-Logikstruktur. Diese Struktur besteht aus einer pro-grammierbaren Matrix von logischen UND-Gattern, deren Ausgänge auf eine Matrix von logi-schen ODER-Gattern führen. Die PLD-Typen unterscheiden sich hauptsächlich in der Pro-grammiermöglichkeit der UND- und ODER-Felder.

Bevor auf die einzelnen PLD-Typen eingegangen wird, werden einige Konventionen zur gra-phischen Darstellungsweise eingeführt. Bei einem typischen PLD-Eingangspuffer liegen an seinen beiden Ausgängen das Eingangssignal (B = A) und sein Komplement (C = A

) an.

Bild 3.2: PLD-Eingangspuffer

Das nächste Bild zeigt die vereinfachte Darstellung eines UND-Gatters mit den Eingängen A, B, C.

Bild 3.3: Und-Gatter, herkömmliche Darstellung und PLD-Darstellung

Die Punkte auf den Kreuzungen symbolisieren eine fest verdrahtete Verbindung. Ein " " über dem Kreuzungspunkt stellt eine programmierbare Verbindung dar, die noch intakt ist, wäh-rend bei einer getrennten programmierbaren Verbindung das " " entfällt.


Bild 3.4: Darstellung von Verbindungstypen bei PLDs

Die ersten PLDs kamen Anfang der siebziger Jahre als PROMs (Programmable Read Only Me-mory) auf den Markt. PROMs weisen ein festes UND-Feld auf, in dem die Adressierung der einzelnen Speicherzellen realisiert ist. Vom Kunden ist nur die ODER-Matrix, in der die Daten bzw. logischen Funktionen abgelegt werden, programmierbar. Die Größe eines PROMs nimmt mit der Zahl der Eingänge stark zu, da für alle Kombinationen der Eingangsvariablen die Funk-tionswerte gespeichert werden. Bei vielen Eingängen bedeutet dies große und teure Bauele-mente. Die großen UND/ODER-Felder führen im Vergleich zu anderen PLD-Typen zu längeren Schaltzeiten. Nur wenige kleine PROMs arbeiten schnell genug, um Logikfunktionen zu reali-sieren. Zudem verlangen die meisten Logikfunktionen nicht, dass alle möglichen Eingangs-kombinationen verfügbar sind. Das Hauptanwendungsfeld für PROMs liegt bei Festwertspei-chern für Tabellen, Zeichengeneratoren etc.

Bild 3.5: Programmable Read-Only-Memory (PROM)

Als effizientere Möglichkeit, Logikfunktionen zu realisieren, wurden Mitte der siebziger Jahre die FPLAs (Field Programmable Logic Array) entwickelt. Bei diesen Bausteinen sind sowohl das UND- als auch das ODER-Feld programmierbar. Um kleinere und schnellere Felder zu erhal-ten, sind nicht alle Eingangskombinationen dekodiert. Diese Struktur erlaubt eine große Flexi-bilität des Entwurfs und einen hohen Ausnutzungsgrad.


Bild 3.6: Field Programmable Logic Array (FPLA)

Als Beispiel dienen folgende Ausgangsfunktionen, die insgesamt 7 Produktterme benötigen, von denen jedoch nur 5 verschieden sind.

𝑂0 = 𝐼0 ∧ 𝐼1 ∧ 𝐼2 ∨ 𝐼0 ∧ 𝐼2

𝑂1 = 𝐼0 ∧ 𝐼1 ∧ 𝐼2 ∨ 𝐼0 ∧ 𝐼1 ∧ 𝐼2 ∨ 𝐼0 ∧ 𝐼1 ∧ 𝐼2

𝑂2 = 𝐼0 ∧ 𝐼1 ∧ 𝐼2 ∨ 𝐼0 ∧ 𝐼2

Diese Funktionen können mit dem dargestellten FPLA-Baustein mit 6 Produkttermen realisiert werden, da die Struktur es erlaubt, einzelne Produktterme mehrfach zu benutzen. Die große Entwurfsfreiheit dieser Bauelemente stellt hohe Anforderungen an die Entwurfswerkzeuge.

Ein anderer Ansatz wurde mit den PALs (Programmable Array Logic) verwirklicht. Bei PALs ist das UND-Feld programmierbar, während das ODER-Feld fest ist. Die Zahl der Produktterme für jeden Ausgang wird durch das fest verdrahtete ODER-Feld bestimmt und beträgt für die heute üblichen Bauelemente 7 bis 8. Unter den Bauelementen mit PAL-Architektur gibt es eine beträchtliche Typenvielfalt, die sich hauptsächlich in ihren Ausgangsblöcken unterschei-den.

Bild 3.7: Programmable Array Logic (PAL)


Dem helfen sogenannte GAL (Generic Array Logic)-Bausteine wirksam ab: Durch konfigurierbare I/O-Makrozellen können die damit ausgestatteten Pins wahlweise als Eingang, (Tristate)-Ausgang mit programmierbarer Polarität oder als Registerausgang betrieben wer-den.

Eine Weiterentwicklung der GALs ist beispielsweise der MACH4, ein sogenannter CPLD (Complex PLD), welcher auch Gegenstand des Praktikumversuchs sein wird. Er bietet im Ver-gleich zu GAL-Bausteinen eine höhere Flexibilität der internen Verschaltung. Mit Hilfe einer softwarebasierten Optimierung kann so eine erheblich höhere Anzahl von Produkttermen verwendet werden.

Die Architektur der MACH4 Bausteine basiert auf mehreren PAL-Blöcken, die durch eine zent-rale Schaltmatrix (Central Switch Matrix) miteinander verbunden sind. Durch diese Matrix ist die Kommunikation der PAL-Blöcke untereinander gewährleistet, und die Implementierung von größeren Schaltungen ist möglich.

Die erweiterten Verschaltungsmöglichkeiten der Komponenten untereinander werden im folgenden Diagramm verdeutlicht:

Bild 3.8: Blockdiagramm der MACH4-Bausteine

Hierin ist das „Logic Array“ das UND-Feld und der „Logic Allocator with XOR“ stellt im Prinzip die erweiterte ODER-Verschaltung der im UND-Feld entstandenen Produktterme dar. Man sieht, dass die Ergebnisse einer logischen Verschaltung an den Eingang zurückgeleitet werden können, indem sie über die „Input Switch Matrix“ an die „Central Switch Matrix“ weitergelei-tet werden. Von dort können sie wieder zu jedem beliebigen PAL-Block geleitet werden. Man ist also nicht darauf angewiesen, die Ergebnisse im gleichen PAL-Block weiter zu verarbeiten.

Der „Logic Allocator“ nimmt eine Zuweisung der Produktterme auf die Makrozellen vor, in-dem er mehrere Produktterme zusammenfasst und diese über einen Schalter einer bestimm-ten Makrozelle zuweist. Diese Zuweisung unterliegt der softwaregesteuerten Optimierung, um die maximale Anzahl von Produkttermen zu ermöglichen. Die Anzahl der zusammenge-fassten Produktterme ist abhängig vom jeweiligen Betriebsmodus: im synchronen Betrieb werden 4, im asynchronen Betrieb nur 2 Terme gebündelt. Zu diesen 4 bzw. 2 Produkttermen


kann noch ein zusätzlicher Term geschaltet werden, welcher wahlweise aber auch über ein XOR-Gatter zur Makrozelle geleitet werden kann.

Bild 3.9: Logic Allocator im synchronen Modus

Bild 3.10: Logic Allocator im asynchronen Modus

Eine Makrozelle besteht aus einem Speicherelement (Flip-Flop), einer Routingvorrichtung für die Steuereingänge, einem Taktmultiplexer für die verschiedenen PAL-Takte und einer Initiali-sierungskontrolle für das Flip-Flop. Die beiden grundsätzlichen Betriebsarten „synchron“ und „asynchron“ unterscheiden sich nur in der Taktung und der Initialisierung der Zelle. Die Mak-rozelle selbst stellt je nach Einstellung ein T- oder D-Flip Flop zur Verfügung, über den Logic Allocator kann hiermit ein J-K- oder S-R-Flip Flop aufgebaut werden.


Bild 3.11: Makrozelle im synchronen Modus

Bild 3.12: Makrozelle im asynchronen Modus

Die „Output Switch Matrix“ ermöglicht den Makrozellen Verbindungen zu jeder der I/O-Zellen innerhalb eines PAL-Blocks. In der I/O-Zelle wird die Ausgabe des Wertes aus der Output Switch Matrix über einen Output Enable gesteuert, welcher wiederum aus einem Produkt-term besteht. Der ausgegebene Wert kann entweder über ein Register oder direkt wieder an die Input Switch Matrix zurückgeleitet werden. Die Input Switch Matrix optimiert die Weiter-leitung an die Central Switch Matrix.


Bild 3.13: I/O-Zelle im synchronen und asynchronen Modus

Bild 3.14: Output Switch Matrix


Bild 3.15: Struktur eines MACH4-Bausteins

4 Literaturverzeichnis Schröder, H.: Skriptum zur Vorlesung "Grundlagen der Informationsverarbeitung II" AG Schal-

tungen der Informationsverarbeitung, Dortmund

Lagemann, K.: Rechnerstrukturen, Springer, Berlin, Heidelberg, New York, 1987

Alemaini, A.E.A.: Kombinatorische und sequentielle Schaltkreise , VCH Verlagsgemeinschaft, Weinheim, 1989

Datenblatt der MACH 4 Bausteine von Lattice, Webseite: www.latticesemi.com

http://www.latticesemi.com/�


5 Testboard Der in diesem Versuch verwendete Baustein M4-64/32 besitzt 32 I/O-Pins, die auf dem Test-board mit folgenden Elementen fest verdrahtet sind:

SW1 SW2

Bild 5.1: Das im Versuch verwendete Testboard

Die Zuordnung der I/O-Ports zu den LEDs der Sieben-Segmentanzeigen ist in Tabelle 5.1 auf-gelistet.

Signale und Systeme B – Praktikum – Programmierung logischer Schaltungen 19 Pin Nummer Pin Definitionen MACH Inputs LED

1 GND2 I/O 0 U24-A3 I/O 1 U24-B4 I/O 2 U24-C5 I/O 3 U24-D6 I/O 4 U24-E7 I/O 5 U24-F8 I/O 6 U24-G9 I/O 7 Taster 1 U24-H (DP)

10 TDI11 CLK 0 / I 0 Takt über Jumper12 GND13 TCK14 I/O 8 U23-A15 I/O 9 U23-B16 I/O 10 U23-C17 I/O 11 U23-D18 I/O 12 U23-E19 I/O 13 U23-F20 I/O 14 U23-G21 I/O 15 Taster 2 U23-H (DP)22 VCC23 GND24 I/O 16 U26-A25 I/O 17 U26-B26 I/O 18 U26-C27 I/O 19 U26-D28 I/O 20 U26-E29 I/O 21 U26-F30 I/O 22 U26-G31 I/O 23 Taster 3 U26-H (DP)32 TMS33 CLK 0 / I 1 4 Hz Taktsignal34 GND35 TDO36 I/O 24 U22-A37 I/O 25 U22-B38 I/O 26 U22-C39 I/O 27 U22-D40 I/O 28 U22-E41 I/O 29 U22-F42 I/O 30 U22-G43 I/O 31 U22-H (DP)44 VCC

Tabelle 5.1: Zuordnung der IO-Ports zu den LEDs

A B

CDE

FG

H Bild 5.2: Belegung der 7-Segmentanzeige (LEDs)

Der Zustand einer LED ist definiert zu:

0 = leuchtend

1 = nicht leuchtend

Der Zustand eines Tasters ist definiert zu:

Taster gedrückt = I/O Pin = 0

Taster nicht gedrückt = I/O Pin = 1


Beispiel:

I/O 0 = 0 (low)

⇒ LED A der ersten 7-Segmentanzeige (U 24) leuchtet

Taster 1 gedrückt

⇒ I/O 7 = 0

6 Beispielprogramm (2:1 Multiplexer) Das Abbilden der Algorithmen und Schaltungen auf den CPLD wird in diesem Praktikumsver-such mit Hilfe der Entwicklungsumgebung „ispLEVER“ der Firma Lattice durchgeführt. Um eine kurze Einleitung in die Programmumgebung des ispLEVERs zu geben, soll hier kurz die Implementierung eines 2:1 Multiplexers erklärt werden.

a0

e0 e1

2:1 Mux

y Bild 6.1: 2:1-Multiplexer

1. Schritt: Öffnen Sie das Programm mit einem Doppelklick auf den Link „ispLEVER“ auf dem Desktop oder über das Startmenü („Lattice Semiconductor““ispLEVER“). Laden Sie das Projekt „Multiplexer.syn“ aus dem Ordner „Aufgabe 1“ und be-antworten Sie den auftauchenden Dialog mit „Ok“. Das Programmfenster sollte nun etwa wie folgt aussehen:

2. Schritt: Doppelklicken Sie auf das Modul „Multiplexer(multiplexer.abl)“ (wie im Bild markiert). Es öffnet sich der Texteditor zur Eingabe des Programmcodes


Geben Sie nun den folgenden Programmcode zur Realisierung der gewünschten Funktion ein:

Die Bedeutung der einzelnen Zeilen des Programms ist wie folgt:

Zeile 1/2: Deklaration der Ein- und Ausgänge des Moduls und Zuweisung von Va-riablen (Kommentare werden durch Anführungszeichen gekennzeich-net)

Zeile 3/4: Definition der Eingangsvektoren, Zuweisung der Zustände für die Seg-mentanzeigen


Zeile 5: Definition des Ausgangsvektors, jeweils eine Variable für ein Segment-LED eines Anzeigeblocks.

Zeile 6: Schlüsselwort für den Beginn der Gleichungsdefinitionen

Zeile 7: die logische Gleichung, Syntax wie folgt:

! = nicht

& = UND

# = ODER

Speichern Sie das Programm, und schließen Sie das Textfenster.

3. Schritt: Wählen Sie im Hauptfenster den Baustein („M4-64/32XXX“ bzw. „M4A5-64/32XX“) durch einen Doppelklick aus. Ändern Sie die Einstellungen wie folgt:

Sind die Einstellungen geändert (s.o.), dann bestätigen Sie mit OK. Daraufhin folgen zwei Warnhinweise. Der Erste muss mit „Nein“ und der zweite mit „Ja“ beantwortet werden.

4. Schritt: Auf der rechten Seite des Hauptfensters doppelklicken Sie den „Constraint Editor“. Die Schaltung wird nun kompiliert und es öffnet sich das Fenster des „Constraint Editors“. Klicken Sie auf den „Loc“-Button, um die Pinbelegung des MACH4-Bausteins festzulegen:


Aktivieren Sie die Checkboxen „Input“ und „Output/Bidi“, um die definierten

Variablen den Pins des Chips zuzuweisen. Markieren Sie „a0“ bei den „Signals“ und „9“ bei den „Pin“ (s. Pinbelegung des Testboards). Weisen Sie mit „Add“ die Pinbelegung zu. Die Variablen y0 bis y6 sollen mit den Pins „2“ bis „8“ (Ach-ten Sie auf die Reihenfolge!) verbunden werden.

Wenn die gewünschte Belegung sich im unteren Fenster befindet, können Sie die Zuweisung durch einen Klick auf „OK“ durchführen. Schließen Sie auch den „Constraint Editor“ und doppelklicken Sie zur Verifizierung des Entwurfs im rechten Teil des Hauptfensters den Eintrag „Fit Design“, so dass er einen grü-nen Haken erhält.

5. Schritt: Öffnen Sie nun das Programm „ispVM System“ auf dem Desktop oder über das Startmenü („Lattice Semiconductor“ „ispVM System“). Wählen Sie unter dem Menüpunkt „Edit“ „Add Device“ aus.


Im folgenden Dialog wählen sie durch klicken auf „Select“ den Baustein Mach4 M4-64/32 mit dem Package 44-pin PLCC aus. Bestätigen Sie die Auswahl.

Wählen Sie die im Projektordner vorhandene Jedec-Datei „Multiplexer.jed“ durch klicken auf den Button “Browse“ aus und bestätigen Sie anschließend mit „OK“.

Öffnen Sie unter "Options" den Dialog "Cable and I/O Port Setup", stellen Sie sicher, dass der "Cable Type" "LATTICE" gewählt ist und setzen Sie den "Custom Port" auf die Adresse 0xE010. Bestätigen Sie mit "OK".

Mit der Schaltfläche „GO“ kann die Programmierung des Bausteins gestartet werden. Sie können die temporären Dateien überschreiben, wenn sie vom Pro-gramm gefragt werden.

Soll später eine veränderte Jedec-Datei erneut gebrannt werden, so muss man den Status zurücksetzen. Dazu einfach den Listeneintrag doppelklicken und dann bestätigen. Wichtig ist, dass Operation auf „Erase,Program,Verify“ steht.


7 Aufgabenstellung Ein Teil der Aufgaben, die im Rahmen dieses Praktikumsversuches durchzuführen sind, sollen vor Versuchsbeginn bearbeitet werden. Aufgabenteile, die zur Versuchsvorbereitung dienen, sind mit einem "V" gekennzeichnet. Diese werden am Versuchstag in der Vorbesprechung gemeinsam mit dem Betreuer besprochen. Aufgabenteile, die während des Versuchs bearbei-tet werden sollen, sind mit einem "D" markiert.

7.1 Implementierung eines Multiplexers Zuerst soll ein einfacher 4:1 Multiplexer gemäß folgender Skizze realisiert werden.

Bild 7.1: 4:1-Multiplexer

Über die Adresseingänge 𝑎1𝑎0 kann einer der 4 Eingangsvektoren 𝑒0 bis 𝑒3 auf den Aus-gangsvektor y geschaltet werden. Die Adresseingänge a0 und a1 sind in diesem Fall die Taster 2 und Taster 3. Der Ausgang Y entspricht der Anzeige U22.

V: Geben Sie die logische Funktion des Multiplexers an. Bedenken Sie die Tasterstellungen.

D: Die Eingangsvektoren e0 bis e3 sollen den Zahlen von 0 bis 3 auf der Segmentanzeige entsprechen. Erweitern Sie dementsprechend das Programm aus Kapitel 6 um:

- die entsprechenden Eingangsvektoren e2, e3

- die zusätzliche Eingangsvariable a1

- die neue Pinbelegung (benutzen Sie die Tabelle aus Kapitel 5)

Erweitern Sie das Beispielprogramm aus Kapitel 6 und übertragen es auf den Baustein (Schrit-te nach Kapitel 6)!

7.2 Dualzahlausgabe auf einer Siebensegmentanzeige Es soll ein Schaltnetz implementiert werden, das 2 Eingänge und 7 Ausgänge besitzt. Das Schaltnetz soll eine Dualzahl, die an den beiden Eingängen anliegt, in dezimaler Form auf ei-ner 7-Segmentanzeige ausgeben.


y0y1y2y3y4y5y6

r0r1

Schalt-netz

y0

y1

y2

y3

y4

y5 y6

Man beachte wiederum: 0 → LED ein, 1 → LED aus

V: Bestimmen Sie die Wahrheitstabelle des Schaltnetzes (negative Logik für die LEDs!):

r1 r0 Anzeige y0 y1 y2 y3 y4 y5 y6

0 0 0

0 1 1

1 0 2

1 1 3

D : 1. Schritt: Öffnen Sie das Projekt „Konverter.syn“ aus dem Ordner „Aufgabe 2 3“. Doppelklicken Sie auf das Modul „konverter_block(konverter_block.abl)“. Es öffnet sich der Text-Editor.

2. Schritt: Das Programm „ispLEVER“ ist in der Lage, eine durch eine Wahrheitstabelle gegeben logische Funktion zu minimieren. Dazu geben Sie die Wahrheitstabelle nach der Pindefinition wie folgt ein:

1. Schlüsselwort: TRUTH_TABLE

2. Kopfzeile: ( [Eingangsvariablen] -> [Ausgangsvariablen]);

3. Zeilen der Wahrheitstabelle: [Eingangskombination] ->[Ausgangskombination];

Die Variablen sind durch Kommata zu trennen und alle Klammern sind mitzuschreiben!

3. Schritt: Nach der Eingabe schließen Sie den Text-Editor und Kompilieren die Tabelle durch Doppelklick auf „Compile Logic“ in der rechten Hälfte des Hauptfensters. Wenn alles korrekt eingegeben wurde, erscheint dann neben „Compile Logic“ ein grünes Häkchen, an-sonsten wird eine Fehlermeldung ausgegeben. Erzeugen Sie auch noch ein Symbol durch Doppelklick auf „Generate Schematic Symbol“.

4.Schritt: Öffnen Sie nun die Schaltung „konverter_schematic (konver-ter_schematic.sch)“ durch Doppelklick auf die entsprechende Zeile im linken Teil des Haupt-fensters. Es öffnet sich der Schematic-Editor. Dort kann mit Hilfe von grafischen Symbolen die Schaltung aufgebaut werden. Es müssen folgende Schritte durchgeführt werden:

• Hinzufügen des logischen Bausteins „konverter_block“ (F2)

• Verdrahten der Ein- und Ausgänge, wobei die Leitungen noch ins Leere führen sollen:


• Die offenen Leitungsenden müssen durch „Add Net Name“ einen Namen bekommen:

• Durch Klicken mit „Add I/O Marker“ auf ein benanntes, offenes Ende einer Leitung kann diese als eine I/O-Leitung deklariert werden:

Speichern Sie die Zeichnung, wenn Sie alle Ein- und Ausgänge des logischen Bausteins „Kon-verter“ mit I/O-Markern verbunden haben.

5. Schritt: Weisen Sie nun in bekannter Weise die Ein- und Ausgänge den Pins des MACH4 zu. Dabei sollen nun die Taster 2 und 3 mit den Eingängen, und die Ausgänge mit einer 7-Segmentanzeige verbunden werden. Passen Sie den Entwurf mit „Fit Design“ dem Chip an.


6. Schritt: Schreiben Sie das Programm auf den MACH4 und testen Sie die Funktion des Konverters. (Das in „ispVM System“ zu benutzende Jedec-File heißt „konverter.jed“).

Beachten Sie, dass ein nicht gedrückter Taster einer logischen „1“ entspricht. Welche Zahl erscheint demnach auf der 7-Segmentanzeige, wenn kein Taster gedrückt ist?

7.3 Modulo-4-Zähler mit Reset Ein einfacher Zähler soll von 0 aufwärts autonom bis 3 zählen und auf einer Anzeige ausge-ben, sobald er über einen Startbutton aktiviert wird. Ist er bei „3“ angekommen, so springt er zurück nach „0“ und wartet auf eine erneute Betätigung des Startbuttons. Ein zusätzlicher Resetknopf soll den Zähler auch während des Betriebs in den Ausgangszustand „0“ zurückset-zen können. Beim Betätigen beider Knöpfe soll der Resetknopf vorrangig behandelt werden. Im laufenden Betrieb soll der Startknopf keine Auswirkung auf die Schaltung haben. Benutzen Sie dabei folgendes Schaltwerk:

2

startreset

clock

Schaltnetzu

Register (D-Flip-Flop)

2

2v

y0y1y2y3y4y5y6

DualzahlKonverter

y0

y1

y2

y3

y4

y5 y62

a

Bild 7.2: Schaltwerk für den Modulo-4-Zähler


V: 1. Zeichnen Sie das Übergangsdiagramm. Benutzen Sie dabei folgende Definition:

start, reset / a , a1 0n n

u , u1 0n n u , u1 0

n+1 n+1

Beachten Sie:

Start und Reset sind in negativer Logik zu behandeln (ein gedrückter Taster liefert „0“, ein nicht gedrückter Taster „1“). Die Vektoren a, v und u sollen in positiver Logik entworfen werden.


2. Geben Sie die Übergangstabelle an:

𝑢1𝑛 𝑢0𝑛 start reset 𝑢1𝑛+1

𝑢0𝑛+1 𝑎1𝑛+1 𝑎0𝑛+1

𝑣1𝑛 𝑣0𝑛

0 0 0 0

0 0 0 1

0 0 1 0

0 0 1 1

0 1 0 0

0 1 0 1

0 1 1 0

0 1 1 1

1 0 0 0

1 0 0 1

1 0 1 0

1 0 1 1

1 1 0 0

1 1 0 1

1 1 1 0

1 1 1 1

3. Geben Sie die logischen Gleichungen für die Registerkontrollvariablen 𝑣1𝑛 und 𝑣0𝑛 an:

𝑣1𝑛 =

𝑣0𝑛 =

D: Implementieren Sie den Zähler auf dem MACH 4 Baustein:

1. Legen Sie im Projekt aus Kapitel 7.2 über „Source/New“ ein neues ABEL-HDL Modul an. Der Modulname und der Dateiname dürfen nur Buchstaben beinhalten, und müs-sen aus einem einzelnen Wort bestehen. In diesem Modul soll das Schaltnetz des Schaltwerkes beschrieben werden. Weisen Sie die Ein- und Ausgänge (start, reset, u1, u0, v1, v0

2. Kompilieren Sie die Logik des Moduls und legen Sie ein neues Symbol dafür an („Generate Schematic Symbol“).

) durch das Schlüsselwort „pin“ aus. Geben Sie die logischen Gleichungen (EQUATIONS) für die Ausgänge an.


3. Lösen Sie die nicht mehr benötigten I/O Marker von r1 und r0 in der schematischen Zeichnung des Projekts („konverter_schematic“). Fügen Sie das neue Modul mit F2 hinzu und verdrahten Sie es korrekt, benutzen Sie hierfür die gegebene Skizze. Die be-nötigten D-FlipFlops („G_D“) finden sie in der „Symbol Library“ (F2) unter „C:\..\GENERIC\REGS.LIB“. Die Schaltung wird übersichtlicher, wenn die entsprechen-den Bauteile über „Edit/Move“ markiert, und dann anhand des Buttons mit dem halb-kreisförmigen Pfeil in der Toolbox gedreht werden. „start“ und „reset“ sollen über Tas-ter auf dem Testboard gesteuert werden. Vergessen Sie nicht die Leitung für den Takt für die FlipFlops (incl. I/O-Marker). Speichern Sie das Ergebnis und kompilieren Sie die Zeichnung neu.

4. Ändern Sie die Pinbelegung im „Constraint Editor“ und passen Sie die Schaltung mit „Fit Design“ an. Überlegen Sie, welches Taktsignal das passendere ist.

5. Brennen Sie das Design auf den MACH 4 und testen Sie das Ergebnis.

6. Werden die Zahlen korrekt dargestellt? Beginnen Sie die eventuelle Fehlersuche mit den Definitionen für Tasterstellung und LED-Leuchten.

7.4 ALU mit 4 Rechenarten Eine einfache Recheneinheit, welche die Rechenarten Subtraktion, Addition, Multiplikation und Modulo beherrscht, soll mit dem „Schematic Editor“ anhand vorgefertigter Symbole und Beschreibungsdateien („Abel“-Dateien) zusammengestellt und verdrahtet werden.

Mit Taster 1 sollen die Rechenarten über einen Zähler zu durchlaufen sein, mit Taster 2 und Taster 3 werden die Eingabezahlen ebenfalls über einen Zähler eingestellt.

SAMM

ubtrahiererddiererultipliziererodulo

/4

/2

/2

/2

/2

/2

/2

Rechenartdarst.

Zahldarst.

Zahldarst.

Zahldarst.

/7

/7

/7

/7

ZählerTaster 1

ZählerTaster 2

ZählerTaster 3

Bild 7.3: Blockschaltbild für die ALU-Schaltung

D: Laden Sie das Projekt „ALU.syn“ aus dem Ordner „Aufgabe 4“. In diesem Projekt fin-den Sie alle benötigten Bausteine und das Schaltbild. Verdrahten Sie alles nach Vorgabe und passen Sie die Schaltung an den Baustein an.

Hinweis: Stellen Sie sicher, dass unter dem Menüpunkt „Tools“ „Global Constraints“ „Logic Synthesis“ „Node Collapsing“ der Punkt „Area“ ausgewählt ist.

Brennen Sie anschließend das Ergebnis auf den Baustein und testen Sie es.

Documents

Praktikum vorlesungsbegleitend zu Signale und Systeme B...6 Beispielprogramm (2:1 Multiplexer) ... Signale und Systeme B – Praktikum – Programmierung logischer Schaltungen 7 Ein