2-6 Modulos Combinacionales Basicos

Titulación: Ingeniería Informática
Asignatura: Fundamentos de Computadores
Bloque 2: Sistemas combinacionales

Tema 6: Módulos combinacionales básicos
Pablo Huerta Pellitero

Ángel Serrano
Módulos combinacionales básicos
ÍNDICE
• Bibliografía
• Introducción
• Codificadores y decodificadores
 Síntesis de funciones de conmutación con decodificadores
• Multiplexores y demultiplexores
 Síntesis de circuitos combinacionales con multiplexores
• Desplazadores
• Comparadores
• Dispositivos lógicos programables
• Módulos aritméticos básicos
 Sumador
 Restador
 Sumador/Restador
• Unidad aritmético-lógica
2
BIBLIOGRAFÍA
• Román Hermida, Ana Mº del Corral, Enric Pastor, Fermín Sánchez

“Fundamentos de Computadores” , cap 3
Editorial Síntesis
• Thomas L. Floyd
“Fundamentos de Sistemas Digitales”, cap 6,7
Editorial Prentice Hall
• Daniel D. Gajski
“Principios de Diseño Digital”, cap 5
• M. Morris Mano
“Diseño Digital”, cap 4,5
3
INTRODUCCIÓN
• Las materializaciones en forma de redes de puertas básicas no son

adecuadas cuando la complejidad del diseño es grande. En estos casos se
realiza diseño jerárquico en base a redes de módulos combinacionales
básicos, y no mediante redes de puertas básicas.
• Ese diseño jerárquico y modular se puede llevar a cabo si se dispone de
módulos que realicen funciones más complejas que las puertas básicas y
que permitan dividir el diseño en partes más sencillas.
• En lo que sigue de tema se explican algunos de los módulos
combinacionales de los que es conveniente disponer y cómo utilizarlos
como módulos básicos para realizar diseños más complejos.
• Estos módulos son: decodificador, codificador, multiplexor, demultiplexor,
desplazador, comparador, algunos módulos aritméticos y dispositivos
programables.
4
ÍNDICE
• Bibliografía
• Introducción
• Desplazadores
• Comparadores
 Sumador
 Restador
5
DECODIFICADORES
• Un decodificador (o decodificador de n a 2n) es un módulo combinacional

con ‘n’ entradas (X0, X1, … Xn-1), y 2n salidas (Y0, Y1, Y2, …), además de una
señal de activación (Enable).
• El funcionamiento del decodificador es el siguiente:
 Si Enable está desactivada todas las salidas Yi toman
el valor ‘0’.
 Si Enable está activada se activará la salida de índice
I, siendo I el número decimal codificado en las
entradas X. El resto salidas toman valor ‘0’.
• La expresión de conmutación que describe cada una de las salidas es:

Yi  Enable  mi ( X n1 ,..., X 0 )
6
DECODIFICADORES
• Ejemplo: implementación de un decodificador de 2 a 4 con puertas

lógicas.
Y0  E  X 1  X 0
Y1  E  X 1  X 0
Y2  E  X 1  X 0
Y3  E  X 1  X 0 7
DECODIFICADORES
• Ejemplo (continuación): descripción VHDL.
library ieee;
use ieee.std_logic_1164.all;
entity deco2a4 is
port(enable: in std_logic;
x: in std_logic_vector(1 downto 0);
y: out std_logic_vector(3 downto 0));
end deco2a4;
architecture puertas of deco2a4 is

signal not_x0, not_x1: std_logic;
begin
inv_1: entity work.not1 port map(x(0), not_x0);
inv_2: entity work.not1 port map(x(1), not_x1);
and_1: entity work.and3 port map(enable, not_x0, not_x1, y(0));
and_2: entity work.and3 port map(enable, x(0), not_x1, y(1));
and_3: entity work.and3 port map(enable, not_x0, x(1), y(2));
and_4: entity work.and3 port map(enable, x(0), x(1), y(3));
end puertas;
8
deco2a4.vhd
DECODIFICADORES
• Ejemplo (continuación): test-bench.
library ieee;
entity test_deco2a4 is
end test_deco2a4;
architecture test of test_deco2a4 is

signal enable: std_logic;
signal x: std_logic_vector(1 downto 0) := "00";
signal y: std_logic_vector(3 downto 0);
begin
inst_1: entity work.deco2a4(puertas) port map(enable, x, y);
enable <= '0', '1' after 400 ns;
x(0) <= not x(0) after 50 ns;
end test;
test_deco2a4.vhd
9
DECODIFICADORES
• Ejemplo (continuación): resultado de la simulación.
10
SÍNTESIS DE FC CON DECODIFICADORES
• Un decodificador de n a 2n materializa todos los minterms de una función

de n variables:
Yi  Enable  mi ( X n1 ,..., X 0 )
• Por tanto se puede materializar cualquier FC de n variables expresada

como suma de minterms con un decodificador de n a 2n y una puerta Or
con tantas entradas como sumandos tenga la expresión de la FC.
11
SÍNTESIS DE FC CON DECODIFICADORES
• Ejemplo: sintetizar las funciones f1, f2 y f3 con un decodificador de 3 a 8.

f1 (a, b, c)   m(1,3,5)
f 2 (a, b, c)   m(0,2) 1
f 3 (a, b, c)   m(2,4,6)
Enable
Y0
f1
c X0 Y1
b X1 Y2
IMPORTANTE: a X2 Y3
Y4
Cuidado con el orden de Y5 f2
Y6
significancia de las entradas Y7
f3
12
CODIFICADORES SIN PRIORIDAD
• Un codificador (codificador de 2n a n) es un módulo con 2n entradas y n

salidas de datos, una entrada de activación (Enable) y una salida de
actividad para diseño modular.
• El funcionamiento del codificador sin prioridad

es el siguiente:
 Si Enable está desactivada todas las salidas Yi
toman el valor ‘0’.
 Si Enable está activada las salidas Yi codificarán
el número I, siendo I el índice de la entrada X
que esté activa (solo una entrada X puede valer
‘1’ en un instante determinado)
 La salida Activo vale ‘1’ si alguna de las entradas
Xi vale ‘1’ y Enable está activa. En caso contrario
Activo vale ‘0’.
13

• Las expresiones de conmutación de las salidas Yi y Activo son:
Yi  E  X j /Xj se incluye en la suma si el bit i-ésimo de la

representación binaria de j es 1
A  E  ( X2n1 + X2n2 + ... + X1 + X0 )
• Ejemplo: codificador de 8 a 3:
E Xactiva Y2 Y1 Y0 A
0 - 0 0 0 0
1 X0 0 0 0 1 y 0  E  (x 1 + x 3 + x 5 + x 7 )
1 X1 0 0 1 1 y 1  E  (x 2 + x 3 + x 6 + x 7 )
1 X2 0 1 0 1
y 2  E  (x 4 + x 5 + x 6 + x 7 )
1 X3 0 1 1 1
1 X4 1 0 0 1 A  E  (x 0 + x 1 + x 2 + x 3 + x 4 + x 5 + x 6 + x 7 )
1 X5 1 0 1 1
1 X6 1 1 0 1
1 X7 1 1 1 1 14
• Ejemplo: codificador de 8 a 3 (continuación):
15
• Ejemplo (continuación): descripción estructural en VHDL
library ieee;
entity cod8a3 is
port(enable: in std_logic;
y: out std_logic_vector(3 downto 0);
activo: out std_logic);
end cod8a3;
architecture puertas of cod8a3 is

signal z: std_logic;
signal s: std_logic_vector(2 downto 0);
begin
or_1: entity work.or4 port map(x(1),x(3),x(5),x(7),s(0));
cod8a3.vhd
and_1: entity work.and2 port map(enable,s(0),y(0));

or_4: entity work.or8 port map(x(0),x(1),x(2),x(3),x(4),x(5),x(6),x(7),z);
and_4: entity work.and2 port map(enable,z,activo);
end puertas;
16
• Ejemplo (continuación): otra posible descripción del circuito.
architecture concurrente of cod8a3 is

begin
y(0) <= enable and (x(1) or x(3) or x(5) or x(7));
activo <= enable and (x(0) or x(1) or x(2) or x(3) or x(4) or
x(5) or x(6) or x(7));
end concurrente;
cod8a3.vhd
17
• Ejemplo (continuación): test-bench.
library ieee;
entity test_cod8a3 is
end test_cod8a3;
architecture test of test_cod8a3 is

signal enable,activo: std_logic;
signal y: std_logic_vector(2 downto 0);
begin
inst_1: entity work.cod8a3(puertas) port map(enable, x, y, activo);
x <= "10000000" after 50 ns, "00000000" after 100 ns,
"00000001" after 150 ns, "00010000" after 200 ns,
"00000010" after 250 ns, "00100000" after 300 ns;
end test;
test_cod8a3.vhd
18
19
CODIFICADORES CON PRIORIDAD
• Los codificadores con prioridad reciben varias entradas de las cuales

pueden estar activas más de una a la vez. La salida codifica el índice de la
entrada activa más alta (o más baja si es un codificador de bit menos
significativo).
• Materializan una red de resolución de prioridades que decide cuál de las
entradas tiene más prioridad.
• Funcionamiento:
 Si Enable está inactiva: Yi, Activo y Enable out
valen todas ‘0’.
 Si Enable está activa:
 Si hay algún Xi activo, la salida Y codifica el
índice del mayor Xi que esté activo. La
salida Activo vale ‘1’ y la salida Enable out
vale ‘0’.
 Si no hay ningún Xi activo, la salida Activo
vale ‘0’ y la salida Enable out vale ‘1’. 20
• Ejemplo: codificador con prioridad en función de un codificador sin

prioridad.
Código
21
Varias señales activas Una señal activa
• El módulo de resolución de prioridades de bit más significativo se

materializa con las siguientes expresiones de conmutación:
Z 2n 1  X 2n 1
Z 2n  2  X 2n  2  X 2n 1
Z 2n 3  X 2n 3  X 2 n  2  X 2n 1
.
.
Z i  X i  X i +1  ...  X 2n  2  X 2n 1
22
• Ejemplo: sintetizar un codificador con prioridad de 4 a 2.

• Módulo de resolución de prioridades:
Z3  X 3
Z2  X 2  X 3
Z1  X 1  X 2  X 3
Z0  X 0  X1  X 2  X 3
• Codificador 4 a 2:
Y0  E  ( X 1 + X 3 )
Y1  E  ( X 2 + X 3 )
A  E  ( X 0 + X1 + X 2 + X 3 )
23
24
ÍNDICE
• Bibliografía
• Introducción
• Desplazadores
• Comparadores
 Sumador
 Restador
25
MULTIPLEXORES
• Un multiplexor (o multiplexor de 2n a 1) es un módulo combinacional con

2n entradas de datos, ‘n’ entradas de selección y una entrada de
activación (Enable). Tiene una única salida. Entradas
de datos
• El multiplexor conecta una de las 2n entradas
a la salida en función de una palabra de
control S:
 Si las entradas de selección Si codifican el
número I, la salida Y tomará el valor de Xi
siempre que Enable esté activo.
 Si Enable está inactivo la salida Y vale ‘0’.
• Puesto en forma de expresión de conmutación: Entradas de

selección
2n 1
y  E  ( x 0  m 0 (s n-1,..., s 0 ) + x 1  m 1(s n-1,..., s 0 ) + ...)  E  x i
 m i (s n-1,..., s 0 )
i 0 26
MULTIPLEXORES
• Ejemplo: implementar un multiplexor de 4 entradas.
yE  ( x0  m0 ( s1 , s0 ) + x1  m1 ( s1 , s0 ) + x2  m2 ( s1 , s0 ) + x3  m3 ( s1 , s0 )) 
E  ( x0  s1  s0 + x1  s1  s0 + x2  s1  s0 + x3  s1  s0 )
Multiplexor 4 a 1
27
MULTIPLEXORES
• Ejemplo (continuación): descripción estructural en VHDL

library ieee;
entity mux4a1 is
port (enable: in std_logic;
sel: in std_logic_vector(1 downto 0);
y: out std_logic);
end mux4a1;
architecture puertas of mux4a1 is

signal not_sel1, not_sel0: std_logic;
signal s0, s1, s2, s3: std_logic;
begin
not1: entity work.not1 port map(sel(0), not_sel0);
not2: entity work.not1 port map(sel(1), not_sel1);
and1: entity work.and4 port map(enable, not_sel0, not_sel1, x(0), s0);
mux4a1.vhd
and2: entity work.and4 port map(enable, sel(0), not_sel1, x(1), s1);

and3: entity work.and4 port map(enable, not_sel0, sel(1), x(2), s2);
and4: entity work.and4 port map(enable, sel(0), sel(1), x(3), s3);
or1: entity work.or4 port map(s0, s1, s2, s3, y);
28
end puertas;
MULTIPLEXORES
• Ejemplo (continuación): otra posible descripción en VHDL
architecture concurrente of mux4a1 is

begin
y <= enable and (
( (not sel(0)) and (not sel(1)) and x(0) ) or
( sel(0) and (not sel(1)) and x(1) ) or
( (not sel(0)) and sel(1) and x(2) ) or
( sel(0) and sel(1) and x(3) )
);
end concurrente;
mux4a1.vhd
29
MULTIPLEXORES
• Ejemplo (continuación): y otra posible descripción más en VHDL utilizando

un process.
architecture funcional of mux4a1 is

begin
process(x, sel)
begin
if enable = '0' then
y <= '0';
else
case sel is
when "00" => y <= x(0);
when "01" => y <= x(1);
when "10" => y <= x(2);
when others => y <= x(3);
end case;
end if;
end process;
end funcional;
mux4a1.vhd
30
MULTIPLEXORES
• Ejemplo (continuación): test-bench

library ieee;
entity test_mux4a1 is
end test_mux4a1;
architecture test of test_mux4a1 is

signal enable, y: std_logic;
signal sel: std_logic_vector(1 downto 0);
begin
inst1: entity work.mux4a1(puertas) port map(enable, x, sel, y);
sel <= "00", "01" after 100 ns, "10" after 200 ns, "11" after 300 ns;
end test;
test_mux4a1.vhd 31
MULTIPLEXORES
• Ejemplo (continuación): resultado de la simulación
32
SÍNTESIS DE FC CON MULTIPLEXORES
• Un único multiplexor de 2n a 1 permite materializar cualquier función de

conmutación de ‘n’ variables.
• La EC de una FC como suma de productos consiste en la suma de los
minterms mi para los que la FC, f(i) toma valor cierto, es decir:
2n 1
f(a n-1,..., a 0 )   f(i)  m (a i n-1
,..., a 0 )
i 0
• La EC de un multiplexor es:
2 n 1
y E x i
 m i (s n-1,..., s 0 )
i 0
• Por tanto, podemos hacer que y = f(an-1,…,a0) si hacemos:

 Que Enable = ‘1’.
 Que las entradas Si sean las variables de la función.
 Que cada entrada Xi del multiplexor sea igual a f(i) (el valor de la fila i de la
tabla de verdad).
33
• Ejemplo: sintetizar f(x,y,z) mediante un único multiplexor.

f(x, y, z)   m(0,3,4,7)
34
• La materialización de FCs mediante multiplexores no es directa cuando no

se dispone de un multiplexor con tantas entradas de control como
variables binarias tiene la FC.
• Dado un multiplexor de 2n a 1 (es

decir, con ‘n’ entradas de selección)
y una función con ‘n+k’ variables
binarias, se seleccionan ‘n’ variables
como entrada de control y se usan
las ‘k’ restantes como variables de
las 2n funciones de entrada al
multiplexor.
2n 1
f(x n+k -1,..., x n , x n-1,..., x 0 )  f(z k -1,..., z 0 , s n-1,..., s 0 )   E (z i ,..., z 0 )  m i (s n-1,..., s 0 )
k -1
i 0 35
• Cada función de k entradas puede realizarse con multiplexores de k

entradas de control (árbol de multiplexores), con decodificadores, con
puertas lógicas, etc.
• Ejemplo: implementar f mediante un multiplexor de 4 a 1 y puertas
lógicas. (Se ha escogido c y d como entradas de selección del multiplexor)
f (a, b, c, d )   m(1,3,4,6,7,9,10,11,14)
f (a, b, c, d )  a  b  c  d + a  b  c  d + a  b  c  d + a  b  c  d + a  b  c  d + a  b  c  d + a  b  c  d + a  b  c  d + a  b  c  d 
 ( a  b)  c  d + ( a  b + a  b)  c  d + ( a  b + a  b + a  b)  c  d + ( a  b + a  b + a  b)  c  d
E0 E1 E2 E3
E0  a  b
E1  a  b + a  b  b
Simplificación algebraica
E2  a  b + a  b + a  b  a + b
E3  a  b + a  b + a  b  a + b 36
• También se puede resolver de forma gráfica con mapas de Karnaugh.

• Se trata de dividir el mapa en regiones en las que las variables que se
utilizarán como entradas de selección del multiplexor tienen valores
constantes.
• Ejemplo: para la misma función que la transparencia anterior:
E0 E1 E3 E2 Se divide el mapa en las regiones en las que ‘c’ y ‘d’

c d valen ‘00’ => E0; ‘01’ => E1, etc.
ab 00 01 11 10
0 1 3 2
Cada región se trata como un mapa de Karnaugh de
00 1 1 2 variables (‘a’ y ‘b’)
4 5 7 6
01 1 1 1 E0  a  b
E1  b
12 13 15 14
11 1
8 9 11 10 E2  a + b
10 1 1 1
E3  a + b
37
• Si se escogen otras variables de selección (‘a’ y ‘d’ en este ejemplo) el

circuito resultante es diferente.
E0  b
E1  b + c
E0 E1 E0
cd E2  c
E3  b
ab 00 01 11 10
0 1 3 2
00 1 1
4 5 7 6
01 1 1 1
12 13 15 14
11 1
8 9 11 10
10 1 1 1
E2 E3 E2
38
• Ejemplo: descripción en VHDL de los dos circuitos anteriores.

library ieee;
entity sintesis_mux is
port(a,b,c,d: in std_logic;
z: out std_logic);
end sintesis_mux;
architecture arq_1 of sintesis_mux is

signal E: std_logic_vector(3 downto 0);
begin
sintesis_mux.vhd
E(0) <= (not a) and b;

E(1) <= (not b);
E(2) <= a or b;
E(3) <= (not a) or (not b);
sel(0) <= d;
sel(1) <= c;
mux: entity work.mux4a1(funcional) port map('1', E, sel, z);
end arq_1;
39
• Ejemplo (continuación): descripción en VHDL de los dos circuitos

anteriores.
architecture arq_2 of sintesis_mux is
signal E: std_logic_vector(3 downto 0);
begin
E(0) <= b;
E(1) <= (not b) or c;
E(2) <= c;
E(3) <= (not b);
sel(0) <= d;
sel(1) <= a;
mux: entity work.mux4a1(concurrente) port map('1', E, sel, z);
end arq_2;
sintesis_mux.vhd
40
• Ejemplo (continuación): test-bench de las dos arquitecturas

library ieee;
entity test_sintesis_mux is
end test_sintesis_mux;
architecture test of test_sintesis_mux is

signal a: std_logic := '0';
signal b: std_logic := '0';
signal c: std_logic := '0';
test_sintesis_mux.vhd
signal d: std_logic := '0';

signal z1, z2: std_logic;
begin
inst_1: entity work.sintesis_mux(arq_1) port map(a,b,c,d,z1);
inst_2: entity work.sintesis_mux(arq_2) port map(a,b,c,d,z2);
d <= not d after 2 ns;
c <= not c after 4 ns;
b <= not b after 8 ns;
a <= not a after 16 ns;
end test;
41
• Ejemplo (continuación): resultado de la simulación
42
DEMULTIPLEXORES
• Un demultiplexor (o demultiplexor de 1 a 2n) es un módulo combinacional

con 1 entrada y 2n salidas, además de una entrada de activación y ‘n’
entradas de control.
• La salida de índice ‘i’ vale lo mismo que

la entrada X, siempre que Enable esté Entrada
activado y las entradas de selección de datos
estén codificando el número decimal ‘i’.
El resto de salidas valen ‘0’.
• Puesto en forma de expresión de

conmutación:
yi  E  x  m i (s n-1,..., s 0 )
Entradas de
selección
43
DEMULTIPLEXORES
• Ejemplo: implementar un demultiplexor de 1 a 4.

Demux 4a1
yi  E  x  m i (s n-1,..., s 0 )
y0  Ex  s 1 s 0
y1  Ex  s 1 s 0
y2  Ex  s 1 s 0
y3  Ex  s 1 s 0
44
DEMULTIPLEXORES
• Ejemplo (continuación): descripción concurrente en VHDL.

library ieee;
use ieee.std_logic_unsigned.all;
entity demux1a4 is
port(enable, x: in std_logic;
sel: in std_logic_vector(1 downto 0);
y: out std_logic_vector(3 downto 0));
end demux1a4;
architecture concurrente of demux1a4 is

begin
y(0) <= enable and x and (not sel(0)) and (not sel(1));
y(1) <= enable and x and sel(0) and (not sel(1));
y(2) <= enable and x and (not sel(0)) and sel(1);
y(3) <= enable and x and sel(0) and sel(1);
end concurrente;
demux1a4.vhd
45
DEMULTIPLEXORES
• Ejemplo (continuación): una posible descripción funcional del mismo

demultiplexor.
architecture funcional_1 of demux1a4 is
begin
process(x, sel)
begin
y <= "0000";
case sel is
when "00" => y(0) <= x;
when "01" => y(1) <= x;
when "10" => y(2) <= x;
when others => y(3) <= x;
end case;
end if;
end process;
end funcional_1;
demux1a4.vhd
46
DEMULTIPLEXORES
• Ejemplo (continuación): otra posible descripción funcional del mismo

demultiplexor.
architecture funcional_2 of demux1a4 is
begin
process(x, sel)
begin
demux1a4.vhd
y <= "0000";
y(conv_integer(sel)) <= x;
end if;
end process;
end funcional_2;
• La función conv_integer(parametro) convierte un vector de bits a su valor

decimal. Esta función se encuentra en la librería ieee.std_logic_unsigned
47
DEMULTIPLEXORES
• Ejemplo (continuación): test-bench para probar las 3 arquitecturas

simultáneamente.
library ieee;
entity test_demux1a4 is
end test_demux1a4;
architecture test of test_demux1a4 is

signal enable: std_logic;
signal x: std_logic := '0';
signal y1, y2, y3: std_logic_vector(3 downto 0);
test_demux1a4.vhd
begin
inst1: entity work.demux1a4(concurrente) port map(enable, x, sel, y1);
inst2: entity work.demux1a4(funcional_1) port map(enable, x, sel, y2);
inst3: entity work.demux1a4(funcional_2) port map(enable, x, sel, y3);

x <= not x after 5 ns;
sel <= "00", "01" after 50 ns, "10" after 100 ns, "11" after 150 ns;
end test; 48
DEMULTIPLEXORES
49
ÍNDICE
• Bibliografía
• Introducción
• Desplazadores
• Comparadores
 Sumador
 Restador
50
DESPLAZADORES
• Un desplazador (shifter) es un módulo combinacional con n+2 entradas y n

salidas, además de una señal de activación y varias señales de control.
• El desplazador mueve a derecha o izquierda en desplazamientos abiertos
o cerrados (rotaciones) en función de las señales de control.
• Aunque se pueden materializar
.
.
.
.
.
.
.
mediante expresiones de XL Xn-1 Xn-2 X1 X0 XR
conmutación a través de puertas Enable
lógicas la construcción habitual
DESPLAZADOR
suele consistir en un conjunto de
multiplexores. OP
Yn-1 Yn-2 Y1 Y0
.
.
.
.
.
.
.
51
DESPLAZADORES
• Ejemplo: desplazador de 4 bits que realiza las siguientes operaciones:
OP = “00” => Desplazamiento a derecha OP = “01” => Desplazamiento a izquierda
XL X3 X2 X1 X0 XR XL X3 X2 X1 X0 XR
Enable Enable
OP OP
Y3 Y2 Y1 Y0 Y3 Y2 Y1 Y0
OP = “10” => Rotación a derecha OP = “11” => Rotación a izquierda
XL X3 X2 X1 X0 XR
XL X3 X2 X1 X0 XR
Enable
Enable
OP
OP
Y3 Y2 Y1 Y0 Y3 Y2 Y1 Y0
52
DESPLAZADORES
• Ejemplo (continuación): se puede implementar utilizando multiplexores:
X2 X0 X2 XL X1 X3 X1 X3 X0 X2 X0 X2 X3 X1 XR X1
Enable
OP0
OP1
E 3 2 1 0 E 3 2 1 0 E 3 2 1 0 E 3 2 1 0
0 0 0 0
1 1 1 1
Y3 Y2 Y1 Y0
53
ÍNDICE
• Bibliografía
• Introducción
• Desplazadores
• Comparadores
 Sumador
 Restador
54
COMPARADORES
• Un comparador es un módulo combinacional con 2n entradas de datos (a

y b de n bits cada una), 3 entradas para encadenamiento de comparación
(de entradas menos a más significativas ) y 3 salidas de comparación.
• El comparador determina la
relación de magnitud de dos
vectores binarios indicando si
el primero es mayor (agtb),
menor (altb) o igual (aeqb)
que el segundo.
agtbout = (a>b) + (a=b)·agtbin

aeqbout = (a=b)·aeqbin
altbout = (a<b) + (a=b)·altbin
55
COMPARADORES
• Ejemplo: comparador de un bit encadenable.
• Partimos primero de un comparador de un bit NO encadenable:
a b (a>b) (a=b) (a<b)

0 0 0 1 0
0 1 0 0 1
1 0 1 0 0
1 1 0 1 0
(a>b)  a  b
(a=b)  a xnor b
(a<b)  a  b
56
COMPARADORES
• Ejemplo (continuación): a partir del comparador no encadenable

añadimos las entradas de comparación se calculan las ecuaciones de las
salidas teniendo en cuenta las entradas de comparación.
agtbout = (a>b) + (a=b)·agtbin
aeqbout = (a=b)·aeqbin
Comparador de 1 bit
altbout = (a<b) + (a=b)·altbin
Comparador de 1
bit encadenable
57
COMPARADORES
• Encadenando varios comparadores se pueden construir otros de mayor

tamaño.
• Ejemplo: comparador de 4 bits a partir del comparador encadenable de 1
bit.
58
ÍNDICE
• Bibliografía
• Introducción
• Desplazadores
• Comparadores
 Sumador
 Restador
59
DISPOSITIVOS LÓGICOS PROGRAMABLES
• Bajo la denominación de dispositivos lógicos programables se encuadran

un conjunto de circuitos integrados formados por cierto número de
puertas lógicas y/o módulos básicos y/o biestables cuyas conexiones
pueden ser personalizadas o programadas, bien sea por el fabricante o
por el usuario.
• La gran ventaja de estos dispositivos reside en que los fabricantes pueden
realizar grandes tiradas de estos CI lo que abarata sus costes de
producción y los usuarios posteriormente pueden personalizar sus diseños
en sus propios laboratorios sin grandes inversiones.
• Dentro de ese conjunto de dispositivos haremos mención de las memorias
ROM, las PLA y las PAL.
• Las diferencias fundamentales entre sendos tipos de dispositivos estriba
en los grados de libertad que disponen cada uno de ellos en cuanto a su
capacidad y flexibilidad de programación.
60
DISPOSITIVOS LÓGICOS PROGRAMABLES: ROM
• Una memoria ROM (Read Only Memory - memoria de solo lectura) es un

módulo combinacional con ‘n’ entradas de direcciones y ‘k’ salidas de
datos, además de una o varias señales de activación.
• Existen distintos tipos, según se puedan o

no programar, borrar, como se realiza el
borrado, etc:
 ROM Read-Only Memory
 PROM Programmable ROM
 EPROM Erasable and Programmable ROM
 EEPROM Electrically erasable PROM
61
• Una ROM se compone internamente de dos

grupos de puertas: un grupo de puertas And
(en realidad incluye también un conjunto de
inversores) y un grupo de puertas Or.
• El grupo de puertas And están programadas
de antemano y conectadas de forma
inalterable, mientras que el grupo de puertas
Or son programables por el usuario.
• En general, una ROM con ‘n’ entradas de
direcciones y ‘k’ salidas de datos consta de un
grupo de puertas And (‘n’ inversores y 2n
puertas And de n entradas) y un grupo de
puertas Or (‘k’ puertas Or de 2n entradas,
tantas como puertas And).
62
• Las puertas And están conectadas de tal forma que cada una de ellas
implementa uno de los 2n minterms de las ‘n’ variables de entrada (es
como un decodificador de n a 2n .
• El grupo de puertas Or es programable, de tal forma que cada una de las
puertas Or puede implementar una suma de algunos de los 2n minterms.
• Cualquier salida de datos de la ROM implementa la siguiente expresión de
conmutación:
 fj(i)=1 si existe conexión (fila i, columna j) en el grupo Or

 fj(i)=0 si no existe dicha conexión
63
• Ejemplo: implementar las siguientes funciones de conmutación con una

ROM:
f 2 ( x, y, z )   m(0,1,6)
f1 ( x, y, z )   m(2,3,5)
f 0 ( x, y, z )   m(4,6,7)
• Como son funciones de 3

variables se necesita una ROM
con 3 entradas de direcciones.
• Como hay que implementar 3
funciones se necesita una ROM
con 3 salidas de datos.
64
• Una ROM se puede ver como una tabla que almacena datos con la
siguiente estructura interna abstracta, donde cada dato ocupa una
posición de la tabla denominada dirección.
ROM
Read Only Memory
dirección 0 Palabra 0
dirección n-1 Palabra n-1
• Como la única parte programable es la Or se suele representar mediante

la matriz de conexiones Or con 1 y 0 indicando conexión o no conexión
respectivamente, de nuevo materializando directamente la tabla de
65
verdad.
• Ejemplo: las mismas tres funciones que en el ejemplo anterior:

f 2 ( x, y, z )   m(0,1,6)
f1 ( x, y, z )   m(2,3,5)
f 0 ( x, y, z )   m(4,6,7)
66
DISPOSITIVOS LÓGICOS PROGRAMABLES: PLA
• Una memoria ROM materializa FCs

directamente como suma de minterms ya
que el grupo de puertas And está prefijado.
• Cuando una FC solo utiliza unos pocos
minterms o admite una fuerte simplificación
utilizar una ROM puede ser un despilfarro.
• Para este tipo de situaciones se utilizan
dispositivos PLA (Programmable Logic Array)
con conexiones programables tanto en el
grupo de puertas And como en el grupo de
puertas Or.
67
DISPOSITIVOS LÓGICOS PROGRAMABLES: PAL
• Las PAL (Programmable Array Logic) son un

caso particular de PLA con conexiones Or
preprogramadas.
• Una PAL con ‘n’ entradas y ‘k’ salidas
presenta un grupo de ‘m’ puertas And de 2n
entradas y un grupo de ‘k’ puertas Or de p
entradas, usualmente p=m/k.
• Con estos parámetros una PAL puede
materializar ‘k’ funciones de conmutación de
‘n’ variables que se expresen como suma de
productos de un máximo de ‘p’ sumandos.
• Ejemplo: representar una PAL con n=3, m=8
y k=2. ¿Qué FCs se pueden materializar?
• Se pueden implementar 2 FCs de 3 entradas con un máximo de

p=m/k=4 términos producto cada una. 68
DISPOSITIVOS LÓGICOS PROGRAMABLES: PAL
• Ejemplo: materializar las siguientes funciones de conmutación con una

PAL con las características anteriores.
69
ÍNDICE
• Bibliografía
• Introducción
• Desplazadores
• Comparadores
 Sumador
 Restador
70
SUMADORES
• El semisumador (half adder) es un circuito que suma dos bits de entrada A

y B, y devuelve un bit de resultado S y un bit de acarreo cout.
• Se suele representar con este símbolo:
a b
𝑠 =𝑎⊕𝑏
+ 𝑐𝑜𝑢𝑡 = 𝑎 · 𝑏
cout
s
71
SUMADORES
• El sumador completo (full adder) es un circuito que suma dos bits de

entrada A y B más un acarreo de entrada Cin y devuelve un bit de resultado
S y un bit de acarreo Cout.
• Se suele representar con este símbolo:

a b
𝑠 = 𝑎 ⊕ 𝑏 ⊕ 𝑐𝑖𝑛
+ 𝑐𝑜𝑢𝑡 = 𝑎 · 𝑏 + 𝑎 · 𝑐𝑖𝑛 + 𝑏 · 𝑐𝑖𝑛

cout cin
s 72
SUMADORES
• Ejemplo: sumador completo de 1 bit en VHDL

library ieee;
entity add1 is
port(a,b,cin: in std_logic;
s, cout: out std_logic);
end add1;
architecture concurrente of add1 is

begin
cout <= (a and b) or (a and cin) or (b and cin);
s <= a xor b xor cin;
end concurrente;
add1.vhd
73
SUMADORES
A B
• Sumador de ‘n’ bits con propagación de acarreo: n n
 Se construye conectando en cascada varios cout cin

sumadores completos de 1 bit. +
an-1 bn-1 a1 b1 a0 b0
a b a b a b
cout Cout
+ Cin
... Cout
+ Cin Cout
+ Cin
cin
s s s
sn-1 s1 s0 74
SUMADORES
• Ejemplo: sumador de 4 bits en VHDL.

library ieee;
entity add4 is
port(a,b: in std_logic_vector(3 downto 0);
cin: in std_logic;
s: out std_logic_vector(3 downto 0);
cout: out std_logic);
end add4;
architecture estructural of add4 is

signal c: std_logic_vector(4 downto 0);
begin
c(0) <= cin;
sum0: entity work.add1 port map(a(0), b(0), c(0), s(0), c(1));
add4.vhd

cout <= c(4);
end estructural;
75
SUMADORES
• Ejemplo (continuación): cuando la estructura interna de un circuito es

repetitiva, como en el sumador de 4 bits, se puede utilizar una
construcción del lenguaje que permite crear varias instancias iguales (for
generate).
architecture estructural_2 of add4 is

signal c: std_logic_vector(4 downto 0);
begin
c(0) <= cin;
sum4: for i in 0 to 3 generate
sum: entity work.add1 port map(a(i), b(i), c(i), s(i), c(i+1));
end generate;
cout <= c(4);
end estructural_2;
add4.vhd
76
SUMADORES
• El lenguaje VHDL permite definir una entidad que tenga parámetros. Estos
parámetros reciben el nombre de generics, y sirven por ejemplo para
describir circuitos que no tienen un tamaño fijo si no que se puede fijar el
tamaño a la hora de crear una instancia de ese circuito.
• Vamos a ver un ejemplo de uso de generics con un sumador de ‘n’ bits:
library ieee;
entity addn is
generic(n: integer);
port(a,b: in std_logic_vector(n-1 downto 0);
cin: in std_logic;
s: out std_logic_vector(n-1 downto 0);
cout: out std_logic);
end addn;
addn.vhd
77
SUMADORES
• Ejemplo (continuación):
architecture estructural of addn is

signal c: std_logic_vector(n downto 0);
begin
c(0) <= cin;
sum4: for i in 0 to n-1 generate
sum: entity work.add1 port map(a(i), b(i), c(i), s(i), c(i+1));
end generate;
cout <= c(n);
end estructural;
addn.vhd
78
SUMADORES
• Ejemplo: es a la hora de utilizar el sumador de ‘n’ bits en otro circuito, o
en un test-bench, cuando se le dará valor al parámetro ‘n’.
library ieee;
test_addn.vhd
use ieee.std_logic_arith.all;
entity test_addn is
end test_addn;
architecture test of test_addn is

signal a,b,s: std_logic_vector(7 downto 0);
signal cin, cout: std_logic;
begin
cin <= '0', '1' after 100 ns;
a <= conv_std_logic_vector(123,8), conv_std_logic_vector(63,8) after 50 ns;
b <= conv_std_logic_vector(31,8);
inst_1: entity work.addn generic map(8) port map(a,b,cin,s,cout);
end test;
• La función conv_std_logic_vector(valor, n) convierte el número ‘valor’ a un

std_logic_vector de ‘n’ bits. Esta función se encuentra en la librería
ieee.std_logic_arith
79
SUMADORES
80
RESTADORES
A-B=A+C2(B)=A+C1(B)+1
• Recordatorio: para restar dos números en binario se hace la suma del

minuendo con el complemento a 2 del sustraendo. El complemento a 2 es
el complemento a 1 más ‘1’. En la resta binaria hay que invertir el acarreo
final.
an-1 bn-1 a1 b1 a0 b0
a b a b a b
cout
+ cin
... cout
+ cin cout
+ cin
'1'
cout
s s s
sn-1 s1 s0
81
SUMADORES RESTADORES
• Se pueden combinar el sumador y el restador en un único circuito que

realice la operación de suma o de resta en función de una señal de
control. Recordar que: X  0  X
X 1  X
an-1 bn-1 an-2 bn-2 a1 b1 a0 b0
Op
a b a b a b a b
cout
+ cin cout
+ cin
... cout
+ cin cout
+ cin
s s s s
sn-1 sn-1 s1 s0
82
cn-1
ÍNDICE
• Bibliografía
• Introducción
• Desplazadores
• Comparadores
 Sumador
 Restador
83
UNIDAD ARITMÉTICO LÓGICA
• Una unidad aritmético lógica (ALU) es un circuito combinacional que

permite hacer distintas operaciones aritméticas (sumas, restas,
desplazamientos) y lógicas (AND, OR, NOT, XOR, etc) entre dos operandos,
en función de unas señales de control.
• Suelen estar implementadas con sumadores-restadores, multiplexores y
lógica adicional.
• Ejemplo de diseño: ALU con dos entradas de datos de 4 bits, que realiza
las siguientes operaciones en función de una entrada de control de 2 bits:
OP1 OP0 OPERACIÓN

0 0 X + Y
0 1 X - Y
1 0 X AND Y
1 1 X OR Y
84

LE y AE proporcionan a las entradas LC se encarga de
A y B de los sumadores los datos proporcionar el acarreo
• Ejemplo (continuación):
necesarios para que se realice la de entrada a la cadena
operación deseada de sumadores
X3 Y3 X2 Y2 X1 Y1 X0 Y0
OP0
OP1
LE AE LE AE LE AE LE AE
LC
a b a b a b a b
cout + cin cout + cin cout + cin cout + cin
s s s s
Z3 Z2 Z1 Z0
85

Si OP1 y OP0 = “10”
Si OP1 y Yi,
OP0 Si OP1 y OP0 = “11”
SiAiOP1
= XiyAND
OP0 = Bi == “01”
“00” 0, LC = 0, y por tanto
Ai = los Ai = Xi
Xi, sumadores OR Yi,
Bi = Yi‘, LC =harán Bi
1, y por = 0,tanto
LC = los
0, y por tanto los
• Ejemplo
Ai=(continuación):
Xi, Bi = Yi, sumadores
LC = 0, y porharán la operación
tantolalos operación
(X AND
(X OR Y) +
sumadores harán Y) + la
0 + operación
0, es decir XX+ ‘Y
AND + 1,
Y.
sumadores harán la operación X + Y + 0.
es decir 0X +– 0, Y.. es decir X OR Y.
X3 Y3 X2 Y2 X1 Y1 X0 Y0
OP0
OP1
LE AE LE AE LE AE LE AE
LC
a b a b a b a b
cout + cin cout + cin cout + cin cout + cin
s s s s
Z3 Z2 Z1 Z0
86
• Con la estructura propuesta, los bloques LE y AE se encargan de

proporcionar a las entradas A y B de los sumadores los datos necesarios
para que se realice la operación deseada. El bloque LC se encarga de
proporcionar el acarreo de entrada a la cadena de sumadores.
 Si OP1 y OP0 = “00”
• Ai= Xi, Bi = Yi, LC = 0, y por tanto los sumadores harán la operación X + Y + 0.
 Si OP1 y OP0 = “01”
• Ai = Xi, Bi = ‘Yi, LC = 1, y por tanto los sumadores harán la operación X + ‘Y + 1, es
decir X – Y.
 Si OP1 y OP0 = “10”
• Ai = Xi AND Yi, Bi = 0, LC = 0, y por tanto los sumadores harán la operación (X AND Y)
+ 0 + 0, es decir X AND Y.
 Si OP1 y OP0 = “11”
• Ai = Xi OR Yi, Bi = 0, LC = 0, y por tanto los sumadores harán la operación (X OR Y) + 0
+ 0, es decir X OR Y.
87
LE AE
xy
OP1 OP0
OP1 OP0 00 01 11 10 yi
00 01 11 10
00 0 0 1 1
00 0 1 0 0
01 0 0 1 1
01 1 0 0 0
11 0 1 1 1
10 0 0 1 0
bi  OP1  OP0  yi + OP1  OP0  yi
ai  OP1  OP0  yi + xi  yi + OP1  xi + OP0  xi
LC => vale ‘1’ cuando OP = “01” => LC OP1  OP0

88
UNIDAD ARITMÉTICO LÓGICA: EJEMPLO

• Ejemplo de diseño: ALU con dos entradas de datos de 4 bits, que realiza
las siguientes operaciones en función de una entrada de control de 2 bits:
X Y
4 4 OP1 OP0 OPERACIÓN

0 0 X + Y
OP Unidad aritmético-lógica
0 1 X - Y
2
1 0 X AND Y
4 1 1 X OR Y
Carry Z
• Vamos a estudiar otras dos alternativas para el diseño de esta ALU:

o Versión 2: diseño por separado de la parte lógica y de la parte
aritmética.
o Versión 3: diseño de una celda básica completa para datos de un bit y
su posterior replicación (red iterativa).
89
UNIDAD ARITMÉTICO LÓGICA: EJEMPLO VERSIÓN 2

• Fijándonos en la tabla de verdad, vemos que: OP1 OP0 OPERACIÓN
o Si OP1=0, se realizan operaciones aritméticas. 0 0 X + Y
 OP0=0 implica suma, OP0=1 implica resta. 0 1 X - Y
o Si OP1=1, se realizan operaciones lógicas. 1 0 X AND Y
1 1 X OR Y
 OP0=0 implica AND, OP0=1 implica OR
• Así, la ALU constará de dos módulos diferenciados: aritmético y lógico.

Y
4
X
4
4 4 4 4
Las salidas de ambos
OP0 Unidad aritmética Unidad lógica
módulos van a un conjunto
de 4 multiplexores de 2 a 1
controlado por OP1.
4 4
Carry
0 1
OP1
2:1x4
MUX
4
90
Z

• El módulo aritmético es un sumador / restador:
x3 y3 x2 y2 x1 y1 x0 y0
OP0
a b a b a b a b
cout
+ cin cout
+ cin cout
+ cin cout
+ cin
s s s s
z’3 z’2 z’1 z’0
Carry
91

• El módulo lógico se puede estructurar en varias unidades lógicas de bit, todas
ellas iguales: x y x y x y x y
3 3 2 2 1 1 0 0
Unidad lógica Unidad lógica Unidad lógica Unidad lógica

de bit de bit de bit de bit OP0
z’’3 z’’2 z’’1 z’’0

yi
• Cada unidad lógica de bit consta de dos xi
puertas lógicas y un multiplexor 2:1 :
0 1
OP0
MUX
2:1
92
z’’i
UNIDAD ARITMÉTICO LÓGICA: EJEMPLO COMPLETO 2

X Y Y
4
X
4
4 4
4 4 4 4
OP Unidad aritmético-lógica OP0 Unidad aritmética Unidad lógica

2
4 4 4
Carry
0 1
Carry Z OP1
2:1x4
MUX
x3 y3 x2 y2 x1 y1 x0 y0
OP0
4
Z
a b a b a b a b
+ + + +
yi
cout cin cout cin cout cin cout cin
s s s s xi
z’3 z’2 z’1 z’0
x3 y3 x2 y2 x1 y1 x0 y0
0 1
OP0
MUX
2:1
Carry
Unidad lógica Unidad lógica Unidad lógica Unidad lógica

de bit de bit de bit de bit OP0
z’’i
93
z’’3 z’’2 z’’1 z’’0

xi yi
• También se puede construir la unidad aritmético
lógica como una red iterativa de módulos
individuales iguales o similares, cada uno de los ci+1 ci
cuales trabaja con un bit de cada operando: ALU de bit
OP
2
x3 y3 x2 y2 x1 y1 x0 y0 zi
OP0
Carry ALU de bit
ALU de bit ALU de bit ALU de bit
especial
OP
2 2
2 2
2 2
z3 z2 z1 z0
• En el módulo i=0, el acarreo de entrada es la señal OP0.

• En los demás, el acarreo de entrada es el de salida del sumador anterior. 94
• Cada módulo de 1 bit combina las • El módulo de la pareja de bits de mayor

operaciones aritméticas y lógicas: peso es especial para poder generar el
acarreo de salida correctamente.
yi y3
xi x3
+ ci + c3
ci+1
Carry
3 2 1 0 3 2 1 0
OP0 OP0
MUX 4:1
MUX 4:1
0 0
1 OP1 1 OP1
zi
z3
95
UNIDAD ARITMÉTICO LÓGICA: EJEMPLO COMPLETO 3

X Y x3 y3 x2 y2 x1 y1 x0 y0
4 4
OP0
Carry ALU de bit
ALU de bit ALU de bit ALU de bit
especial
OP Unidad aritmético-lógica OP
2 2
2 2 2
2 2
4
z3 z2 z1 z0
Carry Z
y3 yi
x3 xi
+ c3 + ci
ci+1
Carry
3 2 1 0 3 2 1 0
OP0
MUX 4:1
OP0 0
MUX 4:1
0
1 OP1 1 OP1
zi
96
z3

2-6 Modulos Combinacionales Basicos

Cargado por

Copyright:

Formatos disponibles

2-6 Modulos Combinacionales Basicos

Cargado por

Información del documento

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

2-6 Modulos Combinacionales Basicos

Cargado por

Copyright:

Formatos disponibles

Titulación: Ingeniería Informática

Asignatura: Fundamentos de Computadores

Bloque 2: Sistemas combinacionales

Pablo Huerta Pellitero

• Román Hermida, Ana Mº del Corral, Enric Pastor, Fermín Sánchez

• Las materializaciones en forma de redes de puertas básicas no son

• Un decodificador (o decodificador de n a 2n) es un módulo combinacional

• La expresión de conmutación que describe cada una de las salidas es:

• Ejemplo: implementación de un decodificador de 2 a 4 con puertas

• Ejemplo (continuación): descripción VHDL.

architecture puertas of deco2a4 is

• Ejemplo (continuación): test-bench.

architecture test of test_deco2a4 is

• Ejemplo (continuación): resultado de la simulación.

SÍNTESIS DE FC CON DECODIFICADORES

• Un decodificador de n a 2n materializa todos los minterms de una función

• Por tanto se puede materializar cualquier FC de n variables expresada

SÍNTESIS DE FC CON DECODIFICADORES

• Ejemplo: sintetizar las funciones f1, f2 y f3 con un decodificador de 3 a 8.

CODIFICADORES SIN PRIORIDAD

• Un codificador (codificador de 2n a n) es un módulo con 2n entradas y n

• El funcionamiento del codificador sin prioridad

CODIFICADORES SIN PRIORIDAD

Yi  E  X j /Xj se incluye en la suma si el bit i-ésimo de la

A  E  ( X2n1 + X2n2 + ... + X1 + X0 )

CODIFICADORES SIN PRIORIDAD

• Ejemplo: codificador de 8 a 3 (continuación):

CODIFICADORES SIN PRIORIDAD

• Ejemplo (continuación): descripción estructural en VHDL

architecture puertas of cod8a3 is

and_1: entity work.and2 port map(enable,s(0),y(0));

CODIFICADORES SIN PRIORIDAD

• Ejemplo (continuación): otra posible descripción del circuito.

architecture concurrente of cod8a3 is

CODIFICADORES SIN PRIORIDAD

• Ejemplo (continuación): test-bench.

architecture test of test_cod8a3 is

CODIFICADORES SIN PRIORIDAD

• Ejemplo (continuación): resultado de la simulación.

CODIFICADORES CON PRIORIDAD

• Los codificadores con prioridad reciben varias entradas de las cuales

CODIFICADORES CON PRIORIDAD

• Ejemplo: codificador con prioridad en función de un codificador sin

CODIFICADORES CON PRIORIDAD

• El módulo de resolución de prioridades de bit más significativo se

CODIFICADORES CON PRIORIDAD

• Ejemplo: sintetizar un codificador con prioridad de 4 a 2.

CODIFICADORES CON PRIORIDAD

• Un multiplexor (o multiplexor de 2n a 1) es un módulo combinacional con

• Puesto en forma de expresión de conmutación: Entradas de

• Ejemplo: implementar un multiplexor de 4 entradas.

• Ejemplo (continuación): descripción estructural en VHDL

architecture puertas of mux4a1 is

and2: entity work.and4 port map(enable, sel(0), not_sel1, x(1), s1);

• Ejemplo (continuación): otra posible descripción en VHDL

architecture concurrente of mux4a1 is

• Ejemplo (continuación): y otra posible descripción más en VHDL utilizando

architecture funcional of mux4a1 is

• Ejemplo (continuación): test-bench

architecture test of test_mux4a1 is