Este documento presenta información sobre sistemas digitales combinacionales. Explica conceptos como multiplexores, demultiplexores y decodificadores, y cómo se pueden usar estos componentes para implementar funciones lógicas. También cubre temas como PLA, PAL, ROM y FPGA, y el uso de lenguajes de descripción hardware.

1. ELO211: Sistemas Digitales
Tomás Arredondo Vidal
1er Semestre – 2006
Este material está basado en:
textos y material de apoyo: Contemporary Logic Design 1st / 2nd edition. Gaetano
Borriello and Randy Katz. Prentice Hall, 1994, 2005
material del curso ELO211 del Prof. Leopoldo Silva
material en el sitio http://es.wikipedia.org
7: Combinacionales 1

2. 7-Sistemas Combinacionales
7.1 Introducción
7.2 Multiplexores, Demultiplexores,
Decodificador
7.3 PLAs, PALs, ROMs
7.4 FPGAs
7.5 HDLs
7: Combinacionales 2

3. Introducción: Componentes básicos
7: Combinacionales 3
Transistores se integraron en compuertas (1960s)
Catálogos de compuertas comunes (1970s)
TI Logic Data Book
listas de los típicos paquetes de chips y sus caracterizaciones
(retardos, consumo)
paquetes típicos en chips de 14 pins
• 6 inversores, 4 compuertas NANDS, 4 compuertas XOR
Cambios (rediseños) a estos diseños son difíciles de
hacer
Hay que reconectar partes o puede necesitar mas
componentes
se diseñaba con compuertas extras en cada placa por si fuera
necesario usarlas

4. Introducción: Bloques multi-uso
Hoy muy pocos de estas chips se utilizan
Pero, bibliotecas de estas compuertas se usan para
diseñar nuevos chips
se reutilizan las compuertas ya caracterizadas
las compuertas no existen en inventario se crean a medida
que se van necesitando
Hoy se usan componentes de lógica programable
se gana en flexibilidad
tiempos mas cortos de diseño
mas difícil de analizar en términos de compuertas especificas
se analiza usando bloques multi-uso mas grandes
7: Combinacionales 4

5. 7-Sistemas Combinacionales
7.1 Introducción
7.2 Multiplexores, Demultiplexores,
Decodificadores
7.3 PLAs, PALs, ROMs
7.4 FPGAs
7.5 HDLs
7: Combinacionales 5

6. Mux/Demux
7: Combinacionales 6
multiplexor demultiplexor switch 4x4
control control
Se usan para conectar y rutear
Muchos inputs a un output - multiplexor
Un input a muchos outputs – demultiplexor
Se pueden usan para conectar entre diferentes fuentes y
destinos
A
B
Y
Z

7. Mux y demux (cont'd)
Uso de multiplexor/demultiplexor en conexiones
multi-punto (como en este sumador)
MUX
A B
Sum
Ss
B0
MUX
DEMUX
B1A0 A1
S0 S1
Sa Sb múltiples fuentes de input
múltiple destinos de output
7: Combinacionales 7

8. Multiplexores
dos formas alternativas
para una tabla de verdad Mux 2:1
forma funcional
forma lógica
A Z
0 I0
1 I1
I1 I0 A Z
0 0 0 0
0 0 1 0
0 1 0 1
0 1 1 0
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 1
Z = A' I0 + A I1
Multiplexores: concepto general
2n data inputs, n inputs de control inputs, 1 output
se usan para conectar 2n puntos a un de punto salida
patrón de control binario indexa cual input se conecta al
output
7: Combinacionales 8

9. Multiplexores (cont'd)
2 -1
I0
I1
I2
I3
I4
I5
I6
I7
A B C
8:1
mux
Z
I0
I1
I2
I3
A B
4:1
mux
ZI0
I1
A
2:1
mux Z
k=0
n
2:1 mux: Z = A'I0 + AI1
4:1 mux: Z = A'B'I0 + A'BI1 + AB'I2 + ABI3
8:1 mux: Z = A'B'C'I0 + A'B'CI1 + A'BC'I2 + A'BCI3 +
AB'C'I4 + AB'CI5 + ABC'I6 + ABCI7
En general: Z = Σ (mkIk)
sumatoria de minterms para un 2n:1 Mux
7: Combinacionales 9

10. Implementación de multiplexores
usando compuertas
7: Combinacionales 10
2:1 mux
4:1 mux

11. Multiplexores en cascada
7: Combinacionales 11
señales de control B y C simultáneamente seleccionan
una de I0, I1, I2, I3 y una de I4, I5, I6, I7
señal de control A elige cual de los outputs
de los mux’s se envia a Z
implementación
alternativa
C
Z
A B
4:1
mux
2:1
mux
2:1
mux
2:1
mux
2:1
mux
I4
I5
I2
I3
I0
I1
I6
I7
8:1
mux
Se pueden implementar multiplexores mas grandes usando
multiplexores mas pequeños en cascada
Z
I0
I1
I2
I3
A
I4
I5
I6
I7
B C
4:1
mux
4:1
mux
2:1
mux
8:1
mux

12. Multiplexores para implementar funciones
Un multiplexor 2n:1 puede implementar cualquiera función de n
variables
con las variables usadas como inputs de control y
los inputs de datos con 0 o 1
básicamente, una tabla de referencia
Ejemplo:
F(A,B,C) = m0 + m2 + m6 + m7
= A'B'C' + A'BC' + ABC' + ABC
= A'B'C'(1) + A'B'C(0)
+ A'BC'(1) + A'BC(0)
+ AB'C'(0) + AB'C(0)
+ ABC'(1) + ABC(1)
Z = A'B'C'I0 + A'B'CI1 + A'BC'I2 + A'BCI3 +
AB'C'I4 + AB'CI5 + ABC'I6 + ABCI7
CA B
0
1
2
3
4
5
6
7
S2
8:1 MUX
S1 S0
Z
1
0
1
0
0
0
1
1
F
7: Combinacionales 12

13. Multiplexores para implementar funciones
Un multiplexor 2n-1:1 puede implementar cualquier función de n
variables
con n-1 variables usadas como inputs de control y
los inputs de datos con la ultima variable o su complemento
Ejemplo:
F(A,B,C) = m0 + m2 + m6 + m7
= A'B'C' + A'BC' + ABC' + ABC
= A'B'(C') + A'B(C') + AB'(0) + AB(1)
F
CA B
0
1
2
3
4
5
6
7
1
0
1
0
0
0
1
1
S2
8:1 MUX
S1 S0
A B C F
0 0 0 1
0 0 1 0
0 1 0 1
0 1 1 0
1 0 0 0
1 0 1 0
1 1 0 1
1 1 1 1
C'
C'
0
1 A B
S1 S0
F
0
1
2
3
4:1 MUX
C'
C'
0
1
7: Combinacionales 13

14. Multiplexores para implementar funciones
Generalización
Ejemplo:
G(A,B,C,D)
se puede realizar
con un MUX 8:1
n-1 variables de
control
una variable de
datos
cuatro posibles
configuraciones
de filas de la
tabla de verdad
se pueden
expresar como
una función de In
I0 I1 . . . In-1 In F
. . . . 0 0 0 1 1
. . . . 1 0 1 0 1
0 In In' 1
7: Combinacionales 14
elegir A,B,C como
variables de control
CA B
0
1
2
3
4
5
6
7
1
D
0
1
D’
D
D’
D’
S2
8:1 MUX
S1 S0
A B C D G
0 0 0 0 1
0 0 0 1 1
0 0 1 0 0
0 0 1 1 1
0 1 0 0 0
0 1 0 1 0
0 1 1 0 1
0 1 1 1 1
1 0 0 0 1
1 0 0 1 0
1 0 1 0 0
1 0 1 1 1
1 1 0 0 1
1 1 0 1 0
1 1 1 0 1
1 1 1 1 0
1
D
0
1
D'
D
D’
D’

15. Actividad
Realizar F = B’CD’ + ABC’ con un 4:1 multiplexor y
un minimo numero de compuertas:
7: Combinacionales 15
A B C D Z
0 0 0 0 0
0 0 0 1 0
0 0 1 0 1
0 0 1 1 0
0 1 0 0 0
0 1 0 1 0
0 1 1 0 0
0 1 1 1 0
1 0 0 0 0
1 0 0 1 0
1 0 1 0 1
1 0 1 1 0
1 1 0 0 1
1 1 0 1 1
1 1 1 0 0
1 1 1 1 0
0 when B’C’
D’ when B’C
A when BC’
0 when BC
Z = B’C’(0) + B’C(D’) + BC’(A) + BC(0)
B C
S1 S0
F
0
1
2
3
4:1 MUX
0
D’
A
0

16. Demultiplexor/decodificador
Decodificador/demultiplexor: concepto general
un input de datos, n inputs de control, 2n outputs
inputs de control (llamado “selects” (S)) representan
index binario de cual output se conecta el input
input de datos típicamente se llama “enable” (G)
1:2 Decoder:
O0 = G • S’
O1 = G • S
3:8 Decoder:
O0 = G • S2’ • S1’ • S0’
O1 = G • S2’ • S1’ • S0
O2 = G • S2’ • S1 • S0’
O3 = G • S2’ • S1 • S0
O4 = G • S2 • S1’ • S0’
O5 = G • S2 • S1’ • S0
O6 = G • S2 • S1 • S0’
O7 = G • S2 • S1 • S0
2:4 Decoder:
O0 = G • S1’ • S0’
O1 = G • S1’ • S0
O2 = G • S1 • S0’
O3 = G • S1 • S0
7: Combinacionales 16

17. Implementación de demultiplexores
7: Combinacionales 17
active-high
enable
active-low
enable
active-high
enable
active-low
enable
O0G
S
O1
O0G
S
O1
S1
O2
O3
O0
G
O1
S0 S1
O2
O3
O0G
O1
S0
decodificador 1:2
decodificador 2:4

18. Demultiplexores para implementar funciones
Un decoder n:2n puede implementar cualquier función de n
variables
con las variables usadas como inputs de control
los inputs de enable conectados a 1
los minterms sumados para formar la función
A'B'C'
A'B'C
A'BC'
A'BC
AB'C'
AB'C
ABC'
ABC
CA B
0
1
2
3
4
5
6
7
S2
3:8 DEC
S1 S0
“1”
demultiplexor genéra minterms apropiados
basados en las señales de control
("decodifica" señales de control)
7: Combinacionales 18

19. Demultiplexores para implementar funciones
F1
F2
F3
F1 = A'BC'D + A'B'CD + ABCD
F2 = ABC'D' + ABC
F3 = (A' + B' + C' + D')
A B
0 A'B'C'D'
1 A'B'C'D
2 A'B'CD'
3 A'B'CD
4 A'BC'D'
5 A'BC'D
6 A'BCD'
7 A'BCD
8 AB'C'D'
9 AB'C'D
10 AB'CD'
11 AB'CD
12 ABC'D'
13 ABC'D
14 ABCD'
15 ABCD
4:16
DECEnable
C D
7: Combinacionales 19

20. Decodificadores en cascada
0 A'B'C'D'E'
1
2
3
4
5
6
7
S2
3:8 DEC
S1 S0
A B
0
1
2
3S1
2:4 DEC
S0
F
0
1
2 A'BC'DE'
3
4
5
6
7
S2
3:8 DEC
S1 S0
EC D
0 AB'C'D'E'
1
2
3
4
5
6
7 AB'CDE
decodificador 5:32
decodificador 1x2:4
decodificador 4x3:8
3:8 DEC
0
1
2
3
4
5
6
7 ABCDE
EC D
S2 S1 S0 S2
3:8 DEC
S1 S0
7: Combinacionales 20

21. 7-Sistemas Combinacionales
7.1 Introducción
7.2 Multiplexores, Demultiplexores,
Decodificador
7.3 PLAs, PALs, ROMs
7.4 FPGAs
7.5 HDLs
7: Combinacionales 21

22. Programmable logic arrays
Bloque constructivo de lógica de muchas compuertas AND/OR
en realidad se usan NOR o NAND
"personalizado" al hacer/romper conexiones entre las
compuertas
diagrama de PLA para forma suma de productos
7: Combinacionales 22
• • •
inputs
AND
array
• • •
outputs
OR
arrayproduct
terms

23. PLAs: Concepto que permite implementación
Términos de productos son compartidos
entre los outputs
ejemplo:
F0 = A + B' C'
F1 = A C' + A B
F2 = B' C' + A B
F3 = B' C + A
personality matrix
1 = uncomplemented in term
0 = complemented in term
– = does not participate
1 = term connected to output
0 = no connection to output
input side:
output side:
product inputs outputs
term A B C F0 F1 F2 F3
AB 1 1 – 0 1 1 0
B'C – 0 1 0 0 0 1
AC' 1 – 0 0 1 0 0
B'C' – 0 0 1 0 1 0
A 1 – – 1 0 0 1
reuso de terminos
7: Combinacionales 23

24. Antes de programar
Todas las conexiones posibles están
disponibles antes de “programar”
en realidad, todas las AND y ORs son NANDs
7: Combinacionales 24

25. Durante programación
7: Combinacionales 25
A B C
F1 F2 F3F0
AB
B'C
AC'
B'C'
A
Conexiones no deseadas se eliminan
fuse (normalmente conectadas, se rompen esas no
deseadas)
anti-fuse (normalmente desconectadas, se hacen
conexiones deseadas)

26. Representaciones alternativas
ejemplo:
F0 = A B + A' B'
F1 = C D' + C' D
AB+A'B'
CD'+C'D
AB
A'B'
CD'
C'D
A B C D
Mas corta para no tener que dibujar todos los
cable
significa conexión esta presente y señal
perpendicular es input a una compuerta
7: Combinacionales 26

27. PLA: ejemplo
7: Combinacionales 27
A'B'C'
A'B'C
A'BC'
A'BC
AB'C'
AB'C
ABC'
ABC
A B C
F1 F2 F3 F4 F5
F6
full decoder as for memory address
bits stored in memory
Múltiples funciones usando A, B, C
F1 = A B C
F2 = A + B + C
F3 = A' B' C'
F4 = A' + B' + C'
F5 = A xor B xor C
F6 = A xnor B xnor C
A B C F1 F2 F3 F4 F5 F6
0 0 0 0 0 1 1 0 0
0 0 1 0 1 0 1 1 1
0 1 0 0 1 0 1 1 1
0 1 1 0 1 0 1 0 0
1 0 0 0 1 0 1 1 1
1 0 1 0 1 0 1 0 0
1 1 0 0 1 0 1 0 0
1 1 1 1 1 0 0 1 1

28. PALs y PLAs
7: Combinacionales 28
una columna del arreglo OR
solo tiene acceso a un
subconjunto del los posibles productos
Programmable logic array (PLA)
lo que hemos visto hasta ahora
arreglos AND y OR generales, sin restricciones
Programmable array logic (PAL)
topología del arreglo OR es restringida (eg. 8, 4, 2 ORs,
numero de inputs fijo para cada OR)
plano de ORs es mas rápido y pequeño
todos los términos de los productos no
se comparten entre los ouputs

29. Ejemplo: PALs y PLAs
Conversor de código BCD a Gray
A B C D W X Y Z
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 1
0 0 1 1 0 0 1 0
0 1 0 0 0 1 1 0
0 1 0 1 1 1 1 0
0 1 1 0 1 0 1 0
0 1 1 1 1 0 1 1
1 0 0 0 1 0 0 1
1 0 0 1 1 0 0 0
1 0 1 – – – – –
1 1 – – – – – –
funciones minimizadas:
W = A + BD + BC
X = BC'
Y = B + C
Z = A'B'C'D + BCD + AD' + B'CD'
7: Combinacionales 29

30. Ejemplo: PALs y PLAs (cont)
Conversor de código: PLA
funciones minimizadas:
W = A + BD + BC
X = B C'
Y = B + C
Z = A'B'C'D + BCD + AD' + B'CD'
A B C D
A
BD
BC
BC'
B
C
A'B'C'D
BCD
AD'
BCD'
W X Y Z
no es un buen candidato para
implementación en PLA
ya que los términos no son
compartidos entre los outputs
pero la implementación es mucho
mas compacta y regular que usando
compuertas AND y OR discretas
7: Combinacionales 30

31. Ejemplo: PALs y PLAs (cont)
Conversor de código: PAL
A
BD
BC
0
BC'
0
0
0
B
C
0
0
A'B'C'D
BCD
AD'
B'CD'
W X Y Z
A B C D
4 términos de
productos por cada
compuerta OR
7: Combinacionales 31

32. Ejemplo: PALs y PLAs (cont)
Conversor de código: implementación con
compuertas individuales NAND
se pierde regularidad, mas difícil de entender
mas difícil hacer cambios
7: Combinacionales 32
W
X
Y
Z
B
B
B
B
B
B
B
C
C
C
A
A
A
D
D
D
D
D
C
C

33. Ejemplo2: PALs y PLAs
Comparador AB vs CD
EQ NE LT GT
A'B'C'D'
A'BC'D
ABCD
AB'CD'
AC'
A'C
B'D
BD'
A'B'D
B'CD
ABC
BC'D'
A B C D
7: Combinacionales 33
A B C D EQ NE LT GT
0 0 0 0 1 0 0 0
0 0 0 1 0 1 1 0
0 0 1 0 0 1 1 0
0 0 1 1 0 1 1 0
0 1 0 0 0 1 0 1
0 1 0 1 1 0 0 0
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 0
1 0 0 0 0 1 0 1
1 0 0 1 0 1 0 1
1 0 1 0 1 0 0 0
1 0 1 1 0 1 1 0
1 1 0 0 0 1 0 1
1 1 0 1 0 1 0 1
1 1 1 0 0 1 0 1
1 1 1 1 1 0 0 0
funciones minimizadas:
EQ = A’B’C’D’ + A’BC’D + ABCD + AB’CD’ NE = AC’ + A’C + B’D + BD’
LT = A’C + A’B’D + B’CD GT = AC’ + ABC + BC’D’

34. Actividad
Mapear las funciones a un PLA:
W = AB + A’C’ + BC’
X = ABC + AB’ + A’B
Y = ABC’ + BC + B’C’
A B C
W X Y
7: Combinacionales 34

35. W = AB + A’C’ + BC’
X = ABC + AB’ + A’B
Y = ABC’ + BC + B’C’
Actividad (cont)
9 términos no caben en PLA de 7 términos
se puede usar teorema de consenso
a W para simplificar a:
W = AB + A’C’
8 términos no caben en PLA de 7 términos
observe que AB = ABC + ABC’
reescribir W para reutilizar términos:
W = ABC + ABC’ + A’C’
Ahora cabe
W = ABC + ABC’ + A’C’
X = ABC + AB’ + A’B
Y = ABC’ + BC + B’C’
Esto es mapeo de tecnología
manipular funciones lógicas para poder usar
recursos disponibles
ABC
ABC’
A’C’
AB’
A’B
BC
B’C’
A B C
W X Y
7: Combinacionales 35

36. Read-only memories (ROM)
7: Combinacionales 36
decoder
0 n-1
Address
2 -1
n
0
1 1 1 1
word[i] = 0011
word[j] = 1010
lineas de bits (normalmente subido a 1
a través de resistor – selectivamente
conectado a zero por los switches controlados
por las palabras)
j
i
líneas de palabras (solo
unas es activa – decoder
se usa por eso)
Arreglo bidimensional de 1s y 0s
entrada (fila) se llama palabra ("word“)
ancho de fila = word-size
índice es dirección ("address“)
dirección es input
palabra seleccionada es output
ROM: organizacion interna

37. ROMs y lógica combinacional
Implementando lógica combinacional con un ROM
(forma canónica de dos niveles)
F0 = A' B' C + A B' C' + A B' C
F1 = A' B' C + A' B C' + A B C
F2 = A' B' C' + A' B' C + A B' C'
F3 = A' B C + A B' C' + A B C'
truth table
A B C F0 F1 F2 F3
0 0 0 0 0 1 0
0 0 1 1 1 1 0
0 1 0 0 1 0 0
0 1 1 0 0 0 1
1 0 0 1 0 1 1
1 0 1 1 0 0 0
1 1 0 0 0 0 1
1 1 1 0 1 0 0
block diagram
ROM
8 words x 4 bits/word
address outputs
A B C F0F1F2F3
7: Combinacionales 37

38. Estructura de ROM
Similar a PLA pero con un arreglo AND
completamente decodificado
Arreglo OR completamente flexible
n address lines
• • •
inputs
decoder 2n word
lines
• • •
outputs
memory
array
(2n words
by m bits)
m data lines
7: Combinacionales 38

39. ROM vs. PLA
7: Combinacionales 39
ROM ventajoso cuando
tiempo de diseño es corto (no hay que minimizar funciones
de output)
la mayoría de combinaciones de input se necesitan (e.g.,
conversores de código)
no se comparten los productos
problemas ROM
tamaño se duplica para cada input adicional
no se pueden utilizar don't cares
PLA ventajoso cuando
hay herramientas para multi-output minimización
hay pocas combinaciones única de minterms
muchos minterms son compartidos entre las funciones de
output
problemas PAL
restricciones de fan-ins en plano OR

40. Estructuras lógicas: ROM, PAL, PLA
7: Combinacionales 40
ROM – plano AND completo, plano OR general
barato (componente de alto volumen)
puede implementar cualquiera función de n inputs
velocidad media
PAL – plano AND programable, plano OR fijo
costo intermedio
puede implementar funciones con numero de términos
limitados
alta velocidad (solo un plano programable)
PLA – planos AND y OR programmables
mas caro (complejo en diseño, herramientas mas
sofisticadas)
puede implementar cualquiera función has un limite de
términos
lento (dos planos programables)

41. Estructuras lógicas: ROM, PAL, PLA
Difícil lograr una estructura regular (celda o cell) para
la conexión arbitraria para conexiones entre
diferentes tipos de compuertas
requerimientos de eficiencia/velocidad
field programmable gate arrays (FPGAs) usan ese
tipo de estructuras programables multi-nivel
• multiplexores programables para conexiones
• tablas de referencia para funciones lógicas
• celdas multi-uso (utilización es lo importante)
Se pueden usar múltiples niveles de PALs/PLAs/ROMs
output es resultado intermedio
se hace un input para ser usado en otra lógica
7: Combinacionales 41

42. 7-Sistemas Combinacionales
7.1 Introducción
7.2 Multiplexores, Demultiplexores,
Decodificador
7.3 PLAs, PALs, ROMs
7.4 FPGAs
7.5 HDLs
7: Combinacionales 42

43. FPGA (Field Programmable Gate Arrays)
Dispositivos basados en arreglos bidimensionales de
bloques lógicos y flip-flops
Interconexiones entre bloques, funciones lógicas y de
control son programables usando HDL
Algunos tienen memoria y procesadores incorporados
Algunos fabricantes proporcionan el código HDL de
microprocesadores de 16 y 32 bits, unidades
multiplicación y acumulación para implementar
diferentes aplicaciones (e.g. filtros digitales)
Diferentes opciones para los bloques lógicos incluyen:
pares de transistores, compuertas NAND de dos
entradas, compuertas AND y XOR, multiplexores y
tablas de búsqueda 7: Combinacionales 43

44. FPGA (Field Programmable Gate Arrays)
7: Combinacionales 44
Ejemplo: celda basada en
multiplexores
Esta celda es de 8 entradas y una salida implementa:
f = (s0 + s1)’(sA’A0+sAA1)(s0 + s1)(sB’B0+sBB1)
Esta celda puede implementar todas las funciones de dos
variables, todas las de tres con al menos unas sin
complementar, muchas de cuatro y hasta algunas de ocho

45. FPGA (Field Programmable Gate Arrays)
Ejemplo: celda basada en
tabla de búsqueda (LUT)
Esta celda es de 4 entradas y puede implementar cualquier función
de cuatro variables
7: Combinacionales 45
Para su funcionamiento primero se graba la tabla de búsqueda con la
tabla de verdad de la función, se direcciona usando el decodificador
Una ves configurada, se usa el multiplexor con la combinación de las
variables de entrada y en la salida se obtiene el bit almacenado

46. FPGA (Field Programmable Gate Arrays)
7: Combinacionales 46
Ejemplo: implementación de función de cuatro variables usando
celdas LUT de 3 variables: f = x2’x3 + x1’x2x3’ + x2x3’x4 + x1x2’x4’
Usando el Teorema de Shannon:
Finalmente:

47. FPGA: Etapas de trabajo
Para trabajar con FPGAs es necesario ingresar el diseño usando
esquemáticos o usando un lenguaje HDL como Verilog o VHDL. Esta
etapa es codificación.
Luego se compila y simula el diseño de la cual se puede verificar el
diseño lógico y el flujo de datos
Luego se ejecuta la fase de síntesis, que implementa el diseño en
compuertas básicas, minimizando las ecuaciones
La próxima fase el mapeo tecnológico, que implementa las ecuaciones
con los elementos lógicos disponibles. También se hacen las
localicaciones de los componentes y los enrutamientos y conexiones
entre los componentes (place and route)
Se ejecutan simulaciones temporales usando el diseño final
Finalmente se genera un archivo binario el cual se graba en el
dispositivo.
7: Combinacionales 47

48. 7-Sistemas Combinacionales
7.1 Introducción
7.2 Multiplexores, Demultiplexores,
Decodificador
7.3 PLAs, PALs, ROMs
7.4 FPGAs
7.5 HDLs
7: Combinacionales 48

49. HDLs (Hardware description
languages)
Describen hardware en diferentes niveles de
abstracción
Descripción estructural
reemplazo textual para una esquemática
composición jerárquica de módulos desde elementos
primitivos
Descripción de Comportamiento y Funcional
describe lo que hace un modulo no los componentes
específicos
la etapa de síntesis genera el circuito para el modulo
Requerimientos para la simulación
circuito de prueba
7: Combinacionales 49

50. HDLs
Abel (circa 1983) – desarrollado por Data-I/O
usado para PLUs
principalmente para maquinas de estados
ISP (circa 1977) – proyecto de CMU
simulación, pero no síntesis
Verilog (circa 1985) – desarrollado por Gateway (absorvido por
Cadence)
similar a Pascal y C
eficiente y facil de usar
standard de IEEE
VHDL (circa 1987) – desarrollado por DoD de USA
similar a Ada
muy general pero complejo
standard de IEEE
7: Combinacionales 50

51. Verilog
Permite descripción estructurales y de comportamiento
Estructural
estructura explicita del circuito
e.g., cada compuerta es instanciada y conectada a otras
Comportamiento
programa describe input/output del circuito
pueden haber muchas implementaciones del mismo
comportamiento
e.g., diferentes implementaciones de una función
Booleana
7: Combinacionales 51

52. Modelo Estructural
module xor_gate (out, a, b);
input a, b;
output out;
wire abar, bbar, t1, t2;
inverter invA (abar, a);
inverter invB (bbar, b);
and_gate and1 (t1, a, bbar);
and_gate and2 (t2, b, abar);
or_gate or1 (out, t1, t2);
endmodule
7: Combinacionales 52

53. Modelo simple de comportamiento
Asignación continua
module xor_gate (out, a, b);
input a, b;
output out;
reg out;
assign #6 out = a ^ b;
endmodule
retardo desde cambio en input
hasta cambio en output
registro de simulación –
contiene valor de senal
7: Combinacionales 53

54. Modelo simple de comportamiento
bloque always
module xor_gate (out, a, b);
input a, b;
output out;
reg out;
always @(a or b) begin
#6 out = a ^ b;
end
endmodule especifica cuando se ejecuta el bloque
ie. determinado por que señales
7: Combinacionales 54

55. Activando la simulación usando
un banco de prueba (testbench)
7: Combinacionales 55
module testbench (x, y);
output x, y;
reg [1:0] cnt;
initial begin
cnt = 0;
repeat (4) begin
#10 cnt = cnt + 1;
$display ("@ time=%d, x=%b, y=%b, cnt=%b",
$time, x, y, cnt); end
#10 $finish;
end
assign x = cnt[1];
assign y = cnt[0];
endmodule
vector de 2-bits
bloque inicial se ejecuta
una vez al inicio de la
simulación
directiva de
detener simulación
imprimir a consola

56. Simulación completa
Instanciar componente de estimulo y
componente para probar circuito
a
b
z
test-bench
x
y
7: Combinacionales 56

57. Ejemplo comparador
module Compare1 (Equal, Alarger, Blarger, A, B);
input A, B;
output Equal, Alarger, Blarger;
assign #5 Equal = (A & B) | (~A & ~B);
assign #3 Alarger = (A & ~B);
assign #3 Blarger = (~A & B);
endmodule
7: Combinacionales 57

58. Modelo de comportamiento mas
complejo
7: Combinacionales 58
module life (n0, n1, n2, n3, n4, n5, n6, n7, self, out);
input n0, n1, n2, n3, n4, n5, n6, n7, self;
output out;
reg out;
reg [7:0] neighbors;
reg [3:0] count;
reg [3:0] i;
assign neighbors = {n7, n6, n5, n4, n3, n2, n1, n0};
always @(neighbors or self) begin
count = 0;
for (i = 0; i < 8; i = i+1) count = count + neighbors[i];
out = (count == 3);
out = out | ((self == 1) & (count == 2));
end
endmodule

59. HDL vs lenguajes de programación
7: Combinacionales 59
Estructura de programa
instanciar múltiples componentes al mismo tiempo
especifican interconexión de módulos vía esquemática
jerarquía de módulos encapsulan bloques funcionales
Asignación
asignación continua (lógica siempre calcula)
retardos de propagación (computación toma tiempo)
efectos temporales de señales es importante
Estructuras de datos
tamaño explícitamente especificado - no hay estructuras
dinámicas
no hay punteros
Paralelismo
hardware es naturalmente paralelo
asignaciones pueden ocurrir en paralelo (no solo
secuencialmente)