Minimización usando mapas de Karnaugh

UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO211 Sistemas Digitales
5.5. Minimización usando mapas de Karnaugh.
Se desea obtener, a partir de una expresión booleana, una forma equivalente que contenga un
número mínimo de términos, y en la cual se tenga el mínimo número de literales presente.
El método consiste en dibujar el mapa a partir de la función, y luego leer desde el mapa agrupando
convenientemente los mintérminos presentes.
Deben respetarse las siguientes reglas:

• Deben agruparse tantos bloques como sea posible; ya que mientras mayor sea la agrupación,
menor será el número de literales.
• Debe formarse el menor número de agrupaciones de bloques; ya que a menor número de

grupos, se tendrá menor número de términos.
• Un bloque puede ser usado muchas veces, en distintas agrupaciones; pero a lo menos una vez.
La técnica consiste en formar primero los grupos con menor número de adyacencias. Por esta razón,
los primeros mintérminos que deben marcarse son aquellos que no tienen adyacencias.
Ejemplo 5.5.1. Minimización a partir de los mintérminos

Se tiene:
AB
C 00 01 11 10
0 2 6 4
0 1 1 1
1 3 7 5
1 1 1
f(A, B, C)=∑(0,2,3,6,7)
Figura 5.20. Mapa de Karnaugh a partir de los mintérminos.
Si se considera primero la agrupación de los mintérminos (2, 3, 6, 7) que puede leerse como B,
podría inducir, en caso de mapas complejos, a no agrupar convenientemente al término: A’B’C’,
que sólo tiene una adyacencia.
Considerando formar grupos mayores con los mintérminos que tienen menos adyacencias quedan
las siguientes agrupaciones de mintérminos: (0, 2) y (2, 3, 6, 7).
Prof. Leopoldo Silva Bijit. 05-03-2004 95

AB
C 00 01 11 10
0 2 6 4
A’C’ 0 1 1 1 0
1 3 7 5
1 0 1 1 0
B
f(A, B, C)=B+A’C’
Figura 5.21. Agrupaciones en el Mapa de Karnaugh.
Veremos a continuación un ejemplo más complejo.
Ejemplo 5.5.2. Formación de grupos de mintérminos en minimización basada en

mapas.
Se desea minimizar: f(A, B, C, D) = ∑m(0, 1, 3, 8, 9, 11, 13, 14)
Dibujando un mapa para cuatro variables, se logra:

AB
CD 00 01 11 10
0 4 12 8
00 1 1
1 5 13 9
01 1 1 1
3 7 15 11
11 1 1
2 6 14 10
10 1
f(A, B, C, D)=∑(0,1,3,8,9,11,13,14)
Figura 5.22. Mapa de Karnaugh con los mintérminos.
Se observa que:
• m14 no tiene mintérminos adyacentes. Por esta razón no puede agruparse.
• m13 tiene un mintérmino adyacente. Por lo tanto, sólo puede agruparse con m9.
• m0, m3, m8 y m11 tienen dos mintérminos a distancia uno.
• m1 tiene 3 mintérminos adyacentes.
• m9 tiene 4 mintérminos a distancia uno.

Los grupos que forman sub-cubos suelen marcarse en al mapa, encerrando los mintérminos del
grupo con una línea cerrada.
Ya se tienen los grupos: (m14) y (m9, m13); puede formarse (m0, m1, m8, m9), con el objeto de
hacer el grupo lo mayor posible.
Sólo falta considerar m3 y m11, que a su vez forman un grupo. Sin embargo, conviene efectuar la
agrupación: (m1, m3, m9, m11), que emplea m1 y m9, ya considerados, con el objeto de hacer el
grupo lo mayor posible.
Resulta finalmente:
AB
CD 00 01 11 10
0 4 12 8
00 1 0 0 1
1 5 13 9
01 1 0 1 1
3 7 15 11
11 1 0 0 1
2 6 14 10
10 0 0 1 0
f(A,B,C,D)=ABCD’+AC'D+B’D+B’C’
Figura 5.23. Mínimo número de grupos.

Minimización empleando lenguaje Abel:
MODULE ejemplo
a ,b,c,d PIN;
f PIN istype ' COM';
EQUATIONS
" m(0,1,3,8,9,11,13,14)
truth_table([a,b,c,d]->f);
0->1;
1->1;
3->1;
8->1;
9->1;
11->1;
13->1;
14->1;
END
Basta indicar los mintérminos presentes. Al reducir las ecuaciones se obtienen:
f = (a & b & c & !d) # (!b & !c) # (a & !c & d) # (!b & d); Suma de productos.
!f = (!b & c & !d) # (b & !c & !d) # (b & c & d) # (!a & b); Producto de sumas.

Ejemplo 5.5.3.
Minimizar: f(A, B, C, D) = Σm(0, 1, 2, 7, 8, 9, 10, 15)
AB
CD 00 01 11 10
0 4 12 8
00 1 0 0 1
1 5 13 9
01 1 0 0 1
3 7 15 11
11 0 1 1 0
2 6 14 10
10 1 0 0 1
f(A, B, C, D)=BCD+B’D’+B’C’
Figura 5.24. Solución ejemplo 5.5.3.
Ejemplo 5.5.4.
Minimizar: f(A, B, C, D, E) = Σm(0,2,4,7,10,12,13,18,23,26,28,29).
ABC
DE 000 001 011 010 100 101 111 110
0 4 12 8 16 20 28 24
00 1 1 1 0 0 0 1 0
1 5 13 9 17 21 29 25
01 0 0 1 0 0 0 1 0
3 7 15 11 19 23 31 27
11 0 1 0 0 0 1 0 0
2 6 14 10 18 22 30 26
10 1 0 0 1 1 0 0 1
f(A, B, C, D, E)=B’CDE+A’B’D’E’+BCD’+C’DE’
Figura 5.25. Solución ejemplo 5.5.4.
Nótese que la representación es de sub-mapas apilados, pero dibujados en un plano.
Se tienen los siguientes grupos: (7,23); (0,4); (12,13,28,29); (2,10,18,26)

Empleando lenguaje Abel, para efectuar la minimización, se tiene:

MODULE ej2
a,b,c,d,e PIN;
f PIN istype 'COM';
EQUATIONS
" f(A,B,C,D,E) = m(0,2,4,7,10,12,13,18,23,26,28,29).
truth_table([a,b,c,d,e]->f);
0->1;2->1;4->1;7->1;10->1;12->1;13->1;18->1;23->1;26->1;28->1;29->1;
END
Y después de la minimización se logra:

f = (!a & !b & !d & !e) # (b & c & !d) # (!b & c & d & e) # (!c & d & !e); 18 entradas.
!f = (a & !b & !d) # (b & d & e) # (b & !c & !d) # (c & d & !e) # (!b & !d & e) # (!c & e); 23
entradas.
5.5.1. Minimización en forma de producto de sumas.
El método consiste en desarrollar el mapa para f, a partir de la forma canónica. Luego se obtiene el
mapa para f negado, de esta forma, se puede leer el producto de maxtérminos de f, como la suma de
mintérminos de f’. Así se obtiene la forma mínima como suma de productos. Después se obtiene
por involución, la función f; y finalmente se aplica De Morgan.
Ejemplo 5.5.1.1
Dada: f(A, B, C, D) = A + C’D’ + B’D = (A + B’ + D’)(A + C’ + D) obtener forma canónica

según producto de sumas.
Conviene escribir: f ’ = A’BD + A’CD’
Se obtiene del mapa: f’ = ∑m(2, 5, 6, 7) = m2 + m5 + m6 + m7

Entonces, por De Morgan: f = m2’ m5’ m6’ m7’ = M2 M5 M6 M7
Finalmente: f = ΠM(2, 5, 6, 7)

Ejemplo 5.5.1.2.
Minimizar, según producto de sumas: f(A,B,C,D) = Σ (4,5,7,8,10,11,12,13,15)
AB
Para f(A,B,C,D) se tiene: CD 00 01 11 10
0 4 12 8
00 0 1 1 1
1 5 13 9
01 0 1 1 0
3 7 15 11
11 0 1 1 1
2 6 14 10
10 0 0 0 1
Figura 5.26. Mapa con los mintérminos de ejemplo 5.5.1.2
Luego, para f ' el mapa resulta:
AB
CD 00 01 11 10
0 4 12 8
00 1
1 5 13 9
01 1 1
3 7 15 11
11 1
2 6 14 10
10 1 1 1
f '(A, B, C, D)
Figura 5.27. Mapa con los mintérminos de f’
Formado los siguientes grupos, en el mapa: (0, 1, 3, 2); (6, 14); (1, 9).
Se obtiene: f’= A’B’ + BCD’ + B’C’D

Por involución: (f’)’ = f = (A’B’ + BCD’ + B’C’D)’
Por De Morgan: f = (A’B’)’ (BCD’)’ (B’C’D)’

Finalmente, por De Morgan: f = (A +B) (B’ +C’ +D’) (B +C +D’)
Con un poco de práctica, pueden agruparse los ceros en el primer mapa, y leer directamente las
sumas, complementando las variables.
5.5.2. Condiciones superfluas (don't care)
Algunas funciones booleanas son especificadas para todas las combinaciones posibles de sus
variables. También es usual especificar que el valor de la función es "1" para ciertas combinaciones,
"0" para otras y un valor cualquiera para el resto. Por esto se denominan funciones
incompletamente especificadas.
Los mintérminos pueden agruparse en tres conjuntos: conjunto que activa la función(on set),
conjunto que desactiva la función( off set) y conjunto de mintérminos superfluos(dc set).
Los mintérminos que pueden ser especificados con valor "1" ó "0"(valor cualquiera), se denominan
“condiciones superfluas”.
Ejemplo de esta situación, es cuando existe dependencia entre las variables; ésta puede originar que
nunca se produzcan ciertas combinaciones de valores de las variables de entrada.
Esto flexibiliza el diseño de circuitos combinacionales; ya que posibilita aumentar el tamaño de las
agrupaciones, mediante la asignación de valor "1" a ciertas condiciones superfluas y "0" a otras,
según convenga para aumentar los grupos.
Debe tenerse presente que no deben formarse agrupaciones que sólo contengan términos superfluos.
En el mapa, las condiciones superfluas pueden marcarse con una "d". En algunos textos se emplea
el símbolo φ; en realidad, el símbolo representa un "1" sobre un "0", pero éste es difícil de lograr en
tipografía.
Ejemplo 5.5.2.1.
Se tiene f(A,B,C) = Σ m(0,5) + Σ d(1,4,7).
En un mapa:
AB
C 00 01 11 10
0 2 6 4
0 1 d
1 3 7 5
1 d d 1
f(A, B, C)
Figura 5.28. Mapa con condiciones superfluas.
Sin emplear las condiciones superfluas, se tiene: f = A’B’C’ + AB’C

Puede agruparse (0,1) y (5,7). En este caso: f = A’B’ + AC
Sin embargo, la agrupación más conveniente es (0,1,4,5), y así se obtiene: f = B’
Nótese que: f(A,B,C) = ΠΜ(2,3,6) • ΠD(1,4,7) es decir, los maxtérminos superfluos tienen
iguales números que los mintérminos superfluos.
También se tienen:
f(A, B, C) = Σm(2, 3, 6) + Σd(1, 4, 7)
f(A, B, C) = ΠM(0, 5) • ΠD(1, 4, 7)
Si en el ejemplo anterior, se minimiza la función f, como suma de productos, se logra:

AB
C 00 01 11 10
0 2 6 4
0 1 1 d
1 3 7 5
1 d 1 d
f '(A, B, C)
Figura 5.29. Mapa con condiciones superfluas de f’
Sin embargo, debido a la presencia de condiciones superfluas, no se cumplirá siempre que:
f=f''
No obstante, tanto f como f ' ' contienen los mintérminos especificados en la lista de f.
Ejemplo 5.5.2.2.
Puede comprobarse que f y f ' ' no son iguales, para la siguiente función:
f(A, B, C) = Σm(0, 1, 5) + Σd(2, 6) = A’C’ + B’C

f’(A, B, C) = Σm(3, 4, 7) + Σd(2, 6) = B + AC’
f’’(A, B, C) = ( B + AC’)’ = B’ (AC’)’ = B’(A’+C) = A’B’ + B’C ≠ A’C’ + B’C
La simplificación de expresiones booleanas mediante reducciones algebraicas presenta dificultades

ya que no puede encontrarse un procedimiento sistemático en general, para efectuar la reducción.
Además se presenta la dificultad de cómo saber que se ha encontrado la forma mínima.
Las herramientas de diseño lógico permiten efectuar minimizaciones para funciones de varias
variables.
Los métodos gráficos desarrollados anteriormente están limitados a un número reducido de
variables(no más de 6) y su exposición permite entender los métodos automáticos, así como
también permitir diseñar con papel y lápiz algunos casos sencillos.

Ejemplo 5.5.2.3.
Diseñar traductor de código BCD a exceso-3. El código exceso-3, representa los dígitos decimales
mediante su equivalente binario más tres. Tiene propiedades aritméticas que lo hacen útil en
manipulaciones.
Se tiene:
BCD exceso-3
0 0000 0011
1 0001 0100
2 0010 0101
3 0011 0110
4 0100 0111
5 0101 1000
6 0110 1001
7 0111 1010
8 1000 1011
9 1001 1100
wxyz f4f3f2f1
Figura 5.30. Tabla traductor BCD a Exceso-3.
Nótese que se tiene un sistema con cuatro entradas y cuatro salidas:
Se ha asumido que la cifra BCD se dispone en paralelo, y se desea lograr la equivalente exceso-3
también en paralelo.
Si se conoce que en la entrada se tendrá una cifra BCD, entonces algunas combinaciones de las
variables w, x, y, z deben tratarse como condiciones superfluas. En un mapa, esto puede anotarse:
WX
YZ 00 01 11 10
0 4 12 8
00 d
1 5 13 9
01 d
3 7 15 11
11 d d
2 6 14 10
10 d d
f(W, X, Y, Z)
Figura 5.31. Mapa de las condiciones superfluas del ejemplo 5.5.2.3.
Las expresiones canónicas para las funciones de salida son:

f1 = ∑m(0,2,4,6,8) + ∑d(10,11,12,13,14,15)
f2 = ∑m(0,3,4,7,8) + ∑d(10,11,12,13,14,15)
f3 = ∑m(1,2,3,4,9) + ∑d(10,11,12,13,14,15)
f4 = ∑m(5,6,7,8,9) + ∑d(10,11,12,13,14,15)
Minimizando, se logra para el sistema de múltiples salidas:

f = z’
f2 = y’ z’ + yz
f3 = x’y + x’z + xy’z’
f4 = w + xy + xz
Si se dibuja un esquema lógico, mediante OR de ANDs, puede apreciarse que en un sistema de

salidas múltiples existe la posibilidad de ahorrar material usando parte o la totalidad de los
productos de una función como partes de otra. Ejemplo de esto es el factor y'z' de f2, que puede
usarse en f3.
Si se presenta una cifra BCD inválida en la entrada, la salida también será errónea. Para usar
confiablemente el circuito combinacional, diseñado empleando condiciones superfluas, debe
asegurarse que la entrada sea una cifra BCD válida.
Diseño empleando Abel.

Puede realizarse el diseño de la red combinacional empleando herramientas de apoyo al diseño. El
siguiente texto es un programa en Lenguaje Abel, que describe una función combinacional,
empleando tablas de verdad.
El lenguaje permite la optimización empleando condiciones superfluas para reducir la cantidad de

compuertas necesarias para una función no especificada completamente. Se emplea la
especificación dc (don't care), para indicar que una salida es una función con condiciones
superfluas; y com para indicar que es combinacional.
Por ejemplo la tabla de cuatro variables, que se muestra a continuación debe tener 16 renglones.
Pero pueden especificarse sólo los renglones en que la función debe ser uno(conjunto on), y los
renglones en que debe ser cero(conjunto off); el resto de los renglones no especificados corresponde
al conjunto de condiciones superfluas.
Cuando se emplea la optimización con condiciones superfluas debe cuidarse de no especificar

condiciones que se traslapen; es decir que el mismo conjunto de valores de las variables de entrada
esté presente en ambos conjuntos. En caso de hacerlo el compilador avisa que no puede efectuar la
mezcla de las condiciones; en este caso debe revisarse el código para efectuar correcciones.
MODULE ejemplo
TITLE 'Diseño con Condiciones superfluas'
“Definiciones
i3..i0, pin; “Entradas
f pin istype 'dc,com'; “Salidas combinacionales.
truth_table ([i3,i2,i1,i0]->[f])
[ 0, 0, 0, 0] ->[ 0]; "off-set Mintérminos para los cuales la función es 0.

[ 0, 0, 0, 1] ->[ 0];
[ 0, 0, 1, 1] ->[ 0];
[ 1, 0, 0, 0] ->[ 0];
[ 0, 1, 1, 1] ->[ 1]; "on-set Mintérminos para los cuales la función es 1.
[ 1, 1, 1, 1] ->[ 1];
[ 1, 1, 1, 0] ->[ 1];
[ 1, 1, 0, 0] ->[ 1];
END
Nótese que no se especifican los mintérminos superfluos, y que se agrega dc( por don't care), en la
declaración del pin de salida.
Diseñar traductor de código BCD a exceso-3, empleando lenguaje Abel
MODULE ej3
w,x,y,z PIN;
f4,f3,f2,f1 PIN istype 'DC,COM';
EQUATIONS
truth_table([w,x,y,z]->f1);
0->1;2->1;4->1;6->1;8->1; 1->0;3->0;5->0;7->0;9->0;
0->1;3->1;4->1;7->1;8->1; 1->0;2->0;5->0;6->0;9->0;
1->1;2->1;3->1;4->1;9->1; 0->0;5->0;6->0;7->0;8->0;
5->1;6->1;7->1;8->1;9->1; 0->0;1->0;2->0;3->0;4->0;
test_vectors([w,x,y,z]->[f4,f3,f2,f1]);
0->3; 1->4; 2->5; 3->6; 4->7; 5->8; 6->9; 7->10; 8->11; 9->12;
END.
Las ecuaciones reducidas resultan:
f4 = (w) # (x & y) # (x & z); f3 = (x & !y & !z) # (!x & z) # (!x & y);
f2 = (!y & !z) # (y & z); f1 = (!z);
Y las de polaridad inversa:
!f4 = (!w & !y & !z) # (!w & !x); !f3 = (!x & !y & !z) # (x & y) # (x & z);
!f2 = (y & !z) # (!y & z); !f1 = (z);
5.6. Diseño de sistemas combinacionales.
5.6.1. Comparador binario.
Primero se plantean las variables que se emplearán:

Entradas: Se tienen dos números(N1 y N2) de dos cifras binarias cada uno.
Los resultados de la comparación son tres señales que denominaremos: Lt por less than(menor que),
Eq por equal(igual), y Gt por greather than(mayor que). También asumiremos que la cifra más
significativa de N1 será A, y B la menos significativa; la cifra más significativa de N2 será C, y D la
menos significativa.

Un diagrama general de las entradas y salidas del módulo combinacional que se diseñará es el
siguiente:
A B C D LT EQ GT
A LT AB<CD 0 0 0 0 0 1 0
N1 0 0 0 1 1 0 0
B 0 0 1 0 1 0 0
EQ AB=CD 0 0 1 1 1 0 0
C 0 1 0 0 0 0 1
N2
D GT AB>CD 0 1 0 1 0 1 0
0 1 1 0 1 0 0
0 1 1 1 1 0 0
Figura 5.32 Diagrama funcional comparador. 1 0 0 0 0 0 1
A continuación se especifica el diseño mediante 1 0 0 1 0 0 1
una tabla de verdad. Ésta tiene 16 renglones. 1 0 1 0 0 1 0
Cuando N1 igual a N2 se activa la señal EQ. 1 0 1 1 1 0 0
Cuando N1 es mayor que N2 se activa la señal GT. 1 1 0 0 0 0 1
1 1 0 1 0 0 1
Cuando N1 es menor que N2 se activa la señal LT.
1 1 1 0 0 0 1
1 1 1 1 0 1 0
Figura 5.33. Tabla del comparador.

A continuación se plantean los 3 mapas de 4 variables y se efectúa la minimización, se obtienen:
LT = A'B'D + A'C + B'CD
EQ = A'B'C'D' + A'BC'D + ABCD + AB'CD' = xnor(A, C) • xnor(B, D)
GT = BC'D' + AC' + ABD'
5.6.2. Multiplicador de dos números binarios de dos cifras cada uno.
Primero se plantean las variables que se emplearán:

Los resultados de la multiplicación son cuatro señales que denominaremos: P3 el bit más
significativo del producto, hasta P0 que será el bit menos significativo del producto. También
asumiremos que la cifra más significativa de N1 será A, y B la menos significativa; la cifra más
significativa de N2 será C, y D la menos significativa. Un diagrama general de las entradas y
salidas del módulo combinacional que se diseñará es el siguiente:

A B C D P3 P2 P1 P0
A P3 0 0 0 0 0 0 0 0
N1
B 0 0 0 1 0 0 0 0
P2 0 0 1 0 0 0 0 0
C P1 0 0 1 1 0 0 0 0
N2 P0
0 1 0 0 0 0 0 0
D 0 1 0 1 0 0 0 1
0 1 1 0 0 0 1 0
0 1 1 1 0 0 1 1
Figura 5.34. Diagrama funcional multiplicador. 1 0 0 0 0 0 0 0
A continuación se especifica el diseño mediante 1 0 0 1 0 0 1 0
una tabla de verdad. Ésta tiene 16 renglones. 1 0 1 0 0 1 0 0
1 0 1 1 0 1 1 0
1 1 0 0 0 0 0 0
Luego se plantean 4 mapas de 4 variables.
1 1 0 1 0 0 1 1
Después se minimiza, y se obtienen: 1 1 1 0 0 1 1 0
1 1 1 1 1 0 0 1
Figura 5.35. Tabla multiplicador
P3 = ABCD
P2 = BC'D + A'BD
P1 = AB'D + AC'D + BCD' + A'BC
P0 = AC
5.6.3. Incrementador en uno de cifra BCD.

Se asume que en la entrada se tiene una cifra BCD válida.
Primero se plantean las variables que se emplearán.
La entrada son cuatro señales que denominaremos: E3 el bit más significativo de la cifra BCD,
hasta E0 que será el bit menos significativo. La salida son cuatro señales que denominaremos: S3 el
bit más significativo de la cifra BCD aumentada en uno, hasta S0 que será el bit menos
significativo.
E3 S3
E2 S2
E1 S1
E0 S0
Figura 5.36. Diagrama funcional Incrementador

E3 E2 E1 E0 S3 S2 S1 S0
Se asume que cuando a 9 se le suma 1 se
0 0 0 0 0 0 0 1
obtiene cifra decimal 0. Se descarta la
0 0 0 1 0 0 1 0
reserva.
0 0 1 0 0 0 1 1
Se completa la tabla de verdad. 0 0 1 1 0 1 0 0
0 1 0 0 0 1 0 1
Se plantean 4 mapas de 4 variables y se 0 1 0 1 0 1 1 0
minimiza, empleando condiciones 0 1 1 0 0 1 1 1
superfluas, se obtienen: 0 1 1 1 1 0 0 0
1 0 0 0 1 0 0 1
S3 = E2 E1 E0 + E3 E0' 1 0 0 1 0 0 0 0
S2 = E2 E1' + E2 E0' + E2' E1 E0 1 0 1 0 d d d d
S1 = E3' E1' E0 + E1 E0' 1 0 1 1 d d d d
S0 = E0' 1 1 0 0 d d d d
1 1 0 1 d d d d
1 1 1 0 d d d d
1 1 1 1 d d d d
Figura 5.37. Tabla del incrementador BCD
5.6.4. Semisumador binario.
Se denomina semi-sumador a un dispositivo que permite sumar, en binario, dos variables de entrada
de un bit(Ai y Bi). El sistema debe generar dos salidas: la suma(Si) y la reserva de salida(Ci carry).
La tabla de verdad resulta:
Ai Bi Ci Si
Con las siguientes ecuaciones:
0 0 0 0
Si = A'iBi + AiB'i = Ai ⊕ Bi
0 1 0 1
1 0 0 1
Ci = Ai Bi
1 1 1 0
Ai
Si
Bi
Ci
Figura 5.38. Implementación semisumador.

5.6.5. Sumador completo.

Si se desea sumar variables de varios bits se requiere un sumador completo, que tenga una tercera
entrada denominada reserva de entrada(carry-in):
Ai Bi Ci
Ci+1 Si
Figura 5.39. Diagrama funcional sumador completo de un bit.
El esquema a continuación muestra una suma de varios bits en base a un sumador completo:
A3 B3 C3 A2 B2 C2 A1 B1 C1 A0 B0 C0
C4 S3 C3 S2 C2 S1 C1 S0
Figura 5.40. Diagrama funcional sumador completo de cuatro bits.
Las ecuaciones, en dos niveles, resultan:

Si = C i ⊕ A i ⊕ B i
C i +1 = B i C i + A i C i + A i Bi = C i (A i + B i) + A i B i
Ai
Ai Ci
Bi Ci
Ci+1
Bi
Si
Ci
Ai
Bi
Figura 5.41. Mapa con los mintérminos de f’

Un sumador completo, puede implementarse mediante dos semi-sumadores, observando que:

C i +1 = B i C i + A i C i + A i Bi = C i (A i + B i) + A i B i = C i (A i ⊕B i) + A i B i
Ai Ai ⊕ Bi Ai ⊕ Bi⊕ Ci
Bi Si
Ai Bi (Ai ⊕ Bi ) Ci
Ci+1
Ci
Figura 5.42. Sumador completo mediante dos semisumadores.
5.7. Detección y corrección de errores en bits.
En sistemas digitales, determinadas acciones sobre los datos colocan la integridad de éstos en
peligro. Ejemplo de procesos que pueden generar errores son: El almacenar bits en memorias
dinámicas o en medios magnéticos(superficies de discos flexibles o rígidos, que pueden dañarse
físicamente o contaminarse por interferencia en la escritura o lectura); la transmisión de bits
mediante conductores de cobre, fibra o en forma inalámbrica a través de grandes distancias.
Debe contemplarse en el diseño de sistemas digitales que estos errores pueden producirse y que
debe encontrarse procedimientos para tratarlos(existen técnicas analógicas para el tratamiento de
errores, que no se desarrollaran aquí).
La idea básica es que cuando se almacena o envía información se le agregue bits adicionales,
denominados de redundancia.
La detección de errores emplea los bits adicionales cuando se accesa o recibe información para
determinar si existe corrupción de los datos. En la corrección de errores, la información adicional
debe permitir detectar y corregir los errores, dentro de ciertos límites.
La detección requiere menos bits redundantes, pero si se detecta un error el receptor solicita que se
vuelvan a enviar los datos, lo cual agrega tiempo de latencia y complejidad.
En la corrección se tiene menor latencia, ya que el proceso de corrección es una parte de la lógica
que recibe los datos; y si los errores sobrepasan los límites de la corrección, debe solicitarse el
reenvío.
Existen procedimientos para detectar y corregir errores simples(paridad, Hamming) y

múltiples(códigos de redundancia cíclica).
5.7.1. Detección de un error simple.
Se envían n bits: b0, b1, b2, ..., bn-1. Se desea encontrar el modo de detectar un error de un bit.

Una solución es enviar n+1 bits, el bit n-avo es uno si existe un número impar de unos en los n bits
de datos. Por esto al bit redundante se lo denomina de paridad(par en este caso), ya que la
información más el bit adicional contienen una cantidad par de unos.
Para dos variables booleanas, el or exclusivo de ellas es cero si el número de unos es par; y uno si es
impar.
Para las n variables, la forma de computar(generar) el bit de paridad es mediante la siguiente

ecuación lógica:
bn = b0 ⊕ b1 ⊕ b2 ⊕...bn-1
Si los datos se disponen en paralelo(todos al mismo tiempo) puede determinarse la paridad

mediante un árbol combinacional mediante xors. Si los datos se tienen en serie, basta una
compuerta xor y un registro(o memoria) de un bit.
Para verificar la paridad, en el receptor se recalcula:

R = b0 ⊕ b1 ⊕ b2 ⊕...bn-1 ⊕ bn
Si (R = =1) se detecta un error simple en un bit, y se toma alguna medida.
Se emplea paridad en algunas situaciones, por ejemplo: en transmisión serial, en arreglos de

memoria donde cada bit de los n, se almacena en un chip diferente.
5.7.2. Corrección de un error simple.
Se envían n bits: b0, b1, b2, ..., bn-1. Se desea encontrar el modo de detectar y corregir un error en un
bit.
Códigos de Hamming(1950).
Se describe el procedimiento desarrollado por Hamming.
Se toman subconjuntos traslapables de b0, b1, b2, ..., bn-1.

Se calcula un bit de paridad para cada subconjunto.
Se envían m bits, n de datos y k de paridad.
Con suficientes bits de paridad puede identificarse el bit errado; ya que el receptor calcula una
palabra de chequeo, tal que si es cero, no hay errores; en caso de existir un error, el valor de la
palabra de chequeo indica la posición del bit errado. Para fijar el error, se complementa el bit en la
posición indicada por la palabra de chequeo.
Se tienen:
n bits de datos: b0, b1, b2, ..., bn-1.
k de paridad: p0, p1, p2, ..., pk-1.
m en total: c1, c2, ..., cm. Nótese que los bits ci se enumeran a partir de uno.
Primera etapa: Asignar los bi y pi con ci .

Se asigna cada bi y cada pi una sola vez. Primero se asigna c1, luego c2 y así sucesivamente.
Se asigna ci a un bit de paridad si i es una potencia de dos; en caso contrario se asigna el ci a un bit
de dato. El proceso se detiene cuando no quedan mas bits bi que asignar.
Ejemplo con n = 4. Se tienen b0, b1, b2, b3

Se asigna: c1 = p0 Ya que 20 = 1.

Luego: c2 = p1 Ya que 21 = 2.
c3 = b0 Ya que i = 3 no es una potencia de dos.
c4 = p2 Ya que 22 = 4.
c5 = b1
c6 = b2
c7 = b3 En este paso no quedan más bits que asignar.
En este caso resulta k = 3, y m = 7. Deben enviarse tres bits adicionales para detectar y corregir un
error simple. Si n es elevado se tendrá que k es aproximadamente igual a log2 (n).
Cuatro bits de paridad permiten un máximo de m = 16, con 12 de datos.
Cinco bits de paridad permiten un máximo de m = 32, con 27 de datos.
Segunda etapa: Cálculo de los bits de paridad.

La determinación de los subconjuntos de c1, c2, ..., cm. debe permitir encontrar la posición del bit
errado. Para ello se escriben los ci en binario, y se forma un subconjunto con todos los bits que
tengan un uno en determinada posición de la secuencia binaria. Debido a la elección de los pi, sólo
estará presente un pi en cada subconjunto. Se calcula el pi del subconjunto como el xor de los bits
de datos del subconjunto.
En el ejemplo con m = 7, se tienen:

c1 = c001 = p0 Los subconjuntos, resultan: Los bits de paridad se b0
b1 p0
c2 = c010 = p1 (c1, c3, c5, c7) = (p0, b0, b1, b3) calculan según: b3
c3 = c011 = b0 (c2, c3, c6, c7) = (p1, b0, b2, b3) p 0 = b0 ⊕ b 1 ⊕ b 3
c4 = c100 = p2 b0
(c4, c5, c6, c7) = (p2, b1, b2, b3) p1 = b0 ⊕ b2 ⊕ b3 b2 p1
c5 = c101 = b1 p 2 = b1 ⊕ b 2 ⊕ b 3 b3
c6 = c110 = b2
c7 = c111 = b3 b1
b2 p2
b3
Figura 5.43. Generación bits de paridad
Tercera etapa: Corregir el error de un bit en recepción:

Se separan los datos recibidos en subconjuntos, se calcula wi, el xor de todos los elementos de cada
subconjunto(incluidos los bits de paridad). Se calcula el valor de chequeo, mediante:
chequeo = w0 + 2* w1 + 4* w2 + ....
Si el valor de chequeo no es cero, un bit debe ser erróneo. Cada wi = 0 remueve la duda sobre
algunos bits. Cualquier bit puede tener un error(solo un bit), incluso uno de los de paridad puede
haberse contaminado en la transmisión o lectura. Si un bit está errado existe sólo una forma de
corregirlo.
Si chequeo es cero, no hay error simple. En caso contrario se complementa el bit cchequeo

c2
Para m = 7 se calculan los wi, a partir de los ci: c3
c1 c6 w1
w0 = (c1 ⊕ c3 ⊕ c5 ⊕ c7) = (p0 ⊕ b0 ⊕ b1 ⊕ b3) c3 c7
c5 w0
w1 = (c2 ⊕ c3 ⊕ c6 ⊕ c7) = (p1 ⊕ b0 ⊕ b2 ⊕ b3) c4
c7
w2 = (c4 ⊕ c5 ⊕ c6 ⊕ c7) = (p2 ⊕ b1 ⊕ b2 ⊕ b3) c5
c6 w2
c7
Figura 5.44. Cálculo de los wi.

El valor de chequeo resulta: chequeo = w0 + 2* w1 + 4* w2
La siguiente tabla muestra los valores binarios de los wi posibles, y asumiendo que sólo un bit del
subconjunto puede estar errado si wi es uno; y que si wi es cero, los elementos del subconjunto
asociado están correctos.
Estudiemos el segundo renglón: Con w2 igual a cero, no pueden estar errados: p2, b1, b2, b3; y si
además w1 es cero: p1, b0, b2, b3 llegan correctamente; y si w0 es 1 podría existir un error en p0, b0,
b1, b3. Pero de las listas anteriores: b0, b1, b2 y b3 llegaron correctamente; por lo tanto se determina
que en este caso p0 llegó errado.
w2 w1 w0 chequeo Pueden tener error No están errados Bit errado

0 0 0 0 ninguno todos ninguno
0 0 1 1 p0, b0, b1, b3 p1, b0, b2, b3, p2, b1 p0
0 1 0 2 p1, b0, b2, b3 p0, b0, b1, b3, p2, b2 p1
0 1 1 3 p0, b0, b1, b3, p1, b2 p2, b1, b2, b3 b0
1 0 0 4 p2, b1, b2, b3 p0, b0, b1, b3, p1, b2 p2
1 0 1 5 p0, b0, b1, b3, p2, b2 p1, b0, b2, b3 b1
1 1 0 6 p1, b0, b2, b3, p2, b1 p0, b0, b1, b3 b2
1 1 1 7 b3 b3
Figura 5.45. Interpretación tabla de valores de wi
En la siguiente red, si w0 y w1 son unos y w2 es cero, se tendrá que f0 es b0'; en caso contrario es b0.
w0 w0 w'0
w1 w'1 w1
w'2 f0 w2 f1 w2 f2
c3 c5 c6
w0
w1
w2 f3
c7
Figura 5.46. Corrección empleando wi

c1 = c001 = p0 = 0
Ejemplo. Con: b0 = 0; b1 = 1; b2= 0; b3 = 1 c2 = c010 = p1 = 1
Los bits de paridad se calculan según: c3 = c011 = b0 = 0
p 0 = b0 ⊕ b 1 ⊕ b 3 = 0 ⊕ 1 ⊕ 1 = 0 c4 = c100 = p2 = 0
p1 = b0 ⊕ b2 ⊕ b3 = 0 ⊕ 0 ⊕ 1 = 1 c5 = c101 = b1 = 1
p 2 = b1 ⊕ b 2 ⊕ b 3 = 1 ⊕ 0 ⊕ 1 = 0 c6 = c110 = b2 = 0
c7 = c111 = b3 = 1
Se calculan los wi, a partir de los ci , recibidos sin errores, según:

w0 = (c1 ⊕ c3 ⊕ c5 ⊕ c7) = (p0 ⊕ b0 ⊕ b1 ⊕ b3) = (0 ⊕ 0 ⊕ 1 ⊕ 1) = 0
w1 = (c2 ⊕ c3 ⊕ c6 ⊕ c7) = (p1 ⊕ b0 ⊕ b2 ⊕ b3) = (1 ⊕ 0 ⊕ 0 ⊕ 1) = 0
w2 = (c4 ⊕ c5 ⊕ c6 ⊕ c7) = (p2 ⊕ b1 ⊕ b2 ⊕ b3) = (0 ⊕ 1 ⊕ 0 ⊕ 1) = 0
El valor de chequeo resulta: chequeo = w0 + 2* w1 + 4* w2 = 0
Se calculan los wi, a partir de los ci , asumiendo que c3 llega errado, según:
w0 = (c1 ⊕ c3 ⊕ c5 ⊕ c7) = (p0 ⊕ b0 ⊕ b1 ⊕ b3) = (0 ⊕ 1 ⊕ 1 ⊕ 1) = 1
w1 = (c2 ⊕ c3 ⊕ c6 ⊕ c7) = (p1 ⊕ b0 ⊕ b2 ⊕ b3) = (1 ⊕ 1 ⊕ 0 ⊕ 1) = 1
w2 = (c4 ⊕ c5 ⊕ c6 ⊕ c7) = (p2 ⊕ b1 ⊕ b2 ⊕ b3) = (0 ⊕ 1 ⊕ 0 ⊕ 1) = 0
El valor de chequeo resulta:
chequeo = w0 + 2* w1 + 4* w2 = 1 + 2*1 +4 *0 = 3, lo cual implica que debe complementarse c3.
w0 = (c1 ⊕ c3 ⊕ c5 ⊕ c7) = (p0 ⊕ b0 ⊕ b1 ⊕ b3) = (0 ⊕ 0 ⊕ 0 ⊕ 1) = 1
w1 = (c2 ⊕ c3 ⊕ c6 ⊕ c7) = (p1 ⊕ b0 ⊕ b2 ⊕ b3) = (1 ⊕ 0 ⊕ 0 ⊕ 1) = 0
w2 = (c4 ⊕ c5 ⊕ c6 ⊕ c7) = (p2 ⊕ b1 ⊕ b2 ⊕ b3) = (0 ⊕ 0 ⊕ 0 ⊕ 1) = 1
w0 = (c1 ⊕ c3 ⊕ c5 ⊕ c7) = (p0 ⊕ b0 ⊕ b1 ⊕ b3) = (1 ⊕ 0 ⊕ 1 ⊕ 1) = 1
w1 = (c2 ⊕ c3 ⊕ c6 ⊕ c7) = (p1 ⊕ b0 ⊕ b2 ⊕ b3) = (1 ⊕ 0 ⊕ 0 ⊕ 1) = 0
w2 = (c4 ⊕ c5 ⊕ c6 ⊕ c7) = (p2 ⊕ b1 ⊕ b2 ⊕ b3) = (0 ⊕ 1 ⊕ 0 ⊕ 1) = 0

Índice de Figuras.
Figura 5.20. Mapa de Karnaugh a partir de los mintérminos. ........................................................................95
Figura 5.21. Agrupaciones en el Mapa de Karnaugh. .....................................................................................96
Figura 5.22. Mapa de Karnaugh con los mintérminos. ....................................................................................96
Figura 5.23. Mínimo número de grupos..........................................................................................................97
Figura 5.24. Solución ejemplo 5.5.3. ...............................................................................................................98
Figura 5.25. Solución ejemplo 5.5.4. ..............................................................................................................98
Figura 5.26. Mapa con los mintérminos de ejemplo 5.5.1.2 .........................................................................100
Figura 5.27. Mapa con los mintérminos de f’ ...............................................................................................100
Figura 5.28. Mapa con condiciones superfluas. ............................................................................................101
Figura 5.29. Mapa con condiciones superfluas de f’.....................................................................................102
Figura 5.30. Tabla traductor BCD a Exceso-3. .............................................................................................103
Figura 5.31. Mapa de las condiciones superfluas del ejemplo 5.5.2.3. .........................................................103
Figura 5.32 Diagrama funcional comparador.................................................................................................106
Figura 5.33. Tabla del comparador. ...............................................................................................................106
Figura 5.34. Diagrama funcional multiplicador. ...........................................................................................107
Figura 5.35. Tabla multiplicador...................................................................................................................107
Figura 5.36. Diagrama funcional Incrementador ...........................................................................................107
Figura 5.37. Tabla del incrementador BCD ...................................................................................................108
Figura 5.38. Implementación semisumador. ..................................................................................................108
Figura 5.39. Diagrama funcional sumador completo de un bit. .....................................................................109
Figura 5.40. Diagrama funcional sumador completo de cuatro bits..............................................................109
Figura 5.41. Mapa con los mintérminos de f’ ...............................................................................................109
Figura 5.42. Sumador completo mediante dos semisumadores.....................................................................110
Figura 5.43. Generación bits de paridad........................................................................................................112
Figura 5.44. Cálculo de los wi.......................................................................................................................113
Figura 5.45. Interpretación tabla de valores de wi ........................................................................................113
Figura 5.46. Corrección empleando wi .........................................................................................................113

Minimización usando mapas de Karnaugh

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Minimización usando mapas de Karnaugh

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD TECNICA FEDERICO SANTA MARIA

5.5. Minimización usando mapas de Karnaugh.

Deben respetarse las siguientes reglas:

• Debe formarse el menor número de agrupaciones de bloques; ya que a menor número de

Ejemplo 5.5.1. Minimización a partir de los mintérminos

Prof. Leopoldo Silva Bijit. 05-03-2004 95

Ejemplo 5.5.2. Formación de grupos de mintérminos en minimización basada en

Dibujando un mapa para cuatro variables, se logra:

Prof. Leopoldo Silva Bijit. 05-03-2004 96

Figura 5.23. Mínimo número de grupos.

Prof. Leopoldo Silva Bijit. 05-03-2004 97

Figura 5.24. Solución ejemplo 5.5.3.

Prof. Leopoldo Silva Bijit. 05-03-2004 98

Empleando lenguaje Abel, para efectuar la minimización, se tiene:

Y después de la minimización se logra:

5.5.1. Minimización en forma de producto de sumas.

Dada: f(A, B, C, D) = A + C’D’ + B’D = (A + B’ + D’)(A + C’ + D) obtener forma canónica

Conviene escribir: f ’ = A’BD + A’CD’

Se obtiene del mapa: f’ = ∑m(2, 5, 6, 7) = m2 + m5 + m6 + m7

Prof. Leopoldo Silva Bijit. 05-03-2004 99

Figura 5.26. Mapa con los mintérminos de ejemplo 5.5.1.2

Luego, para f ' el mapa resulta:

Se obtiene: f’= A’B’ + BCD’ + B’C’D

Prof. Leopoldo Silva Bijit. 05-03-2004 100

Finalmente, por De Morgan: f = (A +B) (B’ +C’ +D’) (B +C +D’)

5.5.2. Condiciones superfluas (don't care)

Prof. Leopoldo Silva Bijit. 05-03-2004 101

Puede agruparse (0,1) y (5,7). En este caso: f = A’B’ + AC

Sin embargo, la agrupación más conveniente es (0,1,4,5), y así se obtiene: f = B’

Si en el ejemplo anterior, se minimiza la función f, como suma de productos, se logra:

f(A, B, C) = Σm(0, 1, 5) + Σd(2, 6) = A’C’ + B’C

La simplificación de expresiones booleanas mediante reducciones algebraicas presenta dificultades

Prof. Leopoldo Silva Bijit. 05-03-2004 102

Prof. Leopoldo Silva Bijit. 05-03-2004 103

Minimizando, se logra para el sistema de múltiples salidas:

Si se dibuja un esquema lógico, mediante OR de ANDs, puede apreciarse que en un sistema de

Diseño empleando Abel.

El lenguaje permite la optimización empleando condiciones superfluas para reducir la cantidad de

Cuando se emplea la optimización con condiciones superfluas debe cuidarse de no especificar

Prof. Leopoldo Silva Bijit. 05-03-2004 104

Diseñar traductor de código BCD a exceso-3, empleando lenguaje Abel

5.6. Diseño de sistemas combinacionales.

5.6.1. Comparador binario.

Primero se plantean las variables que se emplearán:

Prof. Leopoldo Silva Bijit. 05-03-2004 105

Figura 5.33. Tabla del comparador.

5.6.2. Multiplicador de dos números binarios de dos cifras cada uno.

Primero se plantean las variables que se emplearán:

Prof. Leopoldo Silva Bijit. 05-03-2004 106

Figura 5.35. Tabla multiplicador

5.6.3. Incrementador en uno de cifra BCD.

Figura 5.36. Diagrama funcional Incrementador

Prof. Leopoldo Silva Bijit. 05-03-2004 107

Figura 5.37. Tabla del incrementador BCD

5.6.4. Semisumador binario.

Figura 5.38. Implementación semisumador.

Prof. Leopoldo Silva Bijit. 05-03-2004 108

5.6.5. Sumador completo.

Figura 5.39. Diagrama funcional sumador completo de un bit.

Figura 5.40. Diagrama funcional sumador completo de cuatro bits.

Las ecuaciones, en dos niveles, resultan:

Figura 5.41. Mapa con los mintérminos de f’

Prof. Leopoldo Silva Bijit. 05-03-2004 109