Unidad III – Diseño de Circuitos Combinacionales – Parte 4

Clase #14 – Diseño con Demultiplexores

Lógica Digital
Prof. Ricardo Villegas
 Contenido

Diseño con Demultiplexores (DEMUXs)
• Definición, Casos de Estudio, Tipos de DEMUXs
• Expansión de DEMUXs
• Aplicaciones de los DEMUXs
• Implementación de funciones lógicas con DEMUX

Descripción de Comportamiento de Circuitos
con VHDL

Definición de Arquitecturas
 Diseño con Demultiplexores (DEMUXs)

Demultiplexor (DEMUX):
Dispositivo que distribuye una única entrada sobre un conjunto de múltiples salidas.
- Encamina la entrada hacia alguna salida.

y0 • Tiene m salidas y n entradas de control o selección → m = 2n

Sn-1..S0 y1 • Las entradas de control determinan la salida activa.
y2 m
E
…

ym-1 DEMUX 1:m → 1 entrada, m salidas

Caso de Estudio – DEMUX 1:4 Circuito Lógico

Diagrama de Caja Negra Bloque Funcional

E A B y0 y1 y2 y3
A B
A B
1 X X 1 1 1 1 y0

y0 DEMUX y1
0 0 0 1 1 1 1:4 y2
DEMUX y1
0 1 1 0 1 1 y3
1:4 y2 0
E

E y3 1 0 1 1 0 1
1 1 1 1 1 0

• Tomando en cuenta que las salidas son activo bajo, el valor de la entrada E se distribuye hacia la salida activa si E vale 0, mientras que
cuando vale 1 este aparece distribuido simultáneamente en todas las salidas.
• También puede verse a E como una entrada de habilitación en activo bajo, que desactiva el DEMUX cuando vale 1, haciendo que todas
las salidas valgan 1; en caso contrario, la salida activa con 0 depende de la configuración de las entradas de selección.
 Expansión de Demultiplexores
Existen 3 tipos básicos de DEMUX → 1:4, 1:8, 1:16
- Cualquier otra configuración 1:m puede implementarse con base a los anteriores → árboles de DEMUX
• Los DEMUXs se implementan generalmente
A B A B C y
0
A B C Dy
0
con decodificadores (2:4, 3:8, 4:16).
y0 y1 y1 • Existen versiones con salidas en activo alto.
DEMUX y1 y2 y2
DEMUX y3 DEMUX
1:4 y2 DEMUX en Circuitos Integrados TTL
1:8 y4 1:16

…
…
E y3 y5 74139 → (2x) DEMUX 1:4 (Decodificador 2:4)
y6 y14 74138 → (1x) DEMUX 1:8 (Decodificador 3:8)
E y7 E
y15 74154 → (1x) DEMUX 1:16 (Decodificador 4:16)

Árboles de DEMUX
Conjunto de DEMUX organizados en capas, comenzando en una capa inicial con una única entrada y cuyas salidas son
entradas de la siguiente capa y así van divergiendo progresivamente en cada capa hacia el conjunto final de múltiples
salidas.
• Las variables de selección más significativas (varían más lentamente) se distribuyen en las entradas de selección
de las capas iniciales del árbol, mientras que las menos significativas (varían más rapidamente) aparecen en las
entradas de selección de las capas finales.

Entradas de
selección
0
1:M

…
Entrada inicial
0
1:M

…
Salidas
…

de datos
…

0
finales
1:M
…

0 Estructura de
1:M árbol
…

Capa inicial
Capa final
 Ejemplo: Supongamos que se desea construir un árbol de DEMUX que se comporte como un DEMUX 1:16 pero
basado en DEMUXs más pequeños, es decir 1:4 y 1:8. Existen diversas configuraciones posibles, pero lo importante
es entender que el árbol debe comenzar en una capa que tiene 1 entrada, finalizar en 16 salidas y que las cuatro
entradas de selección que tendría un DEMUX 1:16, deben distribuirse en las entradas de selección de los DEMUXs
utilizados en el árbol.
Opción #1: Árbol de DEMUX 1:4 solamente
Variables de Selección
C D
A B C D
0 0 0 0 A B
4 variables para y0 y0
0 0 0 1
0 0 1 0 manejar 24 = 16 DEMUX y1 y1
0 0 1 1 salidas 1:4 y2 y2
0 1 0 0 E y3 y3
0 1 0 1
C D
0 1 1 0
0 1 1 1 A B
y0 y4
1 0 0 0 B C D
…
D varía más rápido; A B DEMUX y1 y5
A varía más lento 1:4 y2 y6
A B C y y0
0
y1 y1
A B
y0
E y3 y7
y2 y2
DEMUX y3 y3 DEMUX y1 C D
Opción #2: Árbol mixto de DEMUX 1:2 y 1:8
1:8 y4 y4 1:4 y2
A
y5 y5
y6
E E y3 A B
y0 y8
y6
E y7 y7 y9
DEMUX y1
B C D 1:4 y2 y10
E y3 y11
A B C y y8
E 0
y1 y9 C D
y2 y10
DEMUX y3 y11 A B
y12 y0 y12
1:8 y4
y5 y13 DEMUX y1 y13
y6 y14 y14
Equivalente a DEMUX 1:2 E y7 y15 1:4 y2
E y3 y15
Ejemplo: Implementar un DEMUX 1:32 basado en árboles de los DEMUXs existentes (1:2, 1:4, 1:8, 1:16).
En este ejemplo existen mayor cantidad de configuraciones posibles; se ilustrarán solamente dos de ellas.
Opción #2: Árbol mixto de MUX 8:1 y 4:1
Diagrama de Caja Negra S2 S1 S0
S4 S3 S2 S1S0
Un DEMUX 1:32 tiene 32 salidas y
A B C y y0
requiere 5 entradas de selección 0
y1 y1
ya que 25 = 32 y0 DEMUX
y1 1:8

…
…
…
MUX
y6 y6
32:1 y7

…
E
y7
y31
E
S2 S1 S0

A B C y y8
Opción #1: Árbol mixto de DEMUX 1:2 y 1:16
0
y1 y9
DEMUX
1:8

…
…
…
S3 S2 S1 S0 S4 S3
y6 y14
y7 y15
E
A B C Dy y0 A B
0 y0
y1 y1 S2 S1 S0
y2 y2 DEMUX Y1|
DEMUX 1:4 y2
S4 A B C y y16
1:16 0
…
…
…

E E y3 y1 y17
y14 y14 DEMUX
y15

…
1:8

…
…
y15
E
y6 y22
y7 y23
E
S3 S2 S1 S0
E
A B C Dy y16 S2 S1 S0
0
DEMUX 1:2 y1 y17
y2 y18 A B C y y24
DEMUX 0
y1 y25
1:16 DEMUX
…
…
…

…
1:8

…
…
y14 y30
y30
y15 y31 y6
E
y7 y31
E
 Aplicaciones de los Demultiplexores
Distribución de un dato a diversos dispositivos: Colocar Difusión de datos: Retransmitir un conjunto de datos
un dato compuesto de varios bits en un dispositivo recibidos sobre un canal de comunicación compartido.
seleccionado; cada DEMUX distribuye un bit del dato.
Recorrido en alta
S1 S0 Dato muestreo cíclico frecuencia sobre todas
Dispositivo 0 las combinaciones de las
0 0 Disp0 variables de selección
0 1 Disp1
x0
1 0 Disp2 S1 S0 y0
1 1 Disp3 Dato0 Dato0
A B
y0 Dato1 MUX DEMUX Dato1
Dispositivo 1
M:1 1:M

…
DEMUX y1

…
Canal de
1:4 y2 x1 Datom-1 comunicación Datom-1
y3
y1
E

Dato
Implementación de funciones lógicas: Utilizar un
S1 S0
x Dispositivo 2 DEMUX o un conjunto de ellos para implementar
el comportamiento de una función lógica.
y A B
y0 x2
DEMUX y1 y2
1:4 y2 X Y
S1 S0 X Y F
E y3
Dispositivo 3 0 0 1 A B
y0
x3 0 1 0 DEMUX y1
F
y3 1:4 y2
1 0 0 E y3
1 1 1
Activación y control de dispositivos: Utilizar las salidas de un
DEMUX para activar dentro de un conjunto de dispositivos uno solo
de ellos, mientras el resto permanece desactivado.

Implementación de funciones lógicas con DEMUX
Objetivo: Utilizar un solo DEMUX o un árbol de DEMUX para implementar funciones lógicas.

Ejemplo:
X Y X Y

X Y F A B A B
y0 y0
0 0 0 y0
DEMUX y1 DEMUX y1
F
y1
F
0 1 1 1:4 y2 1:4 y2
1 y2 y3 y3
E E
1 0
1 1 0 y3

Considerando los 1s de la función Enable a GND → DEMUX siempre activado

X Y X Y
X Y F
A B A B
y0 y0
0 0 0 y0
DEMUX y1 DEMUX y1
F
0 1 1 y1 1:4 y2 F 1:4 y2
1 0 1 y2 y3 y3
E E

1 1 0 y3

Considerando los 0s de la función Enable a GND → DEMUX siempre activado

Puede observarse la correspondencia entre el número de filas en la tabla de la verdad y salidas del DEMUX. Como una función está
definida por sus 1s o 0s, podemos implementar explícitamente una de ambas opciones. Para ello tomamos en cuenta las salidas que
corresponden con los 1s o los 0s de la tabla y las combinamos con las compuertas adecuadas haciéndolas converger hacia una única
salida, tomando en cuenta que las salidas del DEMUX son activo bajo; las combinaciones de las variables de la función conectadas en
las entradas de selección reproducen los valores de la función cuando activan las respectivas salidas del DEMUX.

Caso 1 - Base: El DEMUX tiene tantas entradas de selección como variables tiene la función.
• En este caso tendremos tantas salidas en el DEMUX como filas tiene la tabla de la verdad de la función.
• Debemos concentrar las salidas escogidas del DEMUX en una sola salida final que corresponda con el valor de la
función; recordar que las salidas son activo bajo (se activan con 0)
• Implementar los 1s:
 Opción #1: Negar las salidas asociadas con 1s y agrupar con OR
Opción #2: Agrupar con NAND las salidas asociadas con 1s.
• Implementar los 0s:
 Opción #1: Agrupar con AND las salidas asociadas con 0s.
Opción #2: Negar las salidas asociadas con 0s y agrupar con NOR.

Ejemplo:

F ( a , b, c ) = ∑ (0,1,4,7 )
3 variables → n=3
23 = 8 → DEMUX 1:8
Las implementaciones tipo “caso base” son simples y relativamente directas
con respecto a la definición de la función en su tabla de la verdad.
Sin embargo, requiere un DEMUX suficientemente grande para que acepte
todas las variables de la función en sus entradas de selección.

a b c F
a b c a b c
0 0 0 1
A B C y A B C y
0 0 1 1 0 0
y1 y1
0
0
1
1
0
1
0
0
y2
DEMUX y3
1:8 y4
y5
F ≡ y2
DEMUX y3
1:8 y4
y5
F
1 0 0 1 y6 y6
E y7 E y7
1 0 1 0
1 1 0 0

?
1 1 1 1

Ejercicio: F ( w, x, y , z ) = ∏ ( 4,5,7,8,12,15)

Caso 2: El DEMUX tiene menor cantidad de entradas de selección que la cantidad de variables de la función.
• También hay menos salidas en el DEMUX que las filas de la tabla de la verdad de la función.
• De acuerdo con esto, si nf es el número de variables de la función y n el número de entradas de selección del DEMUX:
→ nf > n → r = nf - n ; aparecen r variables “residuales” que no “caben” en el DEMUX.
• Las salidas escogidas van a estar ahora asociadas con expresiones que contienen a las variables residuales.
• Si el enunciado no especifica cuales son las variables de selección o residuales a usar, estas deben escogerse pero
tomando en cuenta lo siguiente:
IMPORTANTE: el cambio del conjunto de variables de selección produce una implementación equivalente
de la función pero complemente diferente → Se genera un circuito equivalente diferente.

Caso 2.a – Una variable residual: El número de entradas de selección del DEMUX es menor en 1 que la cantidad de
variables de la función → r = nf - n = 1 → una sola variable residual.
• Se determinan las expresiones a conectar en las salidas por inspección de la tabla de la verdad.
- Para una sola variable residual, las únicas expresiones posibles son la variable o la variable negada.
y
Ejemplo: Implementar F con DEMUX 1:4, tomando w y x como variables de selección. w x
F ( w, x, y ) = ∑ (1,4,5,6) w x y F Estos términos contienen
A B y
0
tanto 0s como 1s DEMUXy1
0 0 0
DEMUX 1:4 → 2 ent. sel.
F:
0
y 1:4 y2 F
nf = 3 ; n = 2 x 0 1
r = 3-2 = 1 var. res. → y
0 0 1 1
w 1s E y3
0 1 0 0 0
•
y •0
0 •
0 1 1 0 1 1
•
y
w x
y
• • 0s
1 0 0 1
1 A B y
Combinaciones 1 0 1 1
Este MK está en función de
0

posibles de w y x 1 1 0 1 DEMUXy1 F
las variables de selección y
1 1 1 0
y ayuda a visualizar si conviene 1:4 y2
implementar los 1s (•) o los E y3

¿Cómo cambia F 0s (•); se escoge el que tenga

en relación con y? menos elementos.
¿Cómo cambiaría el circuito si las
variables de selección no son w y x?
Ejemplo: Implementar G con DEMUX 1:8, tomando a, b, c como variables de selección.

G ( a , b, c, d ) = ∑ ( 2,7,8,9,12) + φ ( 4,5,11,13)

DEMUX 1:8 → 3 ent. selección

nf = 4 ; n = 3
r = 4-3 = 1 var. residual → d Implementación de los 0s

d
G: a b c
a b c d G bc
a 00 01 11 10 A B C y
0 0 0 0 0 • • • 0
0 0 y1
•
0 0 d
0 0 0 1 0 d y2 G
1 1
•
0
•
0 1 DEMUX y3
0 0 1 0 1 1:8 y4
d y5
0 0 1 1 0 y6
E y7
0 1 0 0 φ
φ φ =0→0
0 1 0 1 φ
0 1 1 0 0
0 1 1 1 1
d
1 0 0 0 1
1 φ =0→0
• Las expresiones se deducen del valor de
1 0 0 1 1
G con respecto a d si φ es 0 o 1.
1 0 1 0 0 0,35 • En este momento decidimos cuanto vale
0 ó d ≈ d ⋅φ cada φ y por lo tanto la expresión
1 0 1 1 φ resultante que irá conectada en la salida
1 1 0 0 1 φ =1→1 respectiva del DEMUX.
d ó 1 ≈ d + d ⋅φ
1 1 0 1 φ

?
1 1 1 0 0 ¿Cuáles serían los circuitos
0 resultantes si las variables de
1 1 1 1 0
selección fuesen abd, acd o bcd?

Caso 2.b – Dos o más variables residuales: El número de entradas de selección del DEMUX es menor al menos en 2
que la cantidad de variables de la función → r = nf - n ≥ 2 → más de una variable residual.
• Se determinan las expresiones a conectar en las salidas por simplificación de expresiones con MK:
-Se construyen tantos mapas de Karnaugh con respecto a las variables residuales como combinaciones existan de
las variables de selección y se llenan con los valores correspondientes de la función a implementar.
- De cada mapa se obtiene una expresión simplificada que es función de las variables residuales y se combina con la
salida correspondiente del DEMUX.

Ejemplo: Implementar F con DEMUX 1:4, tomando w y z como variables residuales.

F ( w, x, y , z ) = ∑ ( 0,4,5,7,8,12,14) + φ (3,9,10,13)

w x y z F Mapa de Karnaugh
DEMUX 1:4 → 2 ent. selección para las salidas
0 0 0 0 1 nf = 4 ; n = 2 F: y
0 0 0 1 r = 4-2 = 2 var. residuales → wz; xy sel. 0 1
x
0
0 0 1 0 0 0 •
z •
0
xy=00 xy=01
1 w⊕ z
•
0 0 1 1 φ 1
f0: f1 :
0 1 0 0 1 z z
0 1 0 1
w w
0 1 0 1 1 0 1 0 0 0 φ
0 1 1 0 0
1 1 φ 1 φ 0
0 1 1 1 1
wz
1 0 0 0 1 f0 = z f1 = 0 x y
1 0 0 1 φ xy=10 xy=11 A B y
0

1 0 1 0 φ f2: z
f3 : DEMUXy1 F
z
1 0 1 1 0 w
0 1
w
0 1 1:4 y2
1 1 0 1
E
1 1 0 0 1 0 0 y3

1 1 0 1 φ 1 1 φ 1 1 0
1 1 1 0 ¿Cómo cambiaría el circuito si las
1
f2 = 1 f3 = w ⊕ z variables de selección no son x y y?
1 1 1 1 0
Mismo ejemplo pero tomando wz para selección y xy como variables residuales:

F ( w, x, y , z ) = ∑ (0,4,5,7,8,12,14) + φ (3,9,10,13)
Mapa de Karnaugh
w x y z F para las salidas
0 0 0 0 1 wz=00 wz=01 F: z 0 1
0 0 0 1 0 f0: f1 : w • •
y y 0 y x
0 1 0 1
0 0 1 0 0 x x
1 0
•
1
0 0 1 1 φ
0 1 0 0 0 φ
0 1 0 0 1
1 1 0 1 1 1
0 1 0 1 1 f0 = y f1 = x
0 1 1 0 0
0 1 1 1 1 wz=10 wz=11
f2: f3 : x y
1 0 0 0 1 y
0 1
y
0 1 w z
x x
1 0 0 1 φ
0 1 φ 0 φ 0 A B y
φ
0
1 0 1 0
1 1 1 1 φ 0 DEMUXy1 F
1 0 1 1 0 1:4 y2
1 1 0 0 f2 = 1 E
1 f3 = 0 y3

1 1 0 1 φ
1 1 1 0 1
1 1 1 1 0

Implementación de funciones lógicas con Ejemplo: Implementar F con un árbol de DEMUX 1:4
árboles de DEMUX F ( a , b, c, d ) = ∑ (0,3,5,6,9,10,13)
Utilizando una técnica similar a la expansión
de DEMUXs, se organiza un árbol de DEMUXs c d
distribuyéndolos en capas según los siguientes A B
principios: y0

• La capa inicial comienza con un solo DEMUX DEMUX y1

1:4 y2
con su entrada E conectada a GND; las capas
y3
intermedias divergen progresivamente hacia
E

los DEMUX de la última capa. c d

• En la última capa se agrupan con AND todas A B
las salidas asociadas con los 0s o con NAND y0
F0
las asociadas con los 1s. a b DEMUX y1
1:4 y2
• Las variables de la función se distribuyen en A B y3
las entradas de selección de los DEMUXs, y0
E

partiendo desde la capa inicial con las DEMUX y1 c d

1:4 y2
variables que varían más lentamente hasta E y3 A B
las que varían más frecuentemente ubicadas
E
y0

en las últimas capas. DEMUX y1 F1

1:4 y2
E y3

• En el circuito se muestran simultáneamente las implementaciones de los c d

0s y los 1s de F aunque solo una es necesaria. A B
• Las salidas que no se toman en cuenta para alguna de las y0
implementaciones quedan “libres”. DEMUX y1
• Cuando no hay términos con variables residuales, es útil usar NAND para 1:4 y2
agrupar las salidas con 1s. E y3
• Una ventaja de los DEMUXs sobre los MUXs es que permiten implementar
varias funciones simultáneamente, incluyendo el caso en que se usa árboles
un solo dispositivo en lugar de árboles.
 Arquitectura en VHDL

La arquitectura (architecture) es la descripción del comportamiento o funcionamiento interno de una
unidad de diseño, componente o circuito en VHDL.

La declaración de una arquitectura establece la forma en que se obtienen las salidas a partir de las
entradas; equivale al contenido de la “caja negra” del componente o sistema.

Una arquitectura está asociada a la entidad que describe y pueden existir varias arquitecturas
asociadas con una misma entidad.

Existen dos partes dentro del código de una arquitectura:
• El área comprendida entre la cabecera y begin está destinada para declarar elementos que serán utilizados en la
descripción.
• El área delimitada entre begin/end que es donde se realiza la descripción del diseño.

Formato
architecture nomb_arquitectura of nomb_entidad is
declaraciones
begin
… -- conjunto de instrucciones
end nomb_arquitectura;
Ejemplo

a -- Ejemplo de descripción de arquitectura

Componente f architecture Descripcion1 of Componente is
b 3
signal temp: STD_LOGIC;
begin
temp <= (b(2) AND b(1) AND b(0)) OR a;
La arquitectura del ejemplo es una posible f <= NOT(temp);
descripción del componente ilustrado end Descripcion1;
 Estilos de Descripción

VHDL soporta tres estilos para la descripción del diseño en el cuerpo de una
arquitectura:
• Flujo de datos (Data Flow): se representa como fluyen los valores que transportan las
señales desde las entradas hacia las salidas del circuito.
• Estructural (Structural): el diseño se describe en base a la existencia de componentes
o módulos que realizan funciones específicas y la forma como se interconectan entre
sí a través de sus puertos para obtener las salidas deseadas.
• Comportamiento (Behavioral): se utilizan los elementos e instrucciones del lenguaje
para expresar en forma algorítmica la forma como se comporta o funciona el circuito.

Generalmente, los diseños se realizan en un estilo mixto que combina varios de
los estilos mencionados anteriormente.

Ejemplo: Se ilustran a continuación los diferentes estilos descriptivos, partiendo de la definición de un

componente de tipo MUX 2:1 simple.

Si ctrl vale 0, la salida S es A; en ctrl

caso contrario, la salida S es B. entity MUX_2_1 is
port(
A
A,B,ctrl: in bit;
MUX 2:1 S
S: out bit
B
);
end MUX_2_1;
 Descripción de Flujo de Datos

Consiste en especificar como son transferidos los valores lógicos de los
datos desde las entradas hasta las salidas del circuito, a través de las
diferentes señales que existen en el mismo
• Se emplean únicamente instrucciones concurrentes de asignación simple o asignación
condicional

-- Ejemplo de descripción de flujo de datos

-- Descripción de la arquitectura
architecture MUX1 of MUX_2_1 is
signal in1, in2, in3 : bit;
begin
in3 <= B and ctl;
in2 <= A and in1;
in1 <= not(ctrl);
S <= in2 or in3;
end MUX1;
 Descripción Estructural

Una descripción estructural se realiza usando el concepto de “componente”
• Un circuito está constituido por componentes más pequeños que realizan funciones
específicas y especializadas.
• La descripción indica los tipos de componentes y sus conexiones.
• Es esencialmente una descripción textual de un diseño esquemático.

El diseño se realiza en dos fases:
1. Se declaran los componentes; instrucción component
2. Se instancian los componentes; instrucción port map
• La instanciación de componentes es un tipo de instrucción concurrente y puede ser mezclada con otros
tipos de instrucciones.

Declaración de componentes Instancia de componentes

component nombre_componente [etiqueta :] nombre_componente
port( port map(
nombre_puerto: modo tipo_dato; nombre_puerto => señal,
nombre_puerto: modo tipo_dato; nombre_puerto => señal,
... ...
); );
end component;
 Ejemplo de Declaración Estructural

-- Ejemplo de descripción estructural

-- Descripción de la arquitectura
architecture MUX2 of MUX_2_1 is

-- Declaración de componentes y señales

component INV port (I : in bit; O : out bit);
component AND2 port (I1, I2 : in bit; O : out bit);
component OR2 port (I1, I2 : in bit; O : out bit);
signal in1, in2, in3 : bit;
begin
-- Instancias de componentes
U1: INV port map(I => ctrl , O => in1);
A in2
I1
AND2 O
U2: AND2 port map(I1 => A, I2 => in1, O => in2);
I2 I1 U3: AND2 port map(I1 => ctrl, I2 => B, O => in3);
OR2 O S U4: OR2 port map(I1 => in2, I2 => in3, O => S);
in1 I2

I INV O end MUX2;

ctrl I1
AND2 O
B I2
in3
 Descripción de Comportamiento
• Se utilizan algoritmos que describen el comportamiento del circuito
mediante instrucciones contenidas en un bloque de ejecución secuencial
(proceso)
– Una descripción de este estilo involucra la declaración de al menos un proceso
– Existen instrucciones para selección, repetición o sincronización del flujo de ejecución

-- Ejemplo de descripción de comportamiento

-- Descripción de la arquitectura
architecture MUX3 of MUX_2_1 is
0S=A begin
Si ctrl = process (ctrl, A, B)
if (ctrl = ‘0’) then
1S=B S <= A;
else
Este estilo no requiere una S <= B;
representación esquemática del end if;
circuito a describir. end process;
end MUX3;