Ejercicios resueltos del tema 3 1

EJERCICIOS RESUELTOS TEMA 3

EJERCICIO 1

Este ejercicio es un ejemplo de cómo se puede simplificar una función booleana utilizando la
notación de cubos. Su objetivo es aclarar el concepto de cubo y su uso, pero debe tenerse muy
en cuenta que existen multitud de programas capaces de realizar esta minimización
automáticamente y que el diseñador, en la práctica, nunca tendrá que realizar este proceso
manual.

Dados los siguientes minterms de una función, utilizad la notación cúbica para obtener una
expresión mínima. Los minterms en rojo representan términos redundantes.

𝑓(𝑎, 𝑏, 𝑐, 𝑑) = Σ(𝑚5 + 𝑚6 + 𝑚7 ) + Σ𝑑 (𝑚3 + 𝑚4 + 𝑚12 )

En primer lugar explicaremos la notación utilizada: El término Σ(… ) se utiliza para indicar los
minterms que forman parte de la función, mientras que es término Σ𝑑 (… ) se utiliza para
indicar los términos redundantes.

El proceso de minimización consta de dos pasos. En el primero se buscan todos los implicantes
de la función, encontrando todas las parejas de minterms que difieren en un único bit, y
repitiendo este proceso con los implicantes que se van encontrando. Conforme se van
encontrando implicantes, los términos o implicantes de los que proceden se van marcando. El
segundo paso consiste en buscar un conjunto mínimo de implicantes no marcados que cubran
todos los minterms de la función, sin tener en cuenta los minterms redundantes.

1r paso: Búsqueda de todos los implicantes que se pueden obtener directamente de los
minterms. Hemos divido los minterms en dos grupos, escribiendo en rojo los minterms
redundantes. Asimismo, si un implicante proviene de dos minterms redundates, también lo
escribiremos en rojo. (Hemos numerado los minterms y los implicantes para mayor claridad)

Minterm marca
1 𝑚5 =0101
2 𝑚6 =0110
3 𝑚7 =0111

4 𝑚3 =0011
5 𝑚4 =0100
6 𝑚12 =1100

Los minterms numerados como 1 y 3 difieren en 1 bit y dan lugar al implicante 01x1. Puesto
que este implicante contiene a los minterms 1 y 3, los marcamos:

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 2

Minterns
Minterm marca implicante marca
de origen
1 0101 
2 0110 7 1,3 01x1
3 0111 

4 0011
5 0100
6 1100

Siguiendo el mismo proceso, los minterms numerados como 1 y 5 generan el implicante 010x
y los minterms numerados como 5 y 6 generan el implicante x100. Como el implicante x100
proviene de dos minterms redundantes, lo marcamos en rojo:

Minterns
Minterm marca implicante marca
de origen
1 0101 
7 1,3 01x1
2 0110
 8 1,5 010x
3 0111

4 0011
5 0100  12 5,6 x100
6 1100 

Repitiendo el mismo proceso con todas las parejas de minterms obtenemos:

Minterns
Minterm marca implicante marca
de origen
7 1,3 01x1
1 0101  8 1,5 010x
2 0110  9 2,3 011x
3 0111  10 2,5 01x0
11 3,4 0x11

4 0011 
5 0100  12 5,6 x100
6 1100 

El siguiente paso consiste en buscar los implicantes de la lista que acabamos de construir que
difieren en un único bit (0 o 1) para formar implicantes de orden superior:

Minterns Implicante Impl. Impl.

Minterm marca marca
de origen (orden1) origen (ord 2)
7 1,3 01x1 
1 0101  8 1,5 010x 
 7,10 01xx
2 0110  9 2,3 011x
  8,9 01xx
3 0111 10 2,5 01x0
11 3,4 0x11

4 0011 
5 0100  12 5,6 x100
6 1100 

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 3

Los dos implicantes de orden 2 que hemos obtenido son iguales (01xx), así que ya no podemos
seguir buscando implicantes de orden superior. Fijémos que nos han quedado 3 implicantes
sin marcar, el 01xx, el 0x11 y el x100. Este último contiene sólo terminos redundantes, así que
no necesitaremos cogerlo.

La segunda parte consiste en buscar un conjunto de implicantes no marcados que contenga

todos los minterms de la función (salvo los redundantes, que no los necesitamos para nada):

Minterms
(según numeración)
implicante 1 2 3
01xx   
0x11 

El implicante 01xx contiene todos los minterms de la función, así que la función simplificada
será:

𝑓(𝑎, 𝑏, 𝑐, 𝑑) = 𝑎̅. 𝑏

Cuando el número de variables de la función es menor o igual a 4 se puede utilizar un método

de reprsentación gráfica, los llamados “mapas de Karnaugh”. En este curso no los explicamos
por considerar que su uso es demasiado limitado, pero se puede encontrar multitud de
páginas web que explican su funcionamiento (véase por ejemplo la wikipedia:
http://es.wikipedia.org/wiki/Mapa_de_Karnaugh )

EJERCICIO 2

Diseñar un circuito que acepta 4 bits de entrada x,y,z,w, y genera dos señales de salida f y g de
acuerdo con la siguiente descripción:
case xy is
when “00” => f<=z; g<=w;
when “01” => f<=0; g<=z+w;
when “10” => f<=z; g<=0;
when “11” => f<=1; g<=1;
end case;

Podemos resolver el problema de dos maneras:

Aproximación 1: Creamos la tabla de verdad y la entramos al minimizador de funciones de

Logisim (Proyecto→Analizar Circuito), o, “a mano”, creamos la tabla de verdad, obtenemos al
forma canónica de f y g, y simplificamos las funciones resultantes.

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 4

x y z w f g
0 0 0 0 0 0
0 0 0 1 0 1
0 0 1 0 1 0
0 0 1 1 1 1
0 1 0 0 0 0
0 1 0 1 0 1
0 1 1 0 0 1
0 1 1 1 0 1
1 0 0 0 0 0
1 0 0 1 0 0
1 0 1 0 1 0
1 0 1 1 1 0
1 1 0 0 1 1
1 1 0 1 1 1
1 1 1 0 1 1
1 1 1 1 1 1

Utilizarmos al primera opción. Entrando esta tabla en el minimizador de funciones de Logisim

se obtiene:

𝑓 = 𝑥. 𝑦 + 𝑦̅. 𝑧

𝑔 = 𝑥̅ . 𝑤 + 𝑦. 𝑧 + 𝑥. 𝑦

Aproximación 2: El circuito puede también implementarse directamente desde su descripción

en pseudocódigo, sin necesidad de escribir la tabla de verdad, siguiendo las explicaciones de la
lección L3.4.

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 5

Los multiplexores de la figura son multiplexores 4-a-1, con dos entradas de control x e y que
aquí se han representado por un bus de 2 bits. Las entradas a los multiplexores se
corresponden, de arriba abajo, a los valores de las señales de control xy=00, xy=01, xy=10 y
xy=11 respectivamente.

EJERCICIO 3

Construye un circuito que acepta 4 entradas x,y,z,w, (x e y son señales de 1bit; z y w son
números binarios de n bits); y genera dos salidas f y g de n bits cada una de acuerdo con la
siguiente descripción:

case xy is
when “00” => f<=z; g<=w;
when “01” => f<=0; g<=z+w;
when “10” => f<=z; g<=0;
when “11” => f<=1; g<=1;
end case;

Nota:
1) La operación z+w representa una suma aritmética de dos números de n bits, y
2) Las expresiones “f <= 1; g <= 1”, o “f <= 0” significan que todos los bits de f y g toman
el valor indicado.

Evidentemente en este caso no podemos construir ninguna tabla de verdad puesto z y w son
números de n bits en general. Lo que si podemos hacer es construir el circuito directamente
desde el algoritmo.

El circuito será prácticamente idéntico al desarrollado en el ejercicio anterior, con la salvedad

de que los multiplexores son ahora multiplexores 4-a-1 de n bits y que la suma de los números
w y z es una suma aritmética que podemos implementar con un sumador binario de n bits:

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 6

(Cuando un bus de n bits se conecta a un bus de n+1 bits se entiende que el bit más
significativo del bus de n+1 líneas se ha fijado a 0).

La figura de la izquierda muestra el detalle del MUX que genera las salidas f en caso que
utilizásemos MUXs convencionales de 4-a-1 de 1 bit, mientras que la figura de la derecha
muestra el detalle del MUX que genera las salidas g.

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 7

EJERCICIO 4

Diseñar un sumador de 2 dígitos expresados en código BCD.

Recordatorio: El código BCD codifica cada cifra decimal del 0 al 9 en binario utilizando 4 bits. El
0 se codifica por 0000, el 1 por 0001, el 2 por 0010, y así sucesivamente hasta el 9 que se
codifica por 1001. Los números decimales mayores que 9 requieren 8 bits (por ejemplo, el 13
se codifica como 0001 0011) y nunca serán entradas a este circuito.

Nos piden un circuito como el siguiente:

Una implementación directa mediante la tabla de verdad es complicada porque el circuito

tiene 9 entradas y por tanto la tabla de verdad tendría 512 líneas … , así que vamos a intentar
una aproximación diferente: Utilizaremos un sumador de números binarios de 4 bits, que ya ha
sido diseñado en las lecciones de esta semana y la anterior, y le añadiremos a la salida un
circuito que “corrija” el resultado, expresando la suma en BCD.

Si A y B son dígitos BCD, el valor máximo que puede tomar la suma (más el cIN) es 19 (9+9+1),
que para representarlo en BCD necesitaremos 8 bits. Llamaremos S0 a los 4 bits menos
significativos y S1 a los 4 bits más significativos. Visto así, nuestro problema se reduce a
diseñar el “circuito corrector” de la figura.

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 8

El circuito corrector tiene 5 entradas (tabla de verdad de 32 filas) y 8 salidas, valores todavía
aceptables para implementar el circuto a partir de la tabla de verdad:

carryOUT suma3 suma2 suma1 suma0 S13 S12 S11 S10 S03 S02 S01 S00
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 0 0 0 1 0
0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 1 0 0 0 0 0 0 0 1 0 0
0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 1 1 0 0 0 0 0 0 1 1 0
0 0 1 1 1 0 0 0 0 0 1 1 1
0 1 0 0 0 0 0 0 0 1 0 0 0
0 1 0 0 1 0 0 0 0 1 0 0 1
0 1 0 1 0 0 0 0 1 0 0 0 0
0 1 0 1 1 0 0 0 1 0 0 0 1
0 1 1 0 0 0 0 0 1 0 0 1 0
0 1 1 0 1 0 0 0 1 0 0 1 1
0 1 1 1 0 0 0 0 1 0 1 0 0
0 1 1 1 1 0 0 0 1 0 1 0 1
1 0 0 0 0 0 0 0 1 0 1 1 0
1 0 0 0 1 0 0 0 1 0 1 1 1
1 0 0 1 0 0 0 0 1 1 0 0 0
1 0 0 1 1 0 0 0 1 1 0 0 1
1 0 1 0 0 x x x x x x x x
1 0 1 0 1 x x x x x x x x
1 0 1 1 0 x x x x x x x x
1 0 1 1 1 x x x x x x x x
1 1 0 0 0 x x x x x x x x
1 1 0 0 1 x x x x x x x x
1 1 0 1 0 x x x x x x x x
1 1 0 1 1 x x x x x x x x
1 1 1 0 0 x x x x x x x x
1 1 1 0 1 x x x x x x x x
1 1 1 1 0 x x x x x x x x
1 1 1 1 1 x x x x x x x x

El mayor número que puede aparecer a la entrada del circuito corrector es el 19 (1 0 0 1 1 en

binario). Cualquier número de valor superior nunca aparecerá a la entrada del circuito
corrector, de modo que dichos términos pueden establecerse como redundantes.

Entrando esta tabla de verdad a la herramienta de minimización obtenemos:

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 9

𝑆13 = 𝑆12 = 𝑆11 = 0

𝑆10 = 𝑠𝑢𝑚𝑎3 . 𝑠𝑢𝑚𝑎1 + 𝑠𝑢𝑚𝑎3 . 𝑠𝑢𝑚𝑎2 + 𝑐𝑎𝑟𝑟𝑦𝑂𝑈𝑇

𝑆03 = 𝑠𝑢𝑚𝑎3 . ̅̅̅̅̅̅̅̅̅.

𝑠𝑢𝑚𝑎2 ̅̅̅̅̅̅̅̅̅
𝑠𝑢𝑚𝑎1 + 𝑠𝑢𝑚𝑎1 . 𝑐𝑎𝑟𝑟𝑦𝑂𝑈𝑇

𝑆02 = ̅̅̅̅̅̅̅̅̅.
𝑠𝑢𝑚𝑎3 𝑠𝑢𝑚𝑎2 + 𝑠𝑢𝑚𝑎2 . 𝑠𝑢𝑚𝑎1 + ̅̅̅̅̅̅̅̅̅.
𝑠𝑢𝑚𝑎1 𝑐𝑎𝑟𝑟𝑦𝑂𝑈𝑇

𝑆01 = ̅̅̅̅̅̅̅̅̅.
𝑠𝑢𝑚𝑎3 𝑠𝑢𝑚𝑎1 . ̅̅̅̅̅̅̅̅̅̅̅̅
𝑐𝑎𝑟𝑟𝑦𝑂𝑈𝑇 + 𝑠𝑢𝑚𝑎3 . 𝑠𝑢𝑚𝑎2 . 𝑠𝑢𝑚𝑎1 + 𝑠𝑢𝑚𝑎1 . 𝑐𝑎𝑟𝑟𝑦𝑂𝑈𝑇

𝑆003 = 𝑠𝑢𝑚𝑎0

Este circuito deberá conectarse a las salidas de sumador binario.

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 10

EJERCICIO 5

Este ejercicio es un ejemplo más de cómo construir un circuito a partir del algoritmo. En los
problemas 7 y 8 de los ejercicios semanales vimos cómo se puede construir un sistema digital
que, dados 3 números x, y, max, enteros y de n bits, devuelve un valor z, entero y de n bits, tal
que:

▪ Si 0 ≤ x - y ≤ max entonces z = x - y;
▪ Si (x - y)> max, entonces z = max;
▪ Si (x - y)< 0, entonces z = 0.
Esto lo hicimos suponiendo que disponíamos de un componente (un procedimiento)
difference(A, B, s, C), que calcula A – B y devuelve el signo de la resta en s y el valor absoluto
de la resta en C.
En este problema diseñaremos el componente difference(A, B, s, C)

Dados dos números A y B expresados en base 2, enteros, positivos y de n bits,

1) Escribir un algoritmo que describa un procedimiento difference (A,B,s,C), que calcula la
diferencia A-B bajo la forma A – B = (-1)s·C, suponiendo que los componentes de biblioteca
de los que disponemos son puertas lógicas y multiplexores.
2) Diseñar un circuito que implemente dicho algoritmo.

Básicamente, el algoritmo que buscamos debe hacer la resta A-B y ver si el resultado es
positivo, en cuyo caso s=0 y C=A-B, o negativo, en cuyo caso s=1 y C=B-A. Para hacerlo más
fácil, vamos a imaginarnos que disponemos de un componente RESTA(A,B,carryOUT,R) tal
que si AB el resultado de la resta es R=A-B y carryOUT=0, y si A<B el resultado R es
erróneo (no es la resta de A-B) y carryOUT =1

Un algoritmo posible es el siguiente:

Procedure difference (A,B,s,C)

RESTA(A,B,carry1,R1);
RESTA(B,A,carry2,R2);
If carry1=0 then C<=R1;
else C<=R2;
endif;

Del algoritmo obtenemos directamente el siguiente circuito:

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 11

Figura 1

Se ha dibujado un MUX 2-a-1 de n bits. Su equivalente con multiplexores de 1 bit se muestra

en la siguiente figura:

Figura 2

El procedimiento RESTA puede construirse siguiendo el algoritmo “natural” de la resta,

haciendo las operaciones columna a columna de una manera similar a cómo se construye un
sumador para números de n bits. Supongamos que disponemos de un componente
(procedimiento) que realiza resta los dígitos i de los números X e Y teniendo en cuenta si en la
etapa anterior se ha generado un acarreo (carry(i)), y calcula el bit i-ésimo de la resta y el
acarreo para la etapa siguiente, carry(i+1). Llamemos RestaColumna(x(i),y(i),carry(i),
carry(i+1),R(i)) a dicho procedimiento. El procedimiento RESTA podemos escribirlo como:

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 12

Procedure RESTA(X,Y,carryOUT,R) /* X, Y y R: n bits; carryOUT : 1 bit

carry(0)<=0;
for i in 0 to n loop;
RestaColumna(x(i),y(i),carry(i),carry(i+1),R(i));
end loop;
carryOUT<=carry(n);

El modulo RESTA puede construirse, por tanto, como:

Figura 3

Todo lo que falta por hacer es describir el procedimiento RestaColumna y construirlo con
puertas lógicas:

Procedure RestaColumna(x,y,carryIN,carryOUT,R) /* Todos números de 1 bit

z <= y + carryIN;
If z > x then R <= x + 2 - z; carryOUT <= 1;
else R <= x - z; carryOUT <= 0;
end if;

El módulo RestaColumna tiene 3 entradas y 2 salidas, de modo que es posible representarlo

por una tabla de verdad:
x y carryIN carryOUT R
0 0 0 0 0
0 0 1 1 1
0 1 0 1 1
0 1 1 1 0
1 0 0 0 1
1 0 1 0 0
1 1 0 0 0
1 1 1 1 1

Escribiendo las expresiones canónicas de las funciones carryOUT y R, y simplificándolas se

obtiene:
𝑅 = 𝑥⨁𝑦⨁𝑐𝑎𝑟𝑟𝑦𝐼𝑁
̅̅̅̅̅̅) + 𝑥̅ . 𝑦
𝑐𝑎𝑟𝑟𝑦𝑂𝑈𝑇 = 𝑐𝑎𝑟𝑟𝑦𝐼𝑁 . (𝑥⨁𝑦

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán

Ejercicios resueltos del tema 3 13

Con lo que el módulo RestaColumna queda:

Figura 4

Lo único que quedaría por hacer es ir sustituyendo los módulos RestaColumna de la figura 3
por este circuito construido con puertas lógicas y sustituir los módulos RESTA de la figura 1
por el esquema resultante de esta operación. Con esto obtendremos el diseño del módulo
difference que nos pedían, utilizando como componentes las puertas lógicas y multiplexores.
Fijémonos que este diseño es totalmente modular y válido para cualquier valor de n.

©Elena Valderrama, Jean-Pierre Deschamps, Mercè Rullán