Fakultät für Elektrotechnik und Informationstechnik

Praktikum vorlesungsbegleitend zu

Signale und Systeme B Versuch 203 "Programmierung logischer Schaltungen" Anleitung Version: Juni 2015 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://berta.e-technik.uni-dortmund.de/praktikum_apfelgruen/ 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 AG Bildsignalverarbeitung Prof. Dr. rer. nat. Christian Wöhler

Versuch 203 – Programmierung logischer Schaltungen

2

Inhalt 1

Einleitung ............................................................................................................... 2

2

Grundlagen logischer Schaltungen ..................................................................... 3 2.1 Schaltnetze ..................................................................................................... 3 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 ............................................................................................ 18

5

Testboard ............................................................................................................. 19

6

Beispielprogramm (2:1 Multiplexer) .................................................................. 21

7

Aufgabenstellung ................................................................................................ 26 7.1 Implementierung eines Multiplexers .............................................................. 26 7.2 Dualzahlausgabe auf einer Siebensegmentanzeige ..................................... 26 7.3 Modulo-4-Zähler mit Reset ............................................................................ 29 7.4 ALU mit 4 Rechenarten ................................................................................. 32

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 Schaltungen mit programmierbaren Logikbausteinen (Programmable Logic Devices, PLDs) vorstellen. Der im Versuch verwendete Baustein M4LV-64/32 der Firma Lattice vereinigt 4 PALBlö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 Entwicklungssoftware ermöglicht zusätzlich eine weitgehende Schaltungssimulation, mit deren Hilfe bereits vor dem Hardwareaufbau logische Fehler entdeckt werden können.

Versuch 203 – Programmierung logischer Schaltungen

3

2 Grundlagen logischer Schaltungen 2.1 Schaltnetze Als Basis für die Entwicklung logischer Schaltungen dient die Boolesche Algebra. Sie geht zurück auf den englischen Mathematiker Boole, der logische Zusammenhänge in einer zweiwertigen 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 systematisieren 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 maximal 6 Variablen. Für eine genaue Darstellung des Verfahrens sei hier auf die Literatur verwiesen. Die heutige Entwurfssoftware führt bereits eine automatische Minimierung durch, die eine Vereinfachung der Funktionen per Hand überflüssig macht. Ein für die Rechnerimplementierung 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 Folgenden 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 solchen 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

Versuch 203 – Programmierung logischer Schaltungen

4

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 KVDiagramm 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).

Versuch 203 – Programmierung logischer Schaltungen zusammengefasste Terme 1. Ordnung

Nr. a b c d

a b c d

zusammengefasste Terme 2. Ordnung

5 a b c d

1

0 0 0 1 √

1,5

0 - 0 1 A

2,6;10,14

-

- 1 0

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 √

B

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 Haken 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 Verfahren weiter vereinfacht. Gleichzeitig wird mit in die Tabelle aufgenommen, aus welchen Ausdrücken die Terme hervorgegangen sind. Durch die Vereinfachungen kann es vorkommen, dass verschiedene Zusammenfassungen auf gleiche Terme führen, von denen nur jeweils einer 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 y = a ∧ c ∧d ∨ c∧ d ∨ b∧ c ∨ b∧ d . In der minimalen disjunktiven Form sind nicht notwendigerweise alle Primterme enthalten. Im KV-Diagramm (Bild 2.3) ist ersichtlich, dass der Term b∧ d nicht "wesentlich" ist.

Bild 2.3: Bestimmung wesentlicher Primterme im KV-Diagramm

Versuch 203 – Programmierung logischer Schaltungen √ 1 A: 1, 5

√ 2

√ 4

*

B: 2, 6; 10, 14

√ 5

6

√ 6

√ 10

*

*

√ 12

√ 13

√ 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 zusammengefasst 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 festgelegt. Die Minterme, die mit den Primtermen A, B und C erfasst sind, können abgehakt werden. 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: y = a ∧ c ∧d ∨ c∧ d ∨ b∧ c . 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 verwenden.

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

Eingangsvektor x

SCHALTNETZ

Ausgangsvektor y

Registerkontrollvektor v

Zustandsvektor u VERZÖGERUNG bzw. Zustandsspeicher Bild 2.4: Blockschaltbild eines Schaltwerkes

Versuch 203 – Programmierung logischer Schaltungen

7

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 speichern, heißen entsprechend Zustandsvariablen. Zur Kennzeichnung der zeitlichen Abhängigkeit wurde der Sequenzindex n eingeführt. Es gilt für den: •

Eingangsvektor:

xn = { x1n, x2n , .... , xMn}

•

Ausgangsvektor:

yn = { y1n, y2n , .... , yIn}

•

Zustandsvektor:

un = { u1n, u2n , .... , uKn}

•

Registerkontrollvektor: vn = { v1n, v2n , .... , vLn}

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

Ausgangsfunktion:

•

Registerkontrollfunktion: vn = g2(xn, un)

•

Übergangsfunktion:

yn = f(xn, un)

un+1 = g1(vn) = g1(g2(xn, un)) = g(xn, un)

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

asynchronen Schaltwerken, deren Gedächtnis durch ein Verzögerungsglied verwirklicht ist, oder

•

synchronen Schaltwerken, deren Gedächtnis getaktetem Speicherbaustein besteht.

aus einem zeitäquidistant

Hier sollen nur die weiterverbreiteten synchronen Schaltwerke betrachtet werden. Das besondere Kennzeichen synchroner Schaltwerke ist der extern aufgeprägte Takt, zu dessen Taktflanken eine Änderung der Zustandsspeicher zugelassen wird. Eine Änderung des Zustandsvektors 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 Zustandsvektor zum Zeitpunkt (n+1): un+1

Versuch 203 – Programmierung logischer Schaltungen

8

= vn. Der Zähler besitzt 4 Zustände. In Abhängigkeit der Eingangsvariable x zählt das Steuerwerk vorwärts (x = 1) bzw. rückwärts (x = 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 Schaltwerkes in dem Zustand fest, von dem man aktuell ausgeht. Zum Beispiel bedeutet die Kombination 1/01, dass die Eingangsvariable x auf 1 liegt und der Ausgangsvektor y im Zustand, von dem der Pfeil ausgeht, den Wert 01 annimmt.

1/00 00

01 0/01

1/11

0/00

0/10

1/01

0/11 11

10 1/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. x

u2n

u1n

u 2 n+1

U 1 n+1

y2n

y1n

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 Registerkontrollgleichungen v1n = u1n+1 und v2n = u2n+1. Damit man ein möglichst einfaches Schaltnetz erhält, wird versucht, die Ausdrücke mit Hilfe von KVDiagrammen zu vereinfachen.

Versuch 203 – Programmierung logischer Schaltungen

9

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

u1n+1 = u 1n u2n+1 = x ∧ u 1n∧ u 2n ∨ x ∧u1n∧u2n ∨ x∧u1n∧ u 2n ∨ x∧ u 1n∧u2n = (x≡|u1n)≡u2n Es zeigt sich, dass sich nur u1n+1 vereinfachen lässt. Für die Ausgangsfunktionen y1 und y2 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 (Programmable 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.

Versuch 203 – Programmierung logischer Schaltungen D

i

ealg

em

einS

t

ruk

t

urdeP

L

D

sitm

unteg

e

z

e

ig

tenB

l

ock

10 schaltbidrg

estl.

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 programmierbaren Matrix von logischen UND-Gattern, deren Ausgänge auf eine Matrix von logischen ODER-Gattern führen. Die PLD-Typen unterscheiden sich hauptsächlich in der Programmiermöglichkeit der UND- und ODER-Felder. Bevor auf die einzelnen PLD-Typen eingegangen wird, werden einige Konventionen zur graphischen Darstellungsweise eingeführt. Bei einem typischen PLDEingangspuffer 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ährend bei einer getrennten programmierbaren Verbindung das " " entfällt.

Versuch 203 – Programmierung logischer Schaltungen

11

Bild 3.4: Darstellung von Verbindungstypen bei PLDs

Die ersten PLDs kamen Anfang der siebziger Jahre als PROMs (Programmable Read Only Memory) 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 Funktionswerte gespeichert werden. Bei vielen Eingängen bedeutet dies große und teure Bauelemente. 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 realisieren. Zudem verlangen die meisten Logikfunktionen nicht, dass alle möglichen Eingangskombinationen verfügbar sind. Das Hauptanwendungsfeld für PROMs liegt bei Festwertspeichern 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 erhalten, sind nicht alle Eingangskombinationen dekodiert. Diese Struktur erlaubt eine große Flexibilität des Entwurfs und einen hohen Ausnutzungsgrad.

Versuch 203 – Programmierung logischer Schaltungen

12

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. O0 = I0∧I1∧I2 ∨ I0 ∧I2 O1 = I0∧I1∧I2 ∨ I0 ∧ I1 ∧ I2 ∨ I0∧ I1 ∧I2 O2 = I0 ∧ I1 ∧ I2 ∨ I1∧I2 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 unterscheiden.

Versuch 203 – Programmierung logischer Schaltungen

13

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 werden. Eine Weiterentwicklung der GALs ist beispielsweise der MACH4, ein sogenannter CPLD (Complex PLD), welcher auch Gegenstand des Praktikumversuchs sein wird. Er bietet im Vergleich 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 zentrale 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:

Versuch 203 – Programmierung logischer Schaltungen

14

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“ weitergeleitet 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, indem er mehrere Produktterme zusammenfasst und diese über einen Schalter einer bestimmten Makrozelle zuweist. Diese Zuweisung unterliegt der softwaregesteuerten Optimierung, um die maximale Anzahl von Produkttermen zu ermöglichen. Die Anzahl der zusammengefassten 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

Versuch 203 – Programmierung logischer Schaltungen

15

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 Initialisierungskontrolle 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 Makrozelle 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

Versuch 203 – Programmierung logischer Schaltungen

16

Bild 3.12: Makrozelle im asynchronen Modus

Die „Output Switch Matrix“ ermöglicht den Makrozellen Verbindungen zu jeder der I/OZellen 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 Produktterm 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 Weiterleitung an die Central Switch Matrix.

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

Versuch 203 – Programmierung logischer Schaltungen

Bild 3.14: Output Switch Matrix

17

Versuch 203 – Programmierung logischer Schaltungen

Bild 3.15: Struktur eines MACH4-Bausteins

4 Literaturverzeichnis Schröder, H.: Skriptum zur Vorlesung "Grundlagen der Informationsverarbeitung II" AG Schaltungen 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

18

Versuch 203 – Programmierung logischer Schaltungen

19

5 Testboard Der in diesem Versuch verwendete Baustein M4-64/32 besitzt 32 I/O-Pins, die auf dem Testboard 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 aufgelistet.

Versuch 203 – Programmierung logischer Schaltungen Pin Nummer Pin Definitionen MACH Inputs 1 GND 2 I/O 0 3 I/O 1 4 I/O 2 5 I/O 3 6 I/O 4 7 I/O 5 8 I/O 6 9 I/O 7 Taster 1 10 TDI 11 CLK 0 / I 0 Takt über Jumper 12 GND 13 TCK 14 I/O 8 15 I/O 9 16 I/O 10 17 I/O 11 18 I/O 12 19 I/O 13 20 I/O 14 21 I/O 15 Taster 2 22 VCC 23 GND 24 I/O 16 25 I/O 17 26 I/O 18 27 I/O 19 28 I/O 20 29 I/O 21 30 I/O 22 31 I/O 23 Taster 3 32 TMS 33 CLK 0 / I 1 4 Hz Taktsignal 34 GND 35 TDO 36 I/O 24 37 I/O 25 38 I/O 26 39 I/O 27 40 I/O 28 41 I/O 29 42 I/O 30 43 I/O 31 44 VCC

20 LED U24-A U24-B U24-C U24-D U24-E U24-F U24-G U24-H (DP)

U23-A U23-B U23-C U23-D U23-E U23-F U23-G U23-H (DP)

U26-A U26-B U26-C U26-D U26-E U26-F U26-G U26-H (DP)

U22-A U22-B U22-C U22-D U22-E U22-F U22-G U22-H (DP)

Tabelle 5.1: Zuordnung der IO-Ports zu den LEDs

F

A G

B

D

C H

E

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)

Versuch 203 – Programmierung logischer Schaltungen

21

⇒ 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 Praktikumsversuch 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. e0 e1 a0

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 beantworten 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

Versuch 203 – Programmierung logischer Schaltungen

22

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 Variablen (Kommentare werden durch Anführungszeichen gekennzeichnet) Zeile 3/4:Definition der Eingangsvektoren, Zuweisung der Zustände für die Segmentanzeigen

Versuch 203 – Programmierung logischer Schaltungen

23

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. „M4A564/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:

Versuch 203 – Programmierung logischer Schaltungen

24

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“ (Achten 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.

Versuch 203 – Programmierung logischer Schaltungen

25

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 Programm 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.

Versuch 203 – Programmierung logischer Schaltungen

26

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 bearbeitet 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 a1a0 kann einer der 4 Eingangsvektoren e0 bis e3 auf den Ausgangsvektor 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 (Schritte 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 einer 7-Segmentanzeige ausgeben.

Versuch 203 – Programmierung logischer Schaltungen

r0 r1

y0 y1 y2 y3 y4 y5 y6

Sc haltnetz

27 y0

y5

y1

y6

y4

y2 y3

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

0

0

0

0

1

1

1

0

2

1

1

3

y0

y1

y2

y3

y4

y5

y6

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, ansonsten 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 (konverter_schematic.sch)“ durch Doppelklick auf die entsprechende Zeile im linken Teil des Hauptfensters. 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)

Versuch 203 – Programmierung logischer Schaltungen

28

•

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 „Konverter“ mit I/O-Markern verbunden haben.

Versuch 203 – Programmierung logischer Schaltungen

29

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_chain.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 ausgeben, 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ücksetzen 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: start reset

Schaltnetz u

2 v

2

2 clock Register (D-Flip-Flop)

a Dualzahl 2

Konverter

y0 y1 y2 y3 y4 y5 y6

y0 y5

y6

y4

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

y1 y2

y3

Versuch 203 – Programmierung logischer Schaltungen

30

V: 1. Zeichnen Sie das Übergangsdiagramm. Benutzen Sie dabei folgende Definition: u 1n, u 0n

start, reset / a1n, a0n

u1n+1, u0n+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.

Versuch 203 – Programmierung logischer Schaltungen

31

2. Geben Sie die Übergangstabelle an: u1n

u0n

start reset u 1 n+1 u 0 n+1 a 1 n+1 a 0 n+1 v 1 n

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

v0n

3. Geben Sie die logischen Gleichungen für die Registerkontrollvariablen v 1 und v 0 an: v1 = v0 =

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üssen aus einem einzelnen Wort bestehen. In diesem Modul soll das Schaltnetz des Schaltwerkes beschrieben werden. Weisen Sie die Einund Ausgänge (start, reset, u 1 , u 0 , v 1 , v 0 ) durch das Schlüsselwort „pin“ aus. Geben Sie die logischen Gleichungen (EQUATIONS) für die Ausgänge an. 2. Kompilieren Sie die Logik des Moduls und legen Sie ein neues Symbol dafür an („Generate Schematic Symbol“). 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

Versuch 203 – Programmierung logischer Schaltungen

32

neue Modul mit F2 hinzu und verdrahten Sie es korrekt, benutzen Sie hierfür die gegebene Skizze. Die benötigten D-FlipFlops („G_D“) finden sie in der „Symbol Library“ (F2) unter „C:\..\GENERIC\REGS.LIB“. Die Schaltung wird übersichtlicher, wenn die entsprechenden Bauteile über „Edit/Move“ markiert, und dann anhand des Buttons mit dem halbkreisförmigen Pfeil in der Toolbox gedreht werden. „start“ und „reset“ sollen über Taster 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.

Zähler Taster 1

Zähler Taster 2

Zähler Taster 3

Rechenartdarst.

/ 7

/ 2

Zahldarst.

/ 7

/ 4

Zahldarst.

/ 7

/ 2

Zahldarst.

/ 7

/ 2 2 / / 2

/ 2

Subtrahierer Addierer Multiplizierer Modulo

Bild 7.3: Blockschaltbild für die ALU-Schaltung

D:

Laden Sie das Projekt „ALU.syn“ aus dem Ordner „Aufgabe 4“. In diesem Projekt finden 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.