7-Sistemas Combinacionales

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
7-Sistemas Combinacionales
7.1 Introducción
7.2 Multiplexores, Demultiplexores,
Decodificador
7.3 PLAs, PALs, ROMs
7.4 FPGAs
7.5 HDLs
Introducción: Componentes básicos
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
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.1 Introducción
Decodificadores
7.4 FPGAs
7.5 HDLs
Mux/Demux A Y
B Z
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
control control
multiplexor demultiplexor switch 4x4
Mux y demux (cont'd)
Uso de multiplexor/demultiplexor en conexiones
multi-punto (como en este sumador)
A0 A1 B0 B1
Sa MUX MUX Sb múltiples fuentes de input
A B
Sum
Ss DEMUX múltiple destinos de output
S0 S1
Multiplexores
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 I1 I0 A Z
A Z
0 I0 0 0 0 0
Z = A' I0 + A I1 0 0 1 0
1 I1
0 1 0 1
0 1 1 0
1 0 0 0
forma funcional 1 0 1 1
forma lógica 1 1 0 1
1 1 1 1
dos formas alternativas
para una tabla de verdad Mux 2:1
Multiplexores (cont'd)
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
2 n -1
En general: Z = Σ (mkIk) I0
k=0 I1
I2
sumatoria de minterms para un 2n:1 Mux I3 8:1 Z
I4 mux
I0 I5
I1 4:1 I6
I0 2:1 I2 Z I7
Z mux
I1 mux I3
A B C
A A B
Implementación de multiplexores
usando compuertas
2:1 mux
4:1 mux
Multiplexores en cascada
Se pueden implementar multiplexores mas grandes usando
multiplexores mas pequeños en cascada
8:1
I0
I1 4:1 mux
I2 mux implementación
I3 2:1 alternativa
Z
mux I0
I4 2:1 8:1
I5 4:1 I1 mux mux
I6 mux
I7 I2 2:1
I3 mux 4:1 Z
B C A mux
I4 2:1
I5 mux
señales de control B y C simultáneamente seleccionan
una de I0, I1, I2, I3 y una de I4, I5, I6, I7 I6 2:1
I7 mux
señal de control A elige cual de los outputs
de los mux’s se envia a Z
C A B
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 1 0
1
= A'B'C' + A'BC' + ABC' + ABC
0
1 2
0 3
4 8:1 MUX Z
F
0
= A'B'C'(1) + A'B'C(0) 0 5
+ A'BC'(1) + A'BC(0) 1 6
7
+ AB'C'(0) + AB'C(0) 1
S2 S1 S0
+ ABC'(1) + ABC(1)
A B C
Z = A'B'C'I0 + A'B'CI1 + A'BC'I2 + A'BCI3 +
AB'C'I4 + AB'CI5 + ABC'I6 + ABCI7
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)
1 0
0 1 A B C F
1 2 0 0 0 1
C' C' 0
0 3 0 0 1 0 F
0 1 0 1 C' 1 4:1 MUX
0 4 8:1 MUX F C'
0 1 1 0 0 2
0 5 1 3
1 6 1 0 0 0 S1 S0
0
1 7 1 0 1 0
S2 S1 S0 1 1 0 1 A B
1
1 1 1 1
A B C
Generalización I0 I1 . . . In-1 In F cuatro posibles
configuraciones
. . . . 0 0 0 1 1 de filas de la
n-1 variables de tabla de verdad
control . . . . 1 0 1 0 1 se pueden
expresar como
una variable de una función de In
datos
A B C D G 0 In In' 1
0 0 0 0 1
Ejemplo: 0 0 0 1 1
1
0 0 1 0 0
G(A,B,C,D) 0 0 1 1 1 D
1 0
0 1 0 0 0 D 1
se puede realizar
0
0 1 0 1 0 0 2
0 1 1 0 1 1 3
con un MUX 8:1
1
0 1 1 1 1 D’ 4 8:1 MUX
1 0 0 0 1 D 5
1 0 0 1 0 D' D’ 6
elegir A,B,C como 1 0 1 0 0 D’ 7
variables de control 1 0 1 1 1 D
S2 S1 S0
1 1 0 0 1
1 1 0 1 0 D’
1 1 1 0 1 A B C
D’
1 1 1 1 0 7: Combinacionales 14
Actividad
Realizar F = B’CD’ + ABC’ con un 4:1 multiplexor y
un minimo numero de compuertas:
A B C D Z 0 when B’C’
0 0 0 0 0
0 0 0 1 0
0 0 1 0 1
0 0 1 1 0 D’ when B’C
0 1 0 0 0 0 0
0 1 0 1 0 D’ 1 4:1 MUX F
0 1 1 0 0 A 2
0 1 1 1 0 A when BC’ 0 3 S1 S0
1 0 0 0 0
1 0 0 1 0 B C
1 0 1 0 1 0 when BC
1 0 1 1 0
1 1 0 0 1
1 1 0 1 1
1 1 1 0 0 Z = B’C’(0) + B’C(D’) + BC’(A) + BC(0)
1 1 1 1 0
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: 3:8 Decoder:

O0 = G • S’ O0 = G • S2’ • S1’ • S0’
O1 = G • S O1 = G • S2’ • S1’ • S0
O2 = G • S2’ • S1 • S0’
2:4 Decoder: O3 = G • S2’ • S1 • S0
O0 = G • S1’ • S0’ O4 = G • S2 • S1’ • S0’
O1 = G • S1’ • S0 O5 = G • S2 • S1’ • S0
O2 = G • S1 • S0’ O6 = G • S2 • S1 • S0’
O3 = G • S1 • S0 O7 = G • S2 • S1 • S0
Implementación de demultiplexores
decodificador 1:2
active-high active-low
enable enable
G O0 \G O0
S S
O1 O1
decodificador 2:4
G \G O0
O0
active-high active-low
enable O1 enable O1
O2 O2
O3 O3
S1 S0 S1 S0
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
0 A'B'C'
1 A'B'C
2 A'BC' demultiplexor genéra minterms apropiados
3 A'BC basados en las señales de control
“1” 3:8 DEC 4 AB'C' ("decodifica" señales de control)
5 AB'C
6 ABC'
7 ABC
S2 S1 S0
A B C
Demultiplexores para implementar funciones
F1 = A'BC'D + A'B'CD + ABCD

F2 = ABC'D' + ABC
0 A'B'C'D'
F3 = (A' + B' + C' + D') 1 A'B'C'D
2 A'B'CD' F1
3 A'B'CD
4 A'BC'D'
5 A'BC'D
6 A'BCD'
4:16 7 A'BCD
Enable DEC 8 AB'C'D' F2
9 AB'C'D
10 AB'CD'
11 AB'CD
12 ABC'D'
13 ABC'D
14 ABCD'
15 ABCD F3
A B C D
Decodificadores en cascada
decodificador 5:32
0 A'B'C'D'E' 0
decodificador 1x2:4 1 1
2 2 A'BC'DE'
decodificador 4x3:8 3:8 DEC3 3:8 DEC 3
4 4
5 5
6 6
7 7
S2 S1 S0 S2 S1 S0
0
F 2:4 DEC 1
2
S1 S0 3
0 0 AB'C'D'E'
A B 1 1
2 2
3:8 DEC3 3:8 DEC 3
4 4
5 5
6 6
7 ABCDE 7 AB'CDE
S2 S1 S0 S2 S1 S0
C D E C D E
7.1 Introducción
Decodificador
7.4 FPGAs
7.5 HDLs
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
• • •
inputs
OR
AND
product array
array
terms
outputs
• • •
PLAs: Concepto que permite implementación
Términos de productos son compartidos
entre los outputs
F0 = A + B' C'
ejemplo: F1 = A C' + AB
F2 = B' C' + AB
F3 = B' C + A
input side:
personality matrix
1 = uncomplemented in term
0 = complemented in term
product inputs outputs – = does not participate
term A B C F0 F1 F2 F3
AB 1 1 – 0 1 1 0 output side:
B'C – 0 1 0 0 0 1 1 = term connected to output
0 = no connection to output
AC' 1 – 0 0 1 0 0
B'C' – 0 0 1 0 1 0
reuso de terminos
A 1 – – 1 0 0 1
Antes de programar
Todas las conexiones posibles están
disponibles antes de “programar”
en realidad, todas las AND y ORs son NANDs
Durante programación
Conexiones no deseadas se eliminan
fuse (normalmente conectadas, se rompen esas no
deseadas)
anti-fuse (normalmente desconectadas, se hacen
conexiones deseadas)
A B C
AB
B'C
AC'
B'C'
F0 F1 F2 F3
Representaciones alternativas
Mas corta para no tener que dibujar todos los
cable
significa conexión esta presente y señal
perpendicular es input a una compuerta
ejemplo:
F0 = A B + A' B'
F1 = C D' + C' D
A B C D
AB
A'B'
CD'
C'D
AB+A'B'
CD'+C'D
PLA: ejemplo
Múltiples funciones usando A, B, C
F1 = A B C
full decoder as for memory address
F2 = A + B + C
bits stored in memory
F3 = A' B' C'
A B C
F4 = A' + B' + C' A'B'C'
F5 = A xor B xor C A'B'C

A'BC'
F6 = A xnor B xnor C
A'BC
AB'C'
A B C F1 F2 F3 F4 F5 F6
0 0 0 0 0 1 1 0 0 AB'C
0 0 1 0 1 0 1 1 1
0 1 0 0 1 0 1 1 1 ABC'
0 1 1 0 1 0 1 0 0 ABC
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 F1 F2 F3 F4 F5
F6
PALs y PLAs
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
una columna del arreglo OR

solo tiene acceso a un
subconjunto del los posibles productos
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 funciones minimizadas:
0 1 0 0 0 1 1 0
0 1 0 1 1 1 1 0
0 1 1 0 1 0 1 0 W = A + BD + BC
0 1 1 1 1 0 1 1 X = BC'
1 0 0 0 1 0 0 1 Y=B+C
1 0 0 1 1 0 0 0 Z = A'B'C'D + BCD + AD' + B'CD'
1 0 1 – – – – –
1 1 – – – – – –
Ejemplo: PALs y PLAs (cont)
Conversor de código: PLA
funciones minimizadas:
A B C D
W = A + BD + BC
X = B C'
A Y=B+C
Z = A'B'C'D + BCD + AD' + B'CD'
BD
BC
BC'
no es un buen candidato para
implementación en PLA
B ya que los términos no son
compartidos entre los outputs
C
A'B'C'D
pero la implementación es mucho
BCD mas compacta y regular que usando
AD' compuertas AND y OR discretas
BCD'
W X Y Z
Conversor de código: PAL
A B C D
A
BD
BC
0
BC'
0
0
0
4 términos de B
productos por cada C
compuerta OR
0
0
A'B'C'D
BCD
AD'
B'CD'
W X Y Z
Conversor de código: implementación con
compuertas individuales NAND
se pierde regularidad, mas difícil de entender
mas difícil hacer cambios
A
A B
C
B W D
D
B
B C
C D Z
A
B \D
X \B
C C
\D
Y
B
Ejemplo2: PALs y PLAs
Comparador AB vs CD
A B C D
A'B'C'D'
A'BC'D
A B C D EQ NE LT GT ABCD
0 0 0 0 1 0 0 0
0 0 0 1 0 1 1 0 AB'CD'
0 0 1 0 0 1 1 0
AC'
0 0 1 1 0 1 1 0
0 1 0 0 0 1 0 1 A'C
0 1 0 1 1 0 0 0
0 1 1 0 0 1 1 0 B'D
0 1 1 1 0 1 1 0 BD'
1 0 0 0 0 1 0 1
1 0 0 1 0 1 0 1 A'B'D
1 0 1 0 1 0 0 0
B'CD
1 0 1 1 0 1 1 0
1 1 0 0 0 1 0 1 ABC
1 1 0 1 0 1 0 1
1 1 1 0 0 1 0 1 BC'D'
1 1 1 1 1 0 0 0
funciones minimizadas:
EQ NE LT GT
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’ 7: Combinacionales
33
Actividad
Mapear las funciones a un PLA:

W = AB + A’C’ + BC’ A B C
X = ABC + AB’ + A’B
Y = ABC’ + BC + B’C’
W X Y
W = AB + A’C’ + BC’
Actividad (cont) X = ABC + AB’ + A’B
9 términos no caben en PLA de 7 términos

se puede usar teorema de consenso A B C
a W para simplificar a:
W = AB + A’C’ ABC
8 términos no caben en PLA de 7 términos ABC’
observe que AB = ABC + ABC’ A’C’
reescribir W para reutilizar términos: AB’
W = ABC + ABC’ + A’C’
A’B
Ahora cabe
BC
W = ABC + ABC’ + A’C’
X = ABC + AB’ + A’B B’C’
Esto es mapeo de tecnología
manipular funciones lógicas para poder usar
recursos disponibles W X Y
Read-only memories (ROM)
Arreglo bidimensional de 1s y 0s
entrada (fila) se llama palabra ("word“)
ancho de fila = word-size líneas de palabras (solo
unas es activa – decoder
índice es dirección ("address“) se usa por eso)
dirección es input 1 1 1 1
palabra seleccionada es output
n
2 -1
i word[i] = 0011
ROM: organizacion interna decoder
j word[j] = 1010
0 n-1
Address
lineas de bits (normalmente subido a 1
a través de resistor – selectivamente
conectado a zero por los switches controlados
por las palabras)
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'
A B C F0 F1 F2 F3
0 0 0 0 0 1 0 ROM
0 0 1 1 1 1 0 8 words x 4 bits/word
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 A B C F0F1F2F3
1 1 1 0 1 0 0 address outputs
truth table block diagram
Estructura de ROM
Similar a PLA pero con un arreglo AND
completamente decodificado
Arreglo OR completamente flexible
n address lines
• • •
inputs
memory
decoder 2n word
array
n
(2 words
lines
by m bits)
outputs
• • •
m data lines
ROM vs. PLA
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
Estructuras lógicas: ROM, PAL, PLA
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)
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.1 Introducción
Decodificador
7.4 FPGAs
7.5 HDLs
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
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
7: Combinacionales
complementar, muchas de cuatro y hasta algunas de ocho
44
Ejemplo: celda basada en
tabla de búsqueda (LUT)
Esta celda es de 4 entradas y puede implementar cualquier función

de cuatro variables
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
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:
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.1 Introducción
Decodificador
7.4 FPGAs
7.5 HDLs
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
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
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
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
Modelo simple de comportamiento
Asignación continua

input a, b;
output out; registro de simulación –
reg out; contiene valor de senal
assign #6 out = a ^ b;
endmodule
retardo desde cambio en input
hasta cambio en output
Modelo simple de comportamiento
bloque always
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
Activando la simulación usando
un banco de prueba (testbench)
module testbench (x, y);
output x, y; vector de 2-bits
reg [1:0] cnt;
initial begin bloque inicial se ejecuta

una vez al inicio de la
cnt = 0;
simulación
repeat (4) begin
#10 cnt = cnt + 1;
$display ("@ time=%d, x=%b, y=%b, cnt=%b",
$time, x, y, cnt); end
#10 $finish;
imprimir a consola
end
assign x = cnt[1]; directiva de

assign y = cnt[0]; detener simulación
endmodule
Simulación completa
Instanciar componente de estimulo y
componente para probar circuito
a z
x
test-bench y
b
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
Modelo de comportamiento mas
complejo
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
HDL vs lenguajes de programación
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) 7: Combinacionales 59

7-Sistemas Combinacionales

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

7-Sistemas Combinacionales

Hochgeladen von

Copyright:

Verfügbare Formate

ELO211: Sistemas Digitales

Tomás Arredondo Vidal

 Transistores se integraron en compuertas (1960s)

 Hoy muy pocos de estas chips se utilizan

multiplexor demultiplexor switch 4x4

Sa MUX MUX Sb múltiples fuentes de input

Ss DEMUX múltiple destinos de output

 Multiplexores: concepto general

 2:1 mux: Z = A'I0 + AI1

 Decodificador/demultiplexor: concepto general

1:2 Decoder: 3:8 Decoder:

 Un decoder n:2n puede implementar cualquier función de n

 F1 = A'BC'D + A'B'CD + ABCD

 F4 = A' + B' + C' A'B'C'

 F5 = A xor B xor C A'B'C

una columna del arreglo OR

 Conversor de código BCD a Gray

 Mapear las funciones a un PLA:

 9 términos no caben en PLA de 7 términos

 Implementando lógica combinacional con un ROM

 puede implementar cualquiera función de n inputs

 PAL – plano AND programable, plano OR fijo

 puede implementar funciones con numero de términos

 PLA – planos AND y OR programmables

 Esta celda es de 8 entradas y una salida implementa:

 Esta celda es de 4 entradas y puede implementar cualquier función

module xor_gate (out, a, b);

inverter invA (abar, a);

module xor_gate (out, a, b);

always @(a or b) begin

endmodule especifica cuando se ejecuta el bloque

initial begin bloque inicial se ejecuta

assign x = cnt[1]; directiva de

module Compare1 (Equal, Alarger, Blarger, A, B);

assign #5 Equal = (A & B) | (~A & ~B);

always @(neighbors or self) begin

Das könnte Ihnen auch gefallen

Transistores se integraron en compuertas (1960s)

Hoy muy pocos de estas chips se utilizan

Multiplexores: concepto general

2:1 mux: Z = A'I0 + AI1

Decodificador/demultiplexor: concepto general

Un decoder n:2n puede implementar cualquier función de n

F1 = A'BC'D + A'B'CD + ABCD

F4 = A' + B' + C' A'B'C'

F5 = A xor B xor C A'B'C

Conversor de código BCD a Gray

Mapear las funciones a un PLA:

9 términos no caben en PLA de 7 términos

Implementando lógica combinacional con un ROM

puede implementar cualquiera función de n inputs

PAL – plano AND programable, plano OR fijo

puede implementar funciones con numero de términos

PLA – planos AND y OR programmables

Esta celda es de 8 entradas y una salida implementa:

Esta celda es de 4 entradas y puede implementar cualquier función