Hardwarepraktikum WS 1997/98. Versuch 2. Kombinatorische Systeme I

Transkript

1 Harwarepraktikum WS 1997/98 Versuch 2 Kombinatorische Systeme I Jan Horbach, Chris Hübsch, Lars Joran, Seite 1

2 1. Aufgabe: Gegenstan es Versuchs ist ie BOOLEsche Funktion f = x1 x2 x3 x4 Berechnen Sie eine Testfolge (minimaler Länge), ie geeignet ist, alle SA0- un alle SA1- Fehler an en Eingängen un em Ausgang einer technischen Realisierung er Funktion f zu erkennen. Bestimmung er Testfolge: Ein Stuck-at-Fehler ist ein Fehler, er so wirkt, als würe er Pegel an einem Ein- oer Ausgang unabhängig vom Testvektor fest auf 0 (SA0-Fehler) oer 1 (SA1-Fehler) liegen. Es muß für jeen Fehler minestens ein Testvektor bestimmt weren, er geeignet ist, iesen Fehler zu erkennen. Durch einen Soll-Ist-Vergleich kann ann geprüft weren, ob einer er Fehler, ie urch iesen Testvektor erkannt weren, vorliegt. Die Testvektoren müssen zwei Beingungen genügen: Provokationsbeingung: Der Befehl muß provoziert weren,.h. zum Nachweis eines SA0-Fehlers muß am Fehlerort eine 1 angelegt weren, um ie Verfälschung zu 0 am Ausgang beobachten zu können, un zum Nachweis eines SA1-Fehlers muß analog er Pegel 0 am Fehlerort angelegt weren. Transportbeingung: Die Belegung er aneren Eingänge ist so zu wählen, aß er Pegel minestens eines Ausgangs vom Pegel am Fehlerort abhängt,.h. er Fehler am Fehlerort muß zum Ausgang transportiert weren können. Aus iesen Beingungen läßt sich eine Berechnungsvorschrift er Testvektoren ableiten, ie geeignet sin, Stuck-at-Fehler an einem Eingang x i er technischen Realisierung einer BOOLEschen Funktion f zu erkennen: SA0-Defekt an x i : Tx = xi ( f( x,..., xi,..., xk) f( x,..., xi,..., x i k) = SA1-Defekt an x i : T = x x i ( f( x,..., xi,..., xk) f( x,..., xi,..., x = i k) Da er Ausgang stets beobachtbar ist, entfällt für ort auftretene Fehler ie Transportbeingung: T T f 0 f 1 = f = 1 = f = 1 Seite 2

3 Berechnung er Transportbeingungen: f( x ) f( x ) = ( x x x x ) ( x x x x ) = = f( x ) f( x ) = ( x x x x ) ( x x x x ) = = f( x ) f( x ) = ( x x x x ) ( x x x x ) = = f( x ) f( x ) = ( x x x x ) ( x x x 3 x 4 ) = = Die Transportbeingung ist also für alle x i 1,.h. jee Pegelänerung an einem Eingang änert as Ergebnis am Ausgang, unabhängig von er Belegung er aneren Eingänge. Berechnung er Mengen er Testvektoren: Da ie Transportbeingung für alle Eingänge 1 ist, vereinfachen sich ie allgemeinen Gleichungen zu: T = x 1 = 1 x = 1 xi 0 i i T = x 1= 1 x = 0 xi 1 i i T = ( x x x x ) = 1 stabelle. f T = ( x x x x ) = 1 stabelle. f Die Testvektoren lassen sich nun in einer Tabelle zusammenfassen. TV steht abei für Testvektor un δ(tv) für essen Dezimaläquivalent. In ie Matrix ist as Attribut e i,j mit i=δ(tv) un j Menge er betrachteten Fehler wie folgt eingetragen: e i,j = 0, falls er Testvektor i nicht geeignet ist, en Fehler j zu erkennen 1, falls er Testvektor i geeignet ist, en Fehler j zu erkennen δ(tv) Fehler \ TV x x x x x x x x f f Seite 3

4 Nun muß ie kürzeste Folge von Testvektoren bestimmt weren, ie alle betrachteten Fehler erkennt,.h. in er Testfolge muß für jeen Fehler ein Testvektor enthalten sein, er iesen Fehler erkennen kann. Damit gilt: ( ) = j e ij, 1 i Für ie konkrete Aufgabe folgt araus (er 2. Inex j ist er Einfachheit halber weggelassen): ( e e e e e e e e ( e e e e e e e e ( e e e e e e e e ( e e e e e e e e ( e e e e e e e e ( e e e e e e e e ( e1e3e5 e7 e9 e11e13 e 15 ( e e e e e e e e ( e e e e e e e e = 1 ( e e e e e e e e ) Ein Auflösen un Ausmultiplizieren ieses Ausrucks wäre ziemlich kompliziert un aufwenig. Wenn man jeoch ie Tabelle genauer betrachtet, stellt man fest, aß man bei en Eingängen urch ein Falten un Umklappen er Tabelle zwischen i=7 un i=8 alle Feler er Tabelle abecken kann. Das beeutet, aß sich schon urch 2 Testvektoren alle Fehler erkennen ließen. Aber offensichtlich genügen ie e i,j für en Ausgang nicht ieser Beingung, so aß man einen ritten Testvektor benötigt, er en noch ausstehenen Fehler erkennt. Wir haben ie Testvektoren 0111 (i=7) un 1000 (i=8) ausgewählt, ie sämtliche Stuckat-Fehler an en Eingängen sowie en SA0-Fehler an f erkennen, un zusätzlich noch en Testvektor 1001 (i=9), er geeignet ist, en übrigbleibenen SA1-Fehler an f zu erkennen. Eine mögliche Testfolge er minimalen Länge 3 lautet also: {0111, 1000, 1001} Die erwarteten Pegel am Ausgang betragen für ie ersten beien Testvektoren 1, für en letzten Testvektor 0. Falls man einen Eingang änert, muß sich auch as Ergebnis änern. Zur Simulierung eines SA0-Fehlers kann man also en Eingangspegel von 1 auf 0 verfälschen, un wenn sich ann er Ausgangspegel änert, beeutet as, aß er Testvektor so einen SA0-Fehler an em Eingang tatsächlich erkennen kann. Bei einem SA1-Fehler verfährt man analog, inem man bewußt en Pegel von 0 auf 1 verfälscht. Zusammenfassen: Der Ausgang arf nur bei em angelegten Testvektor en erwarteten Pegel führen, bei einer bewußten Eingangsänerung (was einem Stuck-at-Fehler entsprechen würe) muß sich er Ausgangspegel änern. Seite 4

5 2. Aufgabe: Realisieren Sie ie Funktion f mit einem 16-zu-1-Multiplexer. Legen Sie ie Testfolge aus 1. an ie Schaltung an un prüfen Sie ie Vollstänigkeit er Testfolge in bezug auf ie betrachteten Fehler. Vorüberlegung: Die zu realisierene Funktion f = x1 x2 x3 x4 liefert, ausmultipliziert: xx 1 2xx 3 4 xxxx xx 1 2 x3x4 xxxx xx 1 2x3x4 xxxx xx 1 2 xx 3 4 xxxx Der Multiplexer besitzt folgene allgemeine Schaltfunktion: ssss ssss ssss ssss ssss ssss ssss ssss ssss ssss ssss ssss ssss ssss ssss ssss Setzt man nun s 3 =x 1, s 2 =x 2, s 1 =x 3 un s 0 =x 4, liefert ein Koeffizientenvergleich folgene Werte für ie Dateneingänge : 0 =0, 1 =1, 2 =1, 3 =0, 4 =1, 5 =0, 6 =0, 7 =1, 8 =1, 9 =0, 10 =0, 11 =1, 12 =0, 13 =1, 14 =1, 15 =0 Die Werte für s un legt man an en Multiplexer an, enable e wir mit 0 beschaltet, a es negiert vorliegt, un er Ausgang wir urch ein NAND negiert, amit man en Pegel irekt mit en aneren zwei Realisierungsmöglichkeiten vergleichen kann: e MUX 16:1 s 4 f 16 Im Anhang befinet sich auch eine VHDL-Beschreibung ieser Schaltung. Seite 5

6 Durchführung: Legt man ie oben hergeleiteten Werte un Testvektoren an ie Schaltung an, erhält man genau ie erwarteten Ergebnisse. Änert man nun jeweils einen Eingang eines Testvektors auf en entgegengesetzten Wert (was einem Stuck-at-Fehler auf iesem Wert entspricht), änert sich auch as Ergebnis,.h. er betrachtete Testvektor wäre in er Lage, iesen Fehler zu erkennen: TV mit Fehler Ergebnis TV mit Fehler Ergebnis TV mit Fehler Ergebnis Da as für alle Testvektoren un Fehler er Fall war un außerem auch ein SA0- bzw. SA1- Fehler am Ausgang sofort festgestellt weren kann, ist as System von Testvektoren vollstänig in bezug auf ie betrachteten Fehler. Es reicht also aus, nur iese rei Testvektoren an ie Schaltung anzulegen, um eren korrekte Realisierung (.h. ohne Einfach- Stuck-at-Fehler) festzustellen. Seite 6

7 3. Aufgabe: Realisieren Sie ie Funktion f mit einem 16-zu-1-Multiplexer. Der 16-zu-1-Multiplexer ist aus zwei 8-zu-1-Multiplexern (un einigen Grungattern) zusammenzusetzen. Legen Sie ie Testfolge aus 1. an ie Schaltung an un prüfen Sie ie Vollstänigkeit er Testfolge in bezug auf ie betrachteten Fehler. Vorüberlegung: Die Werte für s un sin enen aus Aufgabe 2 ientisch, a sich er Multiplexer nach außen hin genauso verhalten soll. Enable e wir wieer mit 0 beschaltet, er Ausgang braucht allerings nicht noch einmal negiert zu weren, a er schon in er normalen Form vorliegt. Die Dateneingänge müssen nun auf ie beien Multiplexer aufgeteilt weren (siehe Schaltung), un ie Areßeingänge s müssen mit rei er x i belegt weren. Wir haben azu x 1, x 2 un x 3 ausgewählt; x 4 geht ann in ie Grungatter mit ein. Bei ieser Belegung gilt folgene Schaltbelegungstabelle: x 1 x 2 x 3 x 4 f 1 (MUX1) f 2 (MUX2) f Aus ieser Tabelle läßt sich folgene Formel für f ableiten: f = ( x f ) ( x f ) Da wir jeoch nur NAND-Gatter zur Verfügung haben, muß ie Formel erst urch Anwenung er DE MORGANschen Gesetze so umgewanelt weren, ass nur noch AND un NOT vorkommen. Diese Formel lautet ann: f x f x f = Somit benötigen wir 4 NAND-Gatter mit jeweils 2 Eingängen. Der 16-zu-1-Multiplexer kann ann also folgenermaßen urch zwei 8-zu-1-Multiplexer realisiert weren: Seite 7

8 s 3 s 2 s 1 s 0 e s 2 s 1 s 0 e MUX 8:1 f 1 f 1 f s 2 s 1 s 0 e 0 MUX 8:1 f f Im Anhang befinet sich auch eine VHDL-Beschreibung ieser Schaltung. Durchführung: Die Ergebnisse entsprechen genau enen von Aufgabe 2. Also ist as System von Testvektoren vollstänig in bezug auf ie betrachteten Fehler un ie Schaltung ist korrekt. Seite 8

9 4. Aufgabe: Realisieren Sie ie Funktion f mit nur einem 8-zu-1-Multiplexer (16-zu-1-Multiplexer mit s 3 =0, nicht belegt) un einem Negator. Legen Sie ie Testfolge aus 1. an ie Schaltung an un prüfen Sie ie Vollstänigkeit er Testfolge in bezug auf ie betrachteten Fehler. Vorüberlegung: Dieser Multiplexer besitzt folgene allgemeine Schaltfunktion: sss sss sss sss sss sss sss sss Setzt man s 2 =x 1, s 1 =x 2 un s 0 =x 3, liefert ein Koeffizientenvergleich folgene Werte für ie Dateneingänge : = x, = x, = x, = x, = x, = x, = x, = x Die Werte für s un legt man wieer an en Multiplexer an, enable e wir wieerum mit 0 beschaltet, un er Ausgang muß iesmal auch wieer urch ein NAND negiert weren, amit man en Pegel irekt mit en aneren zwei Realisierungsmöglichkeiten vergleichen kann: 0 x 1 x 2 x 3 s 3 s 2 s 1 s 0 e e x MUX 16:1 (8:1) f Im Anhang befinet sich auch eine VHDL-Beschreibung ieser Schaltung. Durchführung: Auch iese Ergebnisse entsprechen genau enen von Aufgabe 2. Also ist as System von Testvektoren vollstänig in bezug auf ie betrachteten Fehler un auch iese Schaltung ist korrekt. Seite 9

10 Anhang VHDL-Beschreibung: -- Funktionspackage package func is function bin2nat (bits : bit_vector) return natural; en func; package boy func is function bin2nat (bits : bit_vector) return natural is variable result : natural := 0; for i in bits'range loop result := result * 2 + bit'pos(bits(i)); en loop; return result; en bin2nat; en func; er-NAND entity nan2 is port (x1,x2 : in bit; y : out bit); en nan2; architecture ataflow of nan2 is y <= not(x1 an x2); en ataflow; -- 8:1-Multiplexer use work.func.all; entity mux8 is -- enable negiert s : in bit_vector (2 ownto 0); -- Aresseingang : in bit_vector (0 to 7); -- Dateneingang f,nf : out bit); -- Ausgang (+negiert) en mux8; architecture verh of mux8 is signal temp : bit; process (ne,s,,temp) temp <= (bin2nat(s)) an (not ne); f <= temp; nf <= not temp; en process; en verh; -- 16:1-Multiplexer use work.func.all; entity mux16 is s : in bit_vector (3 ownto 0); : in bit_vector (0 to 15); nf : out bit); en mux16; -- enable negiert -- Aresseingang -- Dateneingang -- Ausgang negiert Seite 10

11 architecture verh of mux16 is process (ne,s,) nf <= not ((bin2nat(s)) an (not ne)); en process; en verh; Schaltung aus Aufgabe 2 entity schaltung1 is -- Anlegen von 0 (not enable) x1,x2,x3,x4 : in bit; -- Anlegen er Testvektoren : in bit_vector (0 to 15); -- Anlegen von f : out bit); -- Ausgang en schaltung1; architecture struc of schaltung1 is component mux16 s : in bit_vector (3 ownto 0); : in bit_vector (0 to 15); nf : out bit); component nan2 port (x1,x2 : in bit; y : out bit); signal ar : bit_vector (3 ownto 0); signal nf : bit; for all: mux16 use entity work.mux16 (verh); for all: nan2 use entity work.nan2 (ataflow); ar <= x1x2x3x4; mux_1: mux16 port map (ne,ar,,nf); nan_1: nan2 port map (nf,nf,f); en struc; -- enable negiert -- Aresseingang -- Dateneingang -- Ausgang negiert -- Schaltung aus Aufgabe 3 entity schaltung2 is -- Anlegen von 0 (not enable) x1,x2,x3,x4 : in bit; -- Anlegen er Testvektoren : in bit_vector (0 to 15); -- Anlegen von f : out bit); -- Ausgang en schaltung2; architecture struc of schaltung2 is component mux8 -- enable negiert s : in bit_vector (2 ownto 0); -- Aresseingang : in bit_vector (0 to 7); -- Dateneingang f,nf : out bit); -- Ausgang (+negiert) component nan2 port (x1,x2 : in bit; y : out bit); signal m1,m2,nm1,nm2 : bit; signal n1,n2,n3,n4 : bit; signal eing1,eing2 : bit_vector (0 to 7); signal ar : bit_vector (2 ownto 0); for all: mux8 use entity work.mux8 (verh); for all: nan2 use entity work.nan2 (ataflow); Seite 11

12 teiler: process () -- Aufteilung er Dateneingaenge for i in 0 to 7 loop eing1(i) <= (i*2+1); eing2(i) <= (i*2); en loop; en process; ar <= x1x2x3; mux_1: mux8 port map (ne,ar,eing1,m1,nm1); mux_2: mux8 port map (ne,ar,eing2,m2,nm2); nan_1: nan2 port map (x4,x4,n1); nan_2: nan2 port map (x4,m1,n2); nan_3: nan2 port map (n1,m2,n3); nan_4: nan2 port map (n2,n3,f); en struc; -- Schaltung aus Aufgabe 4 entity schaltung3 is x1,x2,x3,x4 : in bit; f : out bit); en schaltung3; -- Anlegen von 0 (not enable) -- Anlegen er Testvektoren -- Ausgang architecture struc of schaltung3 is component mux16 -- nur als 8:1-MUX beschaltet -- enable negiert s : in bit_vector (3 ownto 0); -- Aresseingang : in bit_vector (0 to 15); -- Dateneingang nf : out bit); -- Ausgang negiert component nan2 port (x1,x2 : in bit; y : out bit); signal nx4,nf : bit; signal e8to15 : bit_vector (8 to 15) := " "; -- nicht beschaltet signal zero : bit := '0'; -- S3 = 0 signal eing : bit_vector (0 to 15); -- nur Bits 0-7 gebraucht signal ar : bit_vector (3 ownto 0); -- nur Bits 2-0 gebraucht for all: mux16 use entity work.mux16 (verh); for all: nan2 use entity work.nan2 (ataflow); nan_1: nan2 port map (x4,x4,nx4); -- Signal x4 ausserhalb es MUX negiert eing <= x4nx4nx4x4nx4x4x4nx4e8to15; ar <= zerox1x2x3; mux_1: mux16 port map (ne,ar,eing,nf); nan_2: nan2 port map (nf,nf,f); en struc; Testbench zum Vergleich aller 3 Realisierungen entity test is en test; architecture test of test is component schaltung1 -- Anlegen von 0 (not enable) x1,x2,x3,x4 : in bit; -- Anlegen er Testvektoren : in bit_vector (0 to 15); -- Anlegen von f : out bit); -- Ausgang Seite 12

13 component schaltung2 -- Anlegen von 0 (not enable) x1,x2,x3,x4 : in bit; -- Anlegen er Testvektoren : in bit_vector (0 to 15); -- Anlegen von f : out bit); -- Ausgang component schaltung3 -- Anlegen von 0 (not enable) x1,x2,x3,x4 : in bit; -- Anlegen er Testvektoren f : out bit); -- Ausgang signal ne : bit := '0'; -- not enable signal x1,x2,x3,x4 : bit; -- Testvektoren signal : bit_vector(0 to 15) := " "; signal f1,f2,f3 : bit; -- Ausgaenge for all: schaltung1 use entity work.schaltung1 (struc); for all: schaltung2 use entity work.schaltung2 (struc); for all: schaltung3 use entity work.schaltung3 (struc); x1 <= '0', '1' after 100 ns; x2 <= '1', '0' after 100 ns; x3 <= '1', '0' after 100 ns; x4 <= '1', '0' after 100 ns, '1' after 200 ns; schaltung_1: schaltung1 port map (ne,x1,x2,x3,x4,,f1); schaltung_2: schaltung2 port map (ne,x1,x2,x3,x4,,f2); schaltung_3: schaltung3 port map (ne,x1,x2,x3,x4,f3); en test; Seite 13