Erlnov95__enthält weitere informationen
PROGRAMMIERBARE LOGIK
ÜBERBLICK DER UNTERSCHIEDLICHEN ICs :
Allgemeine Formel für die Anzahl der programmierbaren Verbindungen N
N = 2k . n
k...Anzahl der Eingangsvariablen
n..
.Anzahl der Ausgangsvariablen
Die Verbindungen zwischen den Eingängen und den UND-Gattern sind vom Hersteller fest vorgegeben. Ein ROM ist beim Hersteller maskenprogrammierbar, d.h der Speicherinhalt wird im letzten Herstellungsschritt mit einer spezifischen Metallisierungsmaske eingegeben.
PROMs sind Festwertspeicher, deren Inhalt vom Anwender einmal programmierbar ist. Programmierbare Bauelemente sind meistens Schmelzsicherungen, Dioden oder spezielle MOSFETs mit „floating gate“.
Das (UV-)EPROM ist ein Festwertspeicher, der sich nicht nur vom Anwender programmieren, sondern auch mit ultraviolettem Licht löschen läßt. (Das Gehäuse des Chips besitzt ein Fenster aus Quarzglas). Speicherelemente sind spezielle MOSFETs.
Das EEPROM (=Electrically Erasable PROM) ist ein PROM, das sich im Gegensatz zum EPROM elektrisch löschen läßt. Bei den neueren Typen sind der Spannungswandler zur Erzeugung des Programmierspannung und der Timer zur Festlegen der Programmierimpulsdauer im Chip integriert. Wird ein neues Byte programmiert, wird zuerst das alte Byte gelöscht und dann das neue programmiert.
Nachteil:
Jede zusätzliche Eingangsvariable bewirkt eine Verdopplung der erforderlichen UND-Arrays, da die Eingänge fest verdrahtet sind. Die Erhöhung der Ausgänge erfordert nicht so viele zusätzliche Gatter.
Beispiel: beliebige Funktion nach einer Wahrheitstabelle realisieren
x2
x1
x0
y
DNF (Disjunktive Normalform)
Realisierung im ROM
0
0
0
1
0
0
1
0
0
1
0
1
0
1
1
1
1
0
0
0
1
0
1
0
1
1
0
1
1
1
1
0
GRUPPE: PAL (PROGRAMMABLE ARRAY LOGIC)
Die grundlegende Struktur fast aller programmierbarer Logikbausteine (PLD, EPLD, GAL, RAL, PEEL, IFL, etc.) basieren auf der PAL-Architektur, einer UND-ODER-Anordnung, wobei das UND-Array programmierbar und das ODER-Array festgelegt ist. Damit können bereits sämtliche Grundfunktionen der Boole‘schen Algebra erzeugt werden. Ein wesentlicher Vorteil jeder programmierbaren Logik liegt in der Verknüpfungsmöglichkeit der zur Verfügung stehenden Anschlüsse.
Das heißt, daß jeder Eingang beliebig oft verwendet und zu einem Ausgang geschaltet werden kann.
PALs ersetzten heute bereits die meisten Standard-Logikfunktionen, die früher mit den niedrig integrierten Bausteinen der TTL-74er-Familie aufgebaut wurden. PALs sind mindestens so schnell wie die besten bipolaren Kreise, meistens jedoch schneller. Dadurch sind sie besonders für High-Speed-Anwendungen (Interfacing), für die der Mikroprozessor alleine nicht mehr geeignet ist, interessant.
ARCHITEKTUR VON PAL-BAUSTEINEN:
Diese Abbildung zeigt die Grundstruktur, auf der sich alle PALs zurückführen lassen.
Die Verbindungen im UND-Feld sind elektrisch programmierbar, indem die im Originalzustand bestehenden Sicherungen kontrolliert durchgebrannt werden.
(Um die Grundlagen anschaulich zu erklären wird hier von Sicherungen gesprochen. Dies war die erste Methode PLDs zu realisieren. Zur Zeit sind bereits neuere Technologien mit speziellen MOSFETs u.ä. in Verwendung.)
Mit den Ausgängen der UND-Gatter, die direkt zu einem fest verdrahteten ODER-Feld führen, ist die grundlegende Eigenschaft eines PALs beschrieben.
Jedes AND-Gatter hat so viele Product Lines (also Eingänge), wie Input Lines vorhanden sind, wobei sich an den Kreuzungspunkten jeweils eine Sicherung (in der Abbildung bezeichnet als f1 bis f8) befindet. Damit ist nun die logische Funktion des gesamten Arrays programmierbar. Jede intakte Sicherung bedeutet die Verbindung einer Input Line mit dem AND-Gatter, jede zerstörte Sicherung bedeutet dementsprechend eine Unterbrechung.
Als Beispiel hierfür zeigt die nächste Abbildung das programmierte UND-Feld für eine EXOR-Funktion:
Hier sind die Sicherungen f1, f4, f6 und f7 intakt, während f2, f3, f5 und f8 zerstört sind, um die gewünschte Verknüpfung realisieren zu können. Damit wird auch klar, daß es nicht möglich ist, in Logik-diagrammen das Schema eines PALs in allen Einzelheiten darstellen zu können. Die PAL-Symbolik, ist demnach eine starke Vereinfachung der UND-Gatter mit all ihren Anschlüssen um nicht die Übersichtlichkeit zu verlieren.
Die Spalten beziehen sich auf die Eingänge, wobei zwei nebeneinader liegende Spalten zu einem Eingang gehören, die jeweils das invertierte und nicht invertierte Eingangssignal auf die Matrix geben. Mit dem „VerUNDen“ der Zeilen werden die nicht weggebrannten, d.h. nicht programmierten Verbindungen zu den Eingängen geschaltet. Die Zeilen werden Produktzeilen oder Produktterme genannt. Sie werden je nach Typ in unterschiedlicher Anzahl „verORt“.
Zwei wichtige Programmiersonderfälle müssen noch betrachtet werden:
Läßt man alle Sicherungen einer Produktzeile intakt, wird der Ausgang des entsprechenden Gatters low.
Zerstört man hingegen alle Sicherungen einer Zeile, wird der Ausgang des AND-Gatters high.
Allgemeine Formel für die Anzahl der programmierbaren Verbindungen N
N = 2k . n . q
q..
......
maximale Anzahl der ODER-verknüpfbaren Konjunktionen (Anzahl der Eingänge eines ODER-Gatters)
Vorteil:Bei einer Verdopplung der Eingangsvariablen, wird die Anzahl der programmierbaren Verbindungen nur verdoppelt, d.h. die Chips werden nicht so schnell zu groß und teuer.
Nachteil:
Durch die feste ODER-Matrix wird die Anzahl der Konjunktionen je Disjunktion vorgegeben. Dadurch wird der Funktionsumfang eingeschränkt, was sich aber in der Praxis nicht allzu störend auswirkt.
Beispiel:PAL 10H8
(10 Disjunktionen [ODER-Gatter] mit jeweils 8 Konjunktionen [UND-Gatter])
Die Nummern am Ein- und Ausgang stellen die Pins des IC‘s dar (PIN 10=GND; PIN 20=Vcc).
Der Baustein hat 10 Eingänge (PIN 1-PIN 11) und 8 Ausgänge (PIN 12-PIN 19). Die ‘X’ zeigen die unprogrammierten Verbindungen.
Dargestellt sind die wichtigsten Grundfunktionen:
Gatter
logische Funktion
Realisierung (Angabe der Pinnummern)
Buffer
Inverter
AND
OR
NAND
NOR
EXOR
EXNOR
Da bei diesen Beispielen maximal 2 Konjunktionen verwendet werden, wurden hier nur 2 der 8 UND-Gatter pro Disjunktion gezeichnet. In Beispiel 1 (Buffer) sieht man die reale Anordnung.
GRUPPE: PLA (PROGRAMMABLE LOGIC ARRAY)
Bei den PLAs sind beide Verbindungsmatrizen programmierbar, wodurch sich große Flexibilität ergibt. Die Komplexität und Flexibilität machen PLAs, FPLAs und FPLSs (Field Programmable Logic Sequencer) zu vielseitigen, effektiv einsetzbaren Bauelementen.
Vorteil:
Größere Flexibilität als PALs.
Nachteil:
Häufig ist nur Maskenprogrammierung möglich. Größere Signallaufzeiten, höhere Verlustleistung und größerer Chip als beim PAL führen zu einer beschränkten Anzahl der Produktterme.
FOLGEGENERATIONEN:
PAL-STRUKTUREN:
Mit einer programmierbaren I/O-Struktur, wie sie zum Beispiel im PAL16L8 wiederzufinden ist, lassen sich wesentlich komplexere Schaltungen realisieren.
Wie die Abbildung zeigt, werden die Ausgänge A und B über invertierende Tri-State-Buffer mit Enable-Eingängen geführt, die sich in Abhängigkeit der Product Lines einstellen lassen. Der Vorteil dieser Struktur liegt nun in der universell einsetzbaren Programmierbarkeit der Pins als Ausgang, Eingang oder für den bidirektionalen Datenverkehr.
Werden beispielsweise alle Sicherungen des Produktterms für den Enable-Eingang zerstört, arbeitet der entsprechende Treiber als invertierter Ausgang; läßt man alle Sicherungen dagegen intakt, wird der Ausgangstreiber hochohmig und zum Daten-Eingang (über Feedback). Da die Ausgänge des PALs in die Matrix zurückgeführt werden, spricht man auch von einer kombinatorischen Logik mit Rückkopplung.
Um nicht nur kombinatorische, sondern auch sequentielle Logik realisieren zu können, z.B. Zähler, Schieberegister u.ä.
wurden in die Ausgangsstruktur, wie sie die vorige Abb. zeigt, zusätzliche Register implementiert. „Registered Feedback“ bedeutet, daß zwischen dem fest verdrahteten OR-Array und den Ausgangsinvertern zusätzlich D-Flipflops eingebracht sind, deren komplementären Ausgänge ebenfalls in die Matrix zurückgeführt werden (PAL16R4 und PAL16R8).
Für alle FFs steht eine gemeinsame CLK-Leitung zur Verfügung, über die das Verknüpfungsergebnis zum Zeitpunkt des Taktes, d.h. mit der positiven Flanke, in das D-FF eingespeichert wird.
Auch hier können alle Ausgangsinverter über einen gemeinsamen Enable-Eingang hochohmig gemacht werden.
Beispiel:PAL 16R8
Dieser Baustein hat auch zusätzlich zur UND- und ODER-Matrix einen Speicher am Ausgang, der als zusätzliche Funktion zur Rückführung dient.
Während für den PAL10H8 an jedem ODER-Gatter nur 2 UND-Gatter verknüpft werden, können bei diesem Baustein mit jedem ODER-Gatter 8 UND-Gatter verknüpft werden. Das ermöglicht die Realisierung komplexer log. Funktionen. Der Ausgang des ODER-Gatters geht auf ein D-FF.
Mit dem Flanke des Clocks wird der Wert übernommen und zwischengespeichert. Der Ausgang des FF wird in die UND-Matrix zurückgeführt und kann ebenfalls logisch verknüpft werden, wodurch man weitere Funktionen realisieren kann, wie zum Beispiel Aufwärts- und Abwärtszähler.
Der PAL16R8 hat 8 Eingänge und 8 Ausgänge, d.h. der obige Block kommt 8 mal vor und insgesamt können 64 UND-Gatter programmiert werden.
PALs mit asynchroner Registerzelle:
In Ergänzung zur herkömmlichen Struktur bisher beschriebener PALs gibt es noch Bausteine mit sogenannten asynchronen Registerzeilen.
Hervorzuheben sind hier vor allem PALs vom Typ 16RA8 und 20RA8, mit denen es möglich ist, synchrone und asynchrone Schaltungen in einem Gehäuse realisieren zu können (RA bedeutet Register Asynchron).
Der wesentliche Nachteil der „normalen“ Register-PAL-Struktur ist das synchrone Verhalten der einzelnen FF-Stufen, die gemeinsam nur von einen einzigen Takt gesteuert werden können. Weiterhin mußte jedes Laden und Löschen der Speicher über die UND-ODER-Matrix erfolgen, da die D-FFs über keinen Setz- bzw. Rücksetzeingang verfügen. In vielen Systemen besteht aber die Notwendigkeit, verschiedene Teile einer Schaltung unabhängig voneinander zu betreiben.
Weiters läßt sich die hohe Komplexität einer programmierbaren Logikanordnung noch besser ausnutzen, wenn die einzelnen FFs im PAL getrennt betrieben werden können.
In diesem Bild sieht man eine für die Bausteine PAL16RA8 und PAL20RA10 typische asynchrone Registerzelle, wobei im 24-Pin-PAL20RA10 zehn und im 20-Pin-PAL16RA8 acht solcher Zellen integriert sind. Folgende Funktionen sind innerhalb der einzelnen Zellen unabhängig möglich:
Jeder Takteingang kann individuell programmiert werden.
Setz- und Rücksetzmöglichkeit an jedem Register
Die Setz- und Rücksetzfunktion der Register kann asynchron und synchron zum jeweiligen Takt angewählt werden.
Jeder Ausgang ist in der Ausgangspolarität programmierbar.
Jeder Ausgang kann sequentiell oder mittels einer individuellen „Register-Bypass“-Schaltung (Erklärung siehe weiter unten) kombinatorisch betrieben werden.
Einzeln setzbare Tristate - Funktionen
Die Funktionen der programmierbaren Takt-, Setz-, Rücksetz- und Tristate- Eingänge können für jedes Register einzeln oder auch für alle FFs gemeinsam programmiert werden.
Zu erwähnen wäre hier auch noch die Funktion der Preload-Leitung (PL). Mit Hilfe dieser Leitung können alle Register im 16RA8 in einen beliebigen Zustand gebracht werden. Außer zu Testzwecken kann die Preload-Schaltung auch noch für recht interessante logische Funktionen verwendet werden. Zum Beispiel kann durch Vorladen der Register ein programmierbarer Zähler oder der Zwischenspeicher eines Bussystems aufgebaut werden. Die Steuerung für das Vorladen ist für alle Register gleich, aber unabhängig vom Taktsignal. Nachdem der Ausgangstreiber im Tristate liegt, wird mit einem log.
0-Pegel am Preload-Eingang veranlaßt, daß die Daten am Preseteingang in das FF übernommen werden.
Register-Bypass-Schaltung:
An den Ausgängen des PAL sind Multiplexer angeordnet, die sich über programmierbare Sicherungen ansteuern lassen. Man unterscheidet hier zwei Fälle: 1) Bei intakter Sicherung wirkt der Ausgang sequentiell. 2) Im anderen Fall werden die Daten der Matrix kombinatorisch am Register vorbei zum Ausgangstreiber geführt. Je nachdem, ob die Daten kombinatorisch oder sequentiell gebildet werden, schaltet der zweite Multiplexer die entsprechende Rückkopplung. Wird das Register von den Daten benutzt, so ist die Rückführung vom Q-Ausgang des FF‘s wirksam.
Wird das Register umgangen, übernimmt der Multiplexer die Information direkt am Ausgang des Bauelements. Mit Hilfe dieser Schaltung ist es möglich, jedes einzelne FF individuell wegzuschalten.
PALs mit EXOR-Funktion vor den Registerausgängen: Diese Abbildung zeigt die Logikzelle eines PAL-Bausteins vom Typ 22RX8, mit dem die Komplexität und Funktionalität von 24-Pin-PALs noch weiter erhöht wurde. Wie man sieht, sind pro Zelle jeweils 10 Produktterme zusammengefaßt.
8 UND-Leitungen führen in das nachfolgende ODER-Gatter, dessen Ausgang an ein Exclusiv-ODER (EXOR) angeschlossen ist. Der zweite Eingang des EXOR liegt an der Leitung, die vom 9.
Produktterm gebildet wird. Dieses mitintegrierte EXOR ist eine besonders leistungsstarke Funktion innerhalb der zur Verfügung stehenden programmierbaren Logik und hat zur Folge, daß die Polarität des Datenpfades statisch oder dynamisch beliebig verändert werden kann, d.h. das EXOR-Gatter wirkt als steuerbarer Inverter.
Weiterhin bedeutet das Vorhandensein des EXOR, daß - ohne viele Produktterme verwenden zu müssen - Komperatoren, Zähler und Schieberegister einfach realisiert werden können. Ein weiterer Anwendungsfall für das eingebaute EXOR ist der Aufbau schneller JK-Flipflops.
Die Bilder rechts zeigen hierfür die zugehörige Funktionstabelle und die Realisierung in der Architektur des PAL22RX8:
Industriestandard PAL22V10 (GAL22V10, PALCE22V10):
Eine Weiterentwicklung der Standardbausteine wie z.B. PAL16L8, PAL16R8 usw. war das Hinzufügen von konfigurierbaren Makrozellen, wie sie heute bei den GAL-Bausteinen in ähnlicher Form wiederzufinden sind.
PAL22V10 war der erste Baustein mit einer programmierbaren Ausgangszelle dessen einzelnen Zustandsformen in nachfolgenden Abbildungen dargestellt sind.
Die besondere Architektur dieses Bausteins besteht in der variablen Produktterm-Verteilung.
Er besitzt zehn Makrozellen, wobei die beiden äußeren Zellen jeweils neun Produktterme, acht für die Daten und einen für die Tristate-Steuerung besitzen. Die Zahl der Produktterme nimmt nach innen zu: 2 x (10+1), 2 x (12+1), 2 x (14+1) und
2 x (16+1). Mit den beiden zusätzlichen Termen zum Programmieren der Setz- und Rücksetz-Steuerung besitzt das PAL22V10 insgesamt 132 Produktterme.
Die Bausteine GAL16V8 und GAL20V8:
GAL-Bausteine gibt es zur Zeit mit zwei verschiedenen internen Architekturen:
Bei der ersten handelt es sich um Entwicklungen, die sich auf die bekannten Standard-PAL-Architekturen beziehen, mit einer Komplexität von bis zu 300 äquivalenten Gattern (GAL16V8, GAL20V8, GAL22V10 und GAL20RA10). Die zweite besitzt eine FPLA-Architektur mit einer Komplexität von bis zu 600 Gattern (z.B.
: GAL6001).
Dieses Bild zeigt die internen Strukturen der GALs 16V8 und 20V8, mit dem von der PAL-Logik bekannten Aufbau. Durch Konfigurieren der Output Logic Macro Cell (OLMC) ergibt sich dann entweder ein kombinatorisches oder ein sequentielles Ausgangssignal, das log. 0 oder 1 ist. Während des Einschaltmoments wird ein internes Rücksetzsignal für alle Register bereitgestellt.
PAL-Architektur in einem GAL-Baustein
ÜBERSICHT DER EINZELNEN PAL-BAUSTEINE:
PART
NUMBER
INPUT
OUTPUT
PROGRAMMABLE
I/Os
FEEDBACK
register
OUTPUT
polarity
FUNCTIONS
PAL10H8
10
8
AND-OR
AND-OR GATE ARRAY
PAL12H6
12
6
AND-OR
AND-OR GATE ARRAY
PAL14H4
14
4
AND-OR
AND-OR GATE ARRAY
PAL16H2
16
2
AND-OR
AND-OR GATE ARRAY
PAL10L8
10
8
AND-NOR
AND-OR INVERT GATE ARRAY
PAL12L6
12
6
AND-NOR
AND-OR INVERT GATE ARRAY
PAL14L4
14
4
AND-NOR
AND-OR INVERT GATE ARRAY
PAL16L2
16
2
AND-NOR
AND-OR INVERT GATE ARRAY
PAL16C1
16
2
AND-OR GATE ARRAY
PAL16L8
10
8
6
AND-NOR
AND-OR INVERT GATE ARRAY
PAL16R8
8
8
8
AND-NOR
AND-OR INVERT ARRAY W/REG’S
PAL16R6
8
8
2
6
AND-NOR
AND-OR INVERT ARRAY W/REG’S
PAL16R4
8
8
4
4
AND-NOR
AND-OR INVERT ARRAY W/REG’S
PAL16X4
8
8
4
4
AND-NOR
AND-OR-XOR INVERT W/REG’S
PAL16A4
8
8
4
4
AND-NOR
AND-CARRY-OR-XOR INVERT W/REG’S
Mit den 15 oben angeführten Chips lassen sich 90% der logischen Funktionen einfach realisieren.
PEEL (PROGRAMMABLE ELECTRICAL ERASABLE LOGIC)
PEEL- (Fa. ICT) und PALCE-Bausteine (Fa. AMD) sind elektrisch löschbare PLDs in CMOS-PAL-Technologie (geringerer Energieverbrauch und niedrigere Temperaturen als Bipolar-Technologie).
Das Bild zeigt einen Ausschnitt aus dem Logikdiagramm des Bausteins PALCE16V8 von AMD, bestehend aus der üblichen UND/ODER-Anordnung mit jeweils acht Produkttermen zu jedem Ausgang. Am Ausgang befindet sich eine programmierbare Makrozelle, die aus einem D-Register und vier programmierbaren Multiplexern besteht. Diese Multiplexer sind verantwortlich für die Produktterm-Verteilung, Tristate-Steuerung, Register-Bypass-Funktion und der Wahl des Rückkoppelpfades.
Die Makrozelle kann dem zugehörigen Pin fünf verschiedene Konfigurationen verleihen: ein gewöhnlicher Dateneingang, ein kombinatorischer Ausgang, ein kombinatorischer Ausgang mit Tristate-Steuerung, ein kombinatorischer Ausgang neben Registerausgängen und ein Registerausgang. Pin 2 bis Pin 9 des Bausteins sind gewöhnliche Dateneingänge; Pin 1 und Pin 11 realisieren Doppelfunktionen. Sind in dem Baustein alle Ausgänge kombinatorisch konfiguriert, d.h. alle Register umgangen, sind Pin 1 und Pin 11 normale Dateneingänge. Ist aber nur ein Ausgang im Baustein sequentiell geschaltet, übernimmt Pin 1 die Funktion des Takteingangs und Pin 11 die Funktion der gemeinsamen Tristate-Steuerung aller Registerausgänge.
LCA (LOGIC CELL ARRAY)
Die bekannten PLD-Architekturen der zweistufigen Logik (UND-ODER) eignen sich hervorragend für den Einsatz in der Decodierlogik von Speicher- oder I/O-Schaltungen, als Multiplexer und in schneller Registerlogik. Allerdings nur limitiert geeignet ist diese zweistufige Struktur für die Entwicklung komplexer Logikstrukturen. Eine völlig neue Struktur war deshalb notwendig, um bei programmierbarer Logik eine Komplexität, vergleichbar der Integrationsfähigkeit von Gate-Arrays zu erreichen.
Gate Arrays sind vollständig vorgefertigte sogenannte Master, die später entsprechend des Entwurfs mittels einer 2-Ebenen-Metallisierung fertiggestellt werden. Das heißt es existieren vorgefertigte Verdrahtungskanäle, die sowohl horizontal als auch vertikal zwischen den Gatterblöcken angeordnet sind. Die Kreuzungen der Verdrahtungskanäle werden als Switch-Matrix bezeichnet, wobei die Verbindungsleitungen frei wählbar verdrahtet werden können.
Der Unterschied von LCAs zu herkömmlichen programmierbaren Bausteinen liegt in der Programmiertechnik selbst. Die Logikinformation der LCAs wird im Baustein mit statischen RAM-Zellen definiert. Man ermöglicht so, im Gegensatz zu herkömmlichen PLDs mit nur zweistufiger Logik, eine beliebige logische Tiefe. LCAs sind mit einer Komplexität von bis zu 20000 Gatterfunktionen erhältlich
Die Logic Cell Architektur von XILINX ist eng verwandt mit konventionellen Gate Arrays: eine Matrix von Logikblöcken, umgeben von einem Kranz von Ein-Ausgabe-Blöcken (siehe Abbildung).
Das LCA kann kombinatorische und sequentielle Logik beinhalten und erhält seine Funktionszuweisung, ähnlich wie ein Mikroprozessor, erst nach dem Einschalten der Versorgungsspannung. Dieses Programm wird auf Befehl automatisch aus einem externen Speicher geladen oder von einem Mikroprozessor im Rahmen der Systeminitialisierung bereitgestellt.
Die Funktionszuweisung (Konfigurationsprogramm) befindet sich bei LCAs in speziell dafür vorgesehene statische RAM-Zellen. Alle Ausgänge der Speicherzellen steuern sogenannte Look-Up-Tables für kombinatorische Logik und Schalttransistoren für Verbindungsleitungen. Bei der Logik auf dem LCA handelt es sich um geschlossene logische Einheiten, die als CLB (Combinatorial Logic Block), IOB (Input/Output Block) und als Verbindungsnetzwerk eingestellt werden können.
Die Grundlage der LCAs ist eine Matrix der konfigurierbaren Logikblöcke. Jeder dieser Blöcke besteht aus programmierbarer kombinatorischer Logik, Speicherelementen und bestimmten Pins, mit denen er mit anderen logischen Einheiten frei wählbar verbunden werden kann.
Die zur Verfügung stehenden Logikelemente sind in der Lage, jede beliebige Funktion der Eingangsvariablen zu erzeugen, wobei sich die Speicherelemente entweder direkt oder von der kombinatorischen Logik ansteuern lassen.
Über den logischen Einheiten entstehen Laufzeiten in der Größenordnung von mehreren Nanosekunden.
Das Bild zeigt die interne Struktur eines solchen CLBs.
IOBs (Bild rechts) können individuell als Eingang, Ausgang oder als bidirektionaler Anschluß programmiert werden und als Peripherie des LCA fungieren.
Die Vielseitigkeit dieses programmierbaren Arrays liegt also in der Möglichkeit, beliebige Signale auf dem Chip durch Programmierung miteinander verbinden zu können.
Diese programmierbaren Verbindungen benutzen sogenannte „Programmable Interconnect Points“ (Durchkontaktierungen), bestehend aus einem Transistor der die Signale über feste Metallverbindungen führt. Die Zeitverzögerung einer solchen Verbindung beträgt weniger als 1ns.
Für Verbindungen, die nicht mittels direkter Leitungen erzeugt werden können, ist ein umfangreiches Netzwerk vertikaler und horizontaler Leitungen sowie Schaltmatrizen vorhanden. Damit können sämtliche CLBs und IOBs eines Logic-Cell-Arrays beliebig miteinander verbunden werden.
Zum Routen kritischer Signale, wie zum Beispiel von Taktsignalen, ist ein weiteres Netzwerk von Verbindungen in der LCA vorhanden. Diese Leitungen umgehen die Schaltmatrize, um Signale mit minimalster Verzögerungszeit zueinander, durch das Bauelement zu führen.
Nach dem Ausschalten der Versorgungsspannung geht der Inhalt der Konfigurationsspeicherzellen verloren und das LCA befindet sich wieder in seinem unprogrammierten Ausgangszustand.
LCAs gibt es in verschiedenen Geschwindigkeitsvarianten: 50, 70 und 100 MHz (maximal mögliche Taktrate der Flipflops in den CLBs.
)
FPGA (FIELD PROGRAMMABLE GATE ARRAY)
Das Bild zeigt die Grundstruktur eines FPGAs, bestehend aus einem Feld von Logikmodulen und horizontal dazwischenliegenden Verdrahtungsmodulen mit den sogenannten „Antifuses“. Diese sind der Kern jedes FPGAs. Umgeben ist dieses Feld von peripheren Schaltungen mit Ein/Ausgabe-Puffern, Testfunktionen und Diagnoseschaltungen. Jeder I/O-Pin des Gate-Array-Bausteins kann als Eingang-, Ausgang-, Tristate- oder bidirektionaler Buffer konfiguriert werden, wobei Eingangs- und Ausgangspegel kompatibel zu Standard-TTL-Spezifikationen sind.
Es sind Flipflop-Taktfrequenzen bis
70 MHz und eine Systemfrequenz bis
40 MHz möglich.
Das Bild zeigt, wie das Grund-Logikmodul feldprogrammierbarer Gate-Arrays von Actel aufgebaut ist.
Es besitzt acht Eingänge und einen Ausgang und ist im unprogrammierten Zustand vollkommen funktionslos. Mit dem Aufbau aus drei 2:1-Multiplexern und einem ODER-Gatter ist man jedoch in der Lage, die vier grundlegenden Logik-Funktionen NAND, AND, OR und NOR in Gattern mit 2, 3 oder 4 Eingängen und verschiedenen Kombinationen von negierten oder nicht negierten Eingängen, aber auch verschiedene D-FFs, EXOR-Gatter, AND-OR- und OR-AND-Kombinationen aufbauen zu können. Insgesamt sind in der Makro-Bibliothek rund 200 logische Standardfunktionen enthalten.
Antifuse:
Dieses programmierbare Element ist im normalen Zustand hochohmig und geht nach Anlegen einer Programmierspannung in den leitenden Zustand über. In diesem Zustand wirkt die Antifuse ähnlich wie eine Verbindung in maskenprogrammierbaren Gate-Arrays. Die von einem Antifuse-Element beanspruchte Fläche ist so gering, daß es praktisch überall dort, wo Segmente miteinander verbunden werden sollen, integriert werden kann.
MACH (MACRO ARRAY CMOS HIGH-SPEED/HIGH-DENSITY)
MACH-Bausteine (AMD) weisen eine wesentlich höhere logische Dichte als PALs/GALs auf und haben den Vorteil, daß sie eine vergleichbare Geschwindigkeit besitzen. Integrationsdichte: 900 bis 3600 Gatter
Die MACH-Bausteine bestehen aus einer Anzahl von PAL-Blöcken, bei denen über eine sehr schnelle Schaltmatrix mit einer physikalischen Verzögerung von 1ns eine Verbindung aufgebaut wird. Dabei werden alle Eingangs-, alle Ein-/Ausgangs- und alle Rückkopplungssignale auf-genommen und an die verschiedenen PAL-Blöcke verteilt. Ein PAL-Block besteht aus: einer Produktterm-Matrix, einem Logic Allocator (logischer Verteiler), einem Block von Makrozellen und 16 Ein-/ Ausgabetreibern.
Diese Architektur besitzt den Vorteil, daß individuelle Funktionen in jeden einzelnen PAL-Block plaziert werden können und sehr komplexe Funktionen mit Hilfe der Software über zwei bis acht PAL-Blöcke hinweg aufgeteilt werden können. Unbenutzte Produkttermen der Nachbarzellen werden im Bedarfsfall vom Allocator in Vierergruppen zusätzlich geliehen, ohne dabei neu Verzögerungen zu erzeugen.
Die Ausgänge der Makrozellen können kombinatorisch oder getaktet sein.
Insgesamt besitzen MACH1- 12 und MACH2-Bausteine 16 Produktterme, die - getrennt von den I/O-Pins - wahlweise über ein Register (D- oder
T-Fipflop) oder auch direkt zur Schaltmatrix zurückgeführt werden.
Wie das Bild zeigt, ist die MACH1-Serie sehr I/O-intensiv, da jede Makrozelle am Ausgang mit einem I/O-Pin verbunden ist. Die MACH2-Serie besitzt im gleichen Gehäuse die doppelte Logikdichte. Bei der Verwendung von D-Flipflops mit externer Rückkopplung kommt man auf eine fest vorhersehbare Verzögerungszeit von 15ns, was einer maximalen Frequenz von 50MHz entspricht. Zähleranwendungen mit interner Rück-kopplung können mit 62,5MHz, Pipeline-Applikationen sogar mit 83MHz getaktet werden.
MAX (MULTIBLE ARRAY MATRIX)
Die Architektur dieser Bausteine besteht aus mehreren Logik-Array-Blöcken (LAB), die mit Hilfe einer programmierbaren Matrix (Interconnect Array) verbunden werden können.
Durch eine leistungsstarke Auswahl-Schaltung, die unter Steuerung programmierbarer EPROM-Elemente für die Lenkung der Signale sorgt, wird für das programmierbare Interconnect Array eine gleichmäßige Signallaufzeit von ca. 15ns erreicht. Eine LAB besteht aus einem Makrozellenblock, einem I/O-Block und einem Logik-Expander, wobei die Anzahl der Makrozellen und Produktterme von der Größe des Bausteins abhängen.
Das Bild links zeigt eine Makrozelle, wobei auffallend ist, daß zur Logikbildung nur drei Produkttermen zum Einsatz kommen, die über ein ODER-Gatter verknüpft sind. Nachgeschaltet ist ein Exclusiv-ODER, daß einmal den Ausgang der OR-Verknüpfung aufnimmt und zum anderen an einem Produktterm des Logik-Arrays hängt.
Mit dieser Architektur erhält man ein Verhalten wie bei PLAs.
MAX-Bausteine Serie 7000:besitzen als Leistungssteigerung in ihrer Struktur, einen sogenannten „Parallel Logic Expander“. Mit dieser neuen Funktion können Makrozellen Produkttermen von benachbarten Makrozellen zugeordnet werden, wenn eine bestimmte komplexe Funktion mehr als fünf Produktterme benötigt. Die zusätzlichen Verzögerungszeiten, die sich beim Aufbau komplexer Funktionen ergeben, betragen weniger als 2ns pro Zelle.
MAX 7000 ist die erste PLD-Reihe, die eine Programmierung der Geschwindigkeit und Leistungsaufnahme zuläßt. Die Power-Save-Funktion gestattet dabei das Programmieren einzelner Makrozellen für den Betrieb mit voller Geschwindigkeit und normaler Leistungsaufnahme bzw.
bei verminderter Geschwindigkeit mit einem Viertel der Leistung. Da ausschließlich zeitkritische Signalwege mit voller Leistungsaufnahme betrieben werden müssen, lassen sich Geschwindigkeit und Verlust-leistung des gesamten Bausteins gezielt an die jeweilige Aufgabenstellung anpassen.
Anhang A
Kurzbeschreibung PLSyn
Vorgangsweise zum Programmieren eines Bausteins:
Zeichnen im Schematic-Editor
a) eine Schaltung
Entweder werden nur Bauteile aus der DIG_PRIM.slb verwendet oder
es muß bei jedem Bauteil das Attribut IMPL auf PLSYN gesetzt werden (mit der Maus ein Fenster über alle Bauteile ziehen - EDIT/Attributes - Frage, ob die Änderung für alle Bauteile gelten soll mit JA beantworten und das Attribut eingeben IMPL = PLSYN)
b) einen Block
Um einen Block zu setzen wählt man folgendes Symbol aus:
Die Anschlußpins werden durch Verbinden des Blocks mit einer Standardleitung gezeichnet
Um einen Pin zu spezifizieren klickt man die Bezeichnung des Pins doppelt an, und es öffnet sich ein Editor
Die Funktion des Blocks kann verschiedenartig eingegeben werden:
Beispiel: Gray-Code-Zähler
a) Jedem Pin wird eine Funktion durch Verknüpfung
zugewiesen:
" GRAY1
PROCEDURE GRAY1 (INPUT clock, reset;
OUTPUT q3, q2, q1, q0 CLOCKED_BY clock RESET_BY reset);
q3 = Q3*/Q2*/Q1*Q0 + Q3*/Q2*Q1*Q0 + Q3*/Q2*Q1*/Q0
+ Q3*Q2*Q1*/Q0 + Q3*Q2*Q1*Q0 + Q3*Q2*/Q1*Q0
+ Q3*Q2*/Q1*/Q0 + /Q3*Q2*/Q1*/Q0;
q2 = Q3*Q2*Q1*Q0 + Q3*Q2*/Q1*Q0 + Q3*Q2*/Q1*/Q0
+ /Q3*Q2*/Q1*/Q0 + /Q3*Q2*/Q1*Q0 + /Q3*Q2*Q1*Q0
+ /Q3*Q2*Q1*/Q0 + /Q3*/Q2*Q1*/Q0;
q1 = Q3*/Q2*Q1*/Q0 + Q3*Q2*Q1*/Q0 + Q3*Q2*Q1*Q0
+ Q3*Q2*/Q1*Q0 + /Q3*Q2*Q1*/Q0 + /Q3*/Q2*Q1*/Q0
+ /Q3*/Q2*Q1*Q0 + /Q3*/Q2*/Q1*Q0;
q0 = Q3*/Q2*Q1*Q0 + Q3*/Q2*Q1*/Q0 + Q3*Q2*/Q1*Q0
+ Q3*Q2*/Q1*/Q0 + /Q3*Q2*Q1*Q0 + /Q3*Q2*Q1*/Q0
+ /Q3*/Q2*/Q1*Q0 + /Q3*/Q2*/Q1*/Q0;
END GRAY1;
oder
" GRAY2
PROCEDURE GRAY2 (INPUT clock, reset;
OUTPUT q3, q2, q1, q0 CLOCKED_BY clock);
q3 = /reset*(Q3*/Q2*/Q1*Q0 + Q3*/Q2*Q1*Q0 + Q3*/Q2*Q1*/Q0
+ Q3*Q2*Q1*/Q0 + Q3*Q2*Q1*Q0 + Q3*Q2*/Q1*Q0
+ Q3*Q2*/Q1*/Q0 + /Q3*Q2*/Q1*/Q0);
q2 = /reset*(Q3*Q2*Q1*Q0 + Q3*Q2*/Q1*Q0 + Q3*Q2*/Q1*/Q0
+ /Q3*Q2*/Q1*/Q0+ /Q3*Q2*/Q1*Q0 + /Q3*Q2*Q1*Q0
+ /Q3*Q2*Q1*/Q0 + /Q3*/Q2*Q1*/Q0);
q1 = /reset*(Q3*/Q2*Q1*/Q0 + Q3*Q2*Q1*/Q0 + Q3*Q2*Q1*Q0
+ Q3*Q2*/Q1*Q0+ /Q3*Q2*Q1*/Q0 + /Q3*/Q2*Q1*/Q0
+ /Q3*/Q2*Q1*Q0 + /Q3*/Q2*/Q1*Q0);
q0 = /reset*(Q3*/Q2*Q1*Q0 + Q3*/Q2*Q1*/Q0 + Q3*Q2*/Q1*Q0
+ Q3*Q2*/Q1*/Q0 + /Q3*Q2*Q1*Q0 + /Q3*Q2*Q1*/Q0
+ /Q3*/Q2*/Q1*Q0 + /Q3*/Q2*/Q1*/Q0);
END GRAY2;
b) Eine Wahrheitstabelle wird aufgestellt:
" GRAY3
PROCEDURE GRAY3 (INPUT clock, reset;
OUTPUT q3, q2, q1, q0 CLOCKED_BY clock);
" This macro makes all X's be treated as don't cares.
MACRO X .X.
;
TRUTH_TABLE
reset,q3,q2,q1,q0 :: q3,q2,q1,q0;
"--------------------------------------
1, X, X, X, X :: 0, 0, 0, 0;
0, 0, 0, 0, 0 :: 0, 0, 0, 1;
0, 0, 0, 0, 1 :: 0, 0, 1, 1;
0, 0, 0, 1, 1 :: 0, 0, 1, 0;
0, 0, 0, 1, 0 :: 0, 1, 1, 0;
0, 0, 1, 1, 0 :: 0, 1, 1, 1;
0, 0, 1, 1, 1 :: 0, 1, 0, 1;
0, 0, 1, 0, 1 :: 0, 1, 0, 0;
0, 0, 1, 0, 0 :: 1, 1, 0, 0;
0, 1, 1, 0, 0 :: 1, 1, 0, 1;
0, 1, 1, 0, 1 :: 1, 1, 1, 1;
0, 1, 1, 1, 1 :: 1, 1, 1, 0;
0, 1, 1, 1, 0 :: 1, 0, 1, 0;
0, 1, 0, 1, 0 :: 1, 0, 1, 1;
0, 1, 0, 1, 1 :: 1, 0, 0, 1;
0, 1, 0, 0, 1 :: 1, 0, 0, 0;
0, 1, 0, 0, 0 :: 0, 0, 0, 0;
END TRUTH_TABLE;
END GRAY3;
oder
" GRAY4
PROCEDURE GRAY4 (INPUT clock, reset;
OUTPUT q[4] CLOCKED_BY clock);
IF reset THEN
q = 0;
ELSE
TRUTH_TABLE
q :: q;
"--------------
0000b :: 0001b;
0001b :: 0011b;
0011b :: 0010b;
0010b :: 0110b;
0110b :: 0111b;
0111b :: 0101b;
0101b :: 0100b;
0100b :: 1100b;
1100b :: 1101b;
1101b :: 1111b;
1111b :: 1110b;
1110b :: 1010b;
1010b :: 1011b;
1011b :: 1001b;
1001b :: 1000b;
1000b :: 0000b;
END TRUTH_TABLE;
END IF;
END GRAY4;
g) Über höhere Programmiersprachen:
" GRAY5
PROCEDURE GRAY5 (INPUT clock, reset;
OUTPUT q[4] CLOCKED_BY clock);
IF reset THEN
q = 0;
ELSE
CASE q
WHEN 0000b=> q = 0001b;
WHEN 0001b=> q = 0011b;
WHEN 0011b=> q = 0010b;
WHEN 0010b=> q = 0110b;
WHEN 0110b=> q = 0111b;
WHEN 0111b=> q = 0101b;
WHEN 0101b=> q = 0100b;
WHEN 0100b=> q = 1100b;
WHEN 1100b=> q = 1101b;
WHEN 1101b=> q = 1111b;
WHEN 1111b=> q = 1110b;
WHEN 1110b=> q = 1010b;
WHEN 1010b=> q = 1011b;
WHEN 1011b=> q = 1001b;
WHEN 1001b=> q = 1000b;
WHEN 1000b=> q = 0000b;
END CASE;
END IF;
END GRAY5;
oder
" GRAY6
PROCEDURE GRAY6 (INPUT clock, reset;
OUTPUT q[4] CLOCKED_BY clock);
IF reset THEN
q = 0;
ELSE
IF q = 0000b THEN q = 0001b;
ELSIF q = 0001b THEN q = 0011b;
ELSIF q = 0011b THEN q = 0010b;
ELSIF q = 0010b THEN q = 0110b;
ELSIF q = 0110b THEN q = 0111b;
ELSIF q = 0111b THEN q = 0101b;
ELSIF q = 0101b THEN q = 0100b;
ELSIF q = 0100b THEN q = 1100b;
ELSIF q = 1100b THEN q = 1101b;
ELSIF q = 1101b THEN q = 1111b;
ELSIF q = 1111b THEN q = 1110b;
ELSIF q = 1110b THEN q = 1010b;
ELSIF q = 1010b THEN q = 1011b;
ELSIF q = 1011b THEN q = 1001b;
ELSIF q = 1001b THEN q = 1000b;
ELSIF q = 1000b THEN q = 0000b;
END IF;
END IF;
END GRAY6;
oder
" GRAY7
PROCEDURE GRAY7 (INPUT clock, reset;
OUTPUT q[4] CLOCKED_BY clock);
IF reset THEN
q = 0;
ELSE
STATE_MACHINE gray STATE_BITS q;
STATE s1[0000b]: GOTO s2;
STATE s2[0001b]: GOTO s3;
STATE s3[0011b]: GOTO s4;
STATE s4[0010b]: GOTO s5;
STATE s5[0110b]: GOTO s6;
STATE s6[0111b]: GOTO s7;
STATE s7[0101b]: GOTO s8;
STATE s8[0100b]: GOTO s9;
STATE s9[1100b]: GOTO s10;
STATE s10[1101b]: GOTO s11;
STATE s11[1111b]: GOTO s12;
STATE s12[1110b]: GOTO s13;
STATE s13[1010b]: GOTO s14;
STATE s14[1011b]: GOTO s15;
STATE s15[1001b]: GOTO s16;
STATE s16[1000b]: GOTO s1;
END gray;
END IF;
END GRAY7;
oder
" GRAY8
PROCEDURE GRAY8 (INPUT clock, reset;
OUTPUT q[4] CLOCKED_BY clock);
IF reset THEN
q = 0;
ELSE
STATE_MACHINE gray STATE_BITS q STATE_VALUES GRAY_CODE;
STATE s1: GOTO s2;
STATE s2: GOTO s3;
STATE s3: GOTO s4;
STATE s4:GOTO s5;
STATE s5: GOTO s6;
STATE s6: GOTO s7;
STATE s7: GOTO s8;
STATE s8: GOTO s9;
STATE s9: GOTO s10;
STATE s10: GOTO s11;
STATE s11: GOTO s12;
STATE s12: GOTO s13;
STATE s13: GOTO s14;
STATE s14: GOTO s15;
STATE s15: GOTO s16;
STATE s16: GOTO s1;
END gray;
END IF;
END GRAY8;
2) Durchführen der folgenden Schritte im Schematic - Editor
Analysis - ElectricalRuleCheck
Analysis – CreateNetlist
(Wenn gewünscht kann jetzt auch noch simuliert werden)
Tools - RunPLSYN
3) Durchführen der folgenden Schritte im PLSyn
EDIT - Constraints (hier können diverse Parameter der zu programmierenden Bauteile eingestellt werden wenn gewünscht; z.B.: Hersteller, Logikfamilie, etc.)
EDIT - Priorities (hier können, wie der Name schon sagt Prioritäten gesetzt werden wenn gewünscht; z.B.: Preis, Pinanzahl, Größe, etc.
)
TOOLS - Compiler
TOOLS - Optimizer
TOOLS - Fitter/Partitioner
TOOLS - FuseMapGenerator (mit diesem Befehl wird das zur Programmierung notwendige *.j1 - File generiert, welches der SPRINT - Programmer „versteht“)
| Anmerkungen: |
| impressum | datenschutz
© Copyright Artikelpedia.com
