informe final trabajo de investigacion

UNIVERSIDAD NACIONAL DE PIURA
FACULTAD DE INGENIERIA INDUSTRIAL
INFORME FINAL
TRABAJO DE INVESTIGACION
“MODULO DE APOYO PARA EL CURSO ARQUITECTURA DE
COMPUTADORAS”
EJECUTORES
:
INGº JORGE L. SANDOVAL RIVERA
INGº PEDRO A. CRIOLLO GONZALES
PIURA, febrero del 2009
INDICE
pág
Resumen ............................................................................................................. i
Introducción ........................................................................................................ ii
Esquema del contenido
1. REPRESENTACION DE DATOS
1
1.1. Sistemas numéricos ................................................................................ 1
1.1.1. Decimal ........................................................................................ 2
1.1.2. Binario.......................................................................................... 2
1.1.3. Hexadecimal ................................................................................ 3
1.2. Representación de enteros ...................................................................... 4
1.2.1. Sin signo ...................................................................................... 4
1.2.2. Con signo ..................................................................................... 4
1.3. Representación de reales ....................................................................... 6
1.3.1. Con punto fijo ............................................................................... 6
1.3.2. Con punto flotante ........................................................................ 7
1.4. Otros códigos.......................................................................................... 9
Ejercicios resueltos ...................................................................................... 11
Ejercicios propuestos ................................................................................... 13
2. CIRCUITOS DE LOGICA DIGITAL ............................................................. 14
2.1. Compuertas lógicas ............................................................................... 14
2.2. Álgebra booleana .................................................................................. 14
2.3. Minterminos y Maxterminos .................................................................. 16
2.4. Simplificación por álgebra booleana ..................................................... 17
2.5. Simplificación por mapa de Karnaugh ................................................... 20
2.6. Circuitos lógicos combinacionales ........................................................ 23
2.6.1. Semisumador ............................................................................. 24
2.6.2. Sumador completo ..................................................................... 24
2.6.3. Sumador restador ...................................................................... 25
2.7. Flip-Flops .............................................................................................. 27
2.7.1. Flip-Flop básico con compuertas NAND y NOR ......................... 27
2.7.2. Flip-Flop SR sincronizado por reloj ............................................ 29
2.7.3. Flip-Flop D sincronizado por reloj ............................................... 29
2.7.4. Flip-Flop JK sincronizado por reloj ............................................. 29
2.7.5. Flip-Flop T sincronizado por reloj ............................................... 29
2.8. Circuitos lógicos secuenciales .............................................................. 30
2.8.1. Ecuaciones de entrada de los Flip-flops ..................................... 30
2.9. Solución de ejercicios con Boole........................................................... 34
2.9.1. Circuitos combinacionales.......................................................... 34
2.9.2. circuitos secuenciales ................................................................ 37
2.10. Simulación de circuitos con Electronics WorkBench .......................... 40
Ejercicios resueltos ...................................................................................... 45
Ejercicios propuestos ................................................................................... 50
3. COMPONENTES DIGITALES .................................................................... 51
3.1. Registros ............................................................................................... 51
3.1.1. Registro simple .......................................................................... 51
3.1.2. Registro de carga paralela ......................................................... 52
3.1.3. Registro de corrimiento .............................................................. 53
3.1.4. Registro de corrimiento con carga paralela ................................ 53
3.2. Contadores ............................................................................................ 54
3.2.1. Contadores asíncronos o de propagación .................................. 54
3.2.2. Contadores sincrónicos .............................................................. 55
3.3. Decodificadores - Codificadores ............................................................ 56
3.3.1. Decodificadores ......................................................................... 56
3.3.2. Codificadores ............................................................................. 57
3.4. Multiplexores y Demultiplexores ............................................................ 59
3.4.1. Multiplexores .............................................................................. 59
3.4.2. Demultiplexores ......................................................................... 61
Ejercicios resueltos ..................................................................................... 62
Ejercicios propuestos .................................................................................. 69
4. ORGANIZACIÓN Y DISEÑO BASICO DE COMPUTADORAS ................... 70
4.1. ¿Qué es una computadora? ............................................................... 70
4.1.1. Organización básica................................................................... 70
4.1.2. Funcionamiento ......................................................................... 70
4.2. Los registros ....................................................................................... 71
4.2.1. Los registros de la computadora básica ..................................... 71
4.3. El BUS común .................................................................................... 75
4.4. Transferencia entre el BUS, los registros y la memoria....................... 76
4.5. El código de instrucción ...................................................................... 78
4.5.1. Instrucciones que hacen referencia a memoria .......................... 78
4.5.2. Instrucciones que hacen referencia a registro ............................ 80
4.5.3. Instrucciones de entrada y salida ............................................... 81
4.6. La unidad de control ........................................................................... 82
4.7. Ciclo de instrucción ............................................................................. 83
4.7.1. Búsqueda ................................................................................... 83
4.7.2. Decodificación............................................................................ 84
4.7.3. Tipo de instrucción ..................................................................... 85
4.7.4. Ejecutar instrucción .................................................................... 85
4.7.5. Interrupciones ............................................................................ 90
4.8. La ALU ............................................................................................... 93
4.9. Diseño lógico de la computadora básica ............................................. 95
4.10. Diseño físico de la computadora básica .............................................. 98
4.10.1. Los flip-flops de apoyo ..............................................................100
4.10.2. El acumulador ...........................................................................103
Ejercicios resueltos ....................................................................................105
Ejercicios propuestos .................................................................................109
Bibliografía .......................................................................................................110
RESUMEN
Es común en los docentes universitarios, al preparar sus clases, tomar 2 o más libros
texto y hacer un resumen con cada uno de ellos que luego usará para impartir su
clase. Justamente es lo que pretende realizar el presente trabajo, tomando como base
el libro “Arquitectura de Computadoras” de MORRIS MANO M. y otros textos como por
ejemplo “Sistemas Digitales, Principios y Aplicaciones” de TOCCI, Ronald y “Diseño
Digital Principios y Practicas” de WAKERLY, John F. seleccionar lo mejor de cada uno
de ellos y hacer un resumen, explicando con mayor detalle las áreas que lo requieran
o se consideren necesarias, resolviendo algunos ejercicios y planteando otros.
El módulo se divide en cuatro capitulos:
El primer capitulo “Representación de datos” trata de la forma como se almacenan y
representa los datos numérico (reales, enteros: positivos y negativos) en un sistema
digital. Además se estudian los 3 sistemas de numeración más importantes: el binario,
el decimal y el hexadecimal
El segundo capitulo “Circuitos de lógica digital” estudia los circuitos diseñados a partir
de compuertas lógicas y su representación por medio de expresiones lógicas, estos
son: Circuitos combinatorios y circuitos secuenciales. Haciendo uso del álgebra
booleana y de mapas de Karnaugh se realiza la simplificación de estos circuitos de
forma manual, pero también se explica como usar herramientas de software como el
“WorkBench” para el diseño y simulación de circuitos y “Boole” para el análisis y
simplificación de circuitos combinatorios y secuenciales
El tercer capitulo “Componentes digitales” estudia el diseño de los componentes que
se pueden construir a partir de los circuitos combinatorios y secuenciales estudiados
en el capitulo anterior tales como: sumadores, contadores, registros, multiplexores,
codificadores, etc.
El cuarto capitulo “Organización y diseño básico de computadoras” describe la
estructura de la computadora básica como por ejemplo el tamaño de la memoria,
cantidad y longitud de los registros, instrucciones que serán reconocidas, etc. También
se estudia el diseño de circuitos que permitan generar las señales apropiadas entre los
componentes digitales mencionados para que éstos realicen las tareas para lo que
fueron diseñados
INTRODUCCION
En la ciencia, la tecnología, la administración y, de hecho, muchos otros campos de la
actividad humana, constantemente se manejan cantidades. Estas se miden, registran,
manipulan aritméticamente, observan o se utilizan en muchos sistemas físicos. Existen
básicamente dos maneras de representar el valor numérico de las cantidades: la
analógica y la digital.
Las cantidades analógicas tienen la característica de poder variar gradualmente sobre
un intervalo continuo de valores como en el caso de un velocímetro. La posición
angular de la aguja representa el valor de la velocidad del automóvil y sigue cualquier
cambio que ocurra conforme el automóvil acelere o frene. Mientras que las cantidades
digitales varían en etapas discretas (paso a paso), como por ejemplo un reloj digital, el
cual no cambia continuamente sino por etapas (uno por minuto o por segundo) a pesar
que el tiempo transcurre en forma continúa.
Para manipular la información representada en forma digital se utilizan los sistemas
digitales. Un sistema digital es una combinación de dispositivos diseñado para
manipular información representada en forma digital, es decir, que sólo puede tomar
valores discretos. Esta información digital por lo general se representa en forma
binaria y ésta, a su vez, por medio de cualquier dispositivo que solamente tenga dos
estados de operación como por ejemplo un interruptor: abierto y cerrado.
Esta característica de los circuitos digitales (lógicos) permite utilizar el álgebra
booleana como herramienta para el análisis y diseño de sistemas digitales. El álgebra
booleana tiene tres operaciones básicas AND, OR y NOT llamadas también
operaciones lógicas. Mediante diodos, transistores y resistencias, conectados entre sí,
se puede construir compuertas lógicas cuyas salidas son el resultado de una
operación lógica básica.
Partiendo de las compuertas lógicas AND, OR y NOT, se pueden diseñar circuitos
cuyas salidas depende sólo de sus entradas (circuitos combinatorios) y circuitos cuyas
salidas dependen tanto de las entradas como del estado (conjunto de entradas
pasadas) que se encuentre el circuito (circuitos secuenciales).
Ejemplo de circuitos combinatorios tenemos los sumadores completos de un bit, los
cuales agrupados en 8, 16 o 32 elementos se obtienen sumadores de 8, 16 o 32 bits.
De igual manera se puede diseñar restadores, multiplicadores, divisores, etc. Todos
estos circuitos unidos apropiadamente permitirán diseñar, por ejemplo, una Unidad
Aritmética Lógica (ALU), que es una de las partes básicas de un procesador. Así
también el diseño de codificadores, decodificadores y multiplexores que permiten
conmutar las señales digitales entre los diferentes componentes de una computadora
con el procesador.
Por otro lado, uniendo adecuadamente compuertas NAND o NOR se puede formar un
FLIP-FLOP que es la unidad básica de almacenamiento. Uniendo Flip-Flops y circuitos
combinatorios se puede diseñar registros, contadores, unidad de memoria y otros
componentes de apoyo del procesador.
Para finalizar, todos los componentes mencionados unidos mediante circuitos lógicos,
los cuales les proveeran de las señlales de control apropiadas para que éstos
tranfieran y procesen la información, ya sea un codigo de instrucción o un dato.
I REPRESENTACION DE DATOS
1.1. Sistemas numéricos
Si bien es cierto que una computadora puede realizar una serie de tareas
complejas, la verdad es que lo único que “comprende” es 0 y 1. Estos 0 y 1
agrupados adecuadamente (bajo un formato) pueden representar diferentes tipos
de información binaria para el procesador tales como datos, código ejecutable,
caracteres, señales de control, etc. Como resulta obvio pensar, el sistema de
numeración que puede traducir directamente la computadora es el BINARIO, pero
éste resulta muy difícil de comprender y manipular por los seres humanos ya que
la mayoría estamos acostumbrados a usar el sistema de numeración DECIMAL.
Otro de los inconvenientes de trabajar con el sistema binario es la documentación,
ya que para expresar cualquier número en binario se necesitará mucho más
espacio que si se utilizara, por ejemplo, el sistema decimal o, mejor aun, el sistema
HEXADECIMAL.
Estos tres tipos de sistemas de numeración pertenecen a los sistemas numéricos de
base o raíz r (r=2 para binario, r=10 para decimal y r=16 para hexadecimal),
también se les conoce como sistemas posicionales debido a que cada digito tiene
un valor basado en su posición relativo al digito menos significativo (el que se
encuentra más a la derecha).
Para determinar el valor que representa un número de base r en el sistema decimal
se puede utilizar la siguiente formula:
N=
e -1
åd *r
i= - f
Donde:
i
i
r es la base o raíz del número
di es un dígito de la posición i del número
f es la cantidad de dígitos de la parte fraccionaria
e es la cantidad de dígitos de la parte entera
En términos generales, cualquier número es simplemente la suma de los productos
de cada digito y su valor posicional.
Ejemplo: Cuál es el valor de 31.2041(5 en el sistema decimal?
Como se aprecia r=5, f=4 y e=2. El número sería: d1 d0 . d-1 d-2 d-3 d-4
y el valor en decimal:
N = 3*51 + 1*50 + 2*5-1 + 0*5-2 + 4*5-3 + 1*5-4
N = 3*5 + 1*1 + 2/5 + 0/25 + 4/125 + 1/625
N = 15 + 1 + 0.4 + 0 + 0.032 + 0,0016
N = 16.4336
Ahora, para convertir un numero del sistema decimal al sistema de base r, primero
se toma la parte entera y se divide entre la raíz r, el residuo de esta división se
convertirá en el digito menos significativo de la parte entera. Luego se divide el
cociente resultado de la división anterior entre la raíz r, el residuo será el siguiente
digito, se vuelve a dividir el último cociente entre la raíz r y así sucesivamente se
repite esta operación hasta que el cociente sea 0. El número se formará tomando el
1
último residuo como el digito más significativo y el primer residuo obtenido como
el digito menos significativo.
Para convertir la parte fraccionaria, se coge sólo la parte fraccionaria (tomando
cero como parte entera) y se multiplica por la raíz r. La parte entera del resultado
de la multiplicación será el primer digito de la nueva parte fraccionaria. Luego se
elimina la parte entera (se hace 0) y se repite la operación anterior tantas veces
como dígitos se desea obtener. Si en algún momento el resultado de la
multiplicación es 1 significará que se ha obtenido el valor exacto en el sistema de
base r, en caso contrario, todos los dígitos obtenidos hasta ese instante sólo son
una aproximación al valor real.
Ejemplo: Convertir 82.573 al sistema de base 7
Tomamos la parte entera 82 y la dividimos entre la raíz r=7
82/7
cociente 11, residuo 5 (digito menos significativo)
Dividimos el ultimo cociente entre la raíz
11/7
cociente 1, residuo 4
1/7
cociente 0, residuo 1 (digito más significativo)
Por lo tanto la parte entera será: 145
Ahora tomamos la parte fraccionaria 0.573 y la multiplicamos por la raíz
0.573*7 = 4.011
4 será el 1er digito, luego eliminamos la parte entera.
0.011*7 = 0.077
0 será el 2do digito.
0.077*7 = 0.539
0 será el 3er digito.
0.539*7 = 3.773
3 será el 4to digito, eliminar la parte entera.
0.773*7 = 5.411
5 será el 5to digito y así sucesivamente…
Una aproximación a 82.573 es 145.40035(7
1.1.1. Decimal
La base 10 es importante debido a que se usa en la vida diaria. Este sistema
se compone de 10 numerales o símbolos: 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9; al
utilizar estos símbolos como dígitos de un numero podemos expresar
cualquier cantidad. El sistema decimal evolucionó en forma natural a partir
del hecho de que el ser humano tiene 10 dedos. Incluso, la palabra “digito”
significa “dedo” en latín.
En el sistema digital se comienza a contar con el 0 en la posición de las
unidades y se toma cada símbolo (digito) en progresión hasta llegar al 9,
luego se incrementa en 1 la segunda posición (decenas) y volvemos a
empezar con 0 en las unidades. Este proceso continúa hasta llegar a 99 y se
suma 1 en la tercera posición (centenas) y se empieza con 0 en las 2
posiciones anteriores. Se repite este proceso mientras se desee.
1.1.2. Binario
En el sistema binario sólo hay 2 símbolos o valores de dígitos: 0 y 1. Sin
embargo, con un conjunto de estos símbolos se puede representar cualquier
cantidad denotada en cualquier sistema de numeración.
Al trabajar con números binarios, generalmente se está restringido a
utilizar una cantidad específica de dígitos (bits). Esta restricción se basa en
los circuitos utilizados para representar estos números binarios.
2
Al tener, este sistema sólo los dígitos 0 y 1, cualquier número que se desee
representar se debe de hacer con una combinación de éstos.
El conteo en binario inicia con 0, al sumarle 1 (0+1) nos dará 1. Si luego le
sumamos 1 (1 + 1) nos dará 0 (porque no existe el digito 2) más 1 de
acarreo es decir 10 en total, que es la representación de 2. Nuevamente
sumamos 1 (10 + 1) resultará 11 (representación de 3) y al sumarle 1
(11+1) nos dará 100 (4 en binario) y así sucesivamente.
Numeración del 0 al 15 en decimal, binario y binario con 4 bits
Dec
0
1
2
3
4
5
6
7
Bin
0
1
10
11
100
101
110
111
Bin 4 bits
0000
0001
0010
0011
0100
0101
0110
0111
Dec
8
9
10
11
12
13
14
15
Bin
1000
1001
1010
1011
1100
1101
1110
1111
Bin 4 bits
1000
1001
1010
1011
1100
1101
1110
1111
Como se aprecia, el conteo empieza con 0 en las unidades luego se
incrementa en 1 y después en 1 más, pero como no existe el digito 2 en
binario, para representar éste, se suma en 1 el siguiente digito obteniendo 2
en binario (10). Se incrementa en uno las unidades y se repite esto hasta
que todos los dígitos son 1s.
Las cantidades binarias pueden representarse por medio de cualquier
dispositivo que solamente tenga dos estados de operación o posibles
condiciones. Por ejemplo, un interruptor sólo tiene dos estados: abierto o
cerrado. Arbitrariamente podemos hacer que un interruptor abierto
represente el 0 binario y que uno cerrado represente el 1 binario. Una hoja
con perforaciones sería otro ejemplo, donde una perforación será un 1
binario y la ausencia de ella es un 0 binario. Así, podemos seguir
mencionando otros ejemplos como un foco eléctrico (encendido-apagado),
una fotocelda (iluminada u oscura), el transistor (cortado o saturado), una
cinta magnética (magnetizada o desmagnetizada), etc.
En los sistemas electrónicos digitales, la representación binaria se hace por
medio de voltajes (o corrientes) que están presentes en las entradas o
salidas de los diversos circuitos. Por lo general, el 0 y el 1 binarios se
representan con dos niveles de voltaje nominal, 0V para representar el 0
binario y +5V para el 1 binario, aunque para ser más exactos esta
representación se hace por medio de intervalos de voltaje: el intervalo entre
0 y 0.8V representa un 0 y cualquiera entre 2 y 5V representa un 1
1.1.3. Hexadecimal
Este sistema de numeración está conformado por los 10 dígitos del sistema
decimal (0-9) y 6 dígitos más, como por ejemplo el DIGITO DIEZ (10) o
el DIGITO TRECE (13), pero para evitar confusiones cuando se
3
presenten los dígitos 1 y 0 o 3 juntos, se ha convenido representarlos por
las letra A y D respectivamente. Entonces, A=10, B=11, C=12, D=13,
E=14 y F=15. Este sistema proporciona representaciones breves que son
convenientes para números con múltiples bits en un sistema digital.
Ejemplo: La representación del entero 23830 en binario de 16 bits es
0101110100010110, es decir que se necesitan 16 dígitos,
mientras que en hexadecimal es 5D16 (5D16h) siendo
necesario sólo 4 dígitos. Debido a que su base es potencia de 2
(16=24) 4 dígitos binarios pueden representarse con un solo
digito hexadecimal, tal como se aprecia a continuación.
0101 1101 0001 0110 Dígitos Binarios
5
D
1
6
Dígitos Hexadecimales
1.2. Representación de enteros
Un detalle muy importante en la representación de enteros es la cantidad de bits
que se van a emplear, ya que de ello va a depender el rango de valores que se
pueden representar.
Ejemplo: Un número de 4 bits implicará que se tiene 4 dígitos binarios y como
cada uno de ellos puede tomar el valor de 0 o 1 significará que se
pueden formar 24 combinaciones diferentes y que cada una de ellas
puede representar un valor. Por lo tanto, con 4 bits se puede representar
16 valores diferentes que podrían estar comprendidos (rango) entre 0 y
15 o entre -8 y 7 o cualquier convención que se establezca.
1.2.1. Sin signo
En este tipo de notación sólo se van a representar enteros positivos (sin
signo). El menor valor a representar será el 0 y el mayor valor dependerá
de la cantidad de bits a emplear. Si N es la cantidad de bits a emplear, 2N-1
será el mayor valor que se podrá denotar, así por ejemplo, con 4 bits el
mayor valor será 15 (24=16); con 8 bits, 255 (28=256) y con 16 bits hasta
65535 (216=65536). En todos los casos, el valor es uno menos debido a que
se tiene en cuenta el 0 como primer valor a representar.
Ejemplo: Para representar el entero 1837 se necesitan por lo menos 11
bits, ya que este entero en binario es 11100101101. La
representación de este valor en un formato de 16 bits será
0000011100101101 y en forma abreviada (hexadecimal) será
072Dh.
1.2.2. Con signo
Aquí se tiene en cuenta los valores negativos y por ende, que la cantidad a
representar de valores positivos sea igual a la cantidad de valores
negativos.
Los dos sistemas más usados para representar un número con signo son:
4
a) Bit de signo.- Se utiliza el bit más significativo (el que se encuentra
más a la izquierda) para representar el signo del número: 0 para indicar
que el número es positivo y 1 para indicar que es negativo. Esto trae
como consecuencia que, si se utiliza N bits para representar el número
sólo se podrán emplear N-1 bits (2N-1 valores diferentes) ya que 1 bit se
usará para el signo y por lo tanto el rango de valores a representar
disminuirá a la mitad: una mitad será para representar valores positivos
y la otra mitad los valores negativos.
Ejemplo: El entero -1837 en 16 bits será igual que +1837 pero
estableciendo en 1 el bit más significativo es decir:
1000011100101101 y en forma abreviada 872Dh.
Con 16 bits se podrá denotar desde -32767 a +32767 (216-11) es decir desde 1111111111111111 = FFFFh a
0111111111111111 = 7FFFh.
Una de las desventajas de este sistema es la doble representación del 0,
ya que se puede denotar como 000...0 (+0) y como 100…0 (-0).
Además, no permite realizar las operaciones aritméticas directamente.
Ejemplo: Restar 86 y 24 en 8 bits
86 = 01010110 y 24=00011000 → -24=10011000, luego
86+
=
01010110+
-24
=
10011000
-------------------------------62
≠
11101110
=
-110
Como se aprecia el resultado es -110 cuando debió ser 62.
En la actualidad este sistema se emplea únicamente para la
codificación de números con punto flotante.
b) Complemento a 2.- El complemento a r de un numero N de un sistema
de base r es rn-N, donde n es la cantidad de dígitos de N y el
complemento a (r-1) es (rn-1)-N.
Ejemplo: Hallar el complemento a 10 de 392
103-392=608
Ejemplo: Hallar el complemento a 9 de 392
103-1-392=607
Es decir, que el complemento a r de N es igual al complemento a (r-1)
de N, más 1.
Ahora si a un número X le restamos Y entonces:
X-Y = X-Y+rn-rn = X+(rn–Y)-rn = X+CY(r)-rn
Donde CY(r) es el complemento a r de Y.
5
Ejemplo: Hallar 627-392 (en el sistema decimal)
Como se observa, r=10 y n=3, entonces:
627-392= 627+608-103 = 1235-1000 = 235.
El restarle 103 es equivalente a simplemente eliminar el
digito más significativo al resultado (por desbordamiento)
En el sistema binario, X-Y = X+CY(2)-2n y como CN(r)= CN(r-1)+1,
entonces: X-Y = X+(CY(1)+1)-2n. Donde CY(1) es el complemento a 1
de Y, pero el complemento a 1 de un numero en binario es
simplemente el cambio de 0s por 1s y 1s por 0s. Por lo tanto, en
binario, la diferencia de X y Y se puede resumir en: Sumar a X, Y
complementado, es decir, convertir los 1s en 0s y los 0s en 1s, luego
sumarle 1 y finalmente eliminar el digito más significativo.
Ejemplo: Restar 179-62 (r=2 , n=8 bits)
179=10110011
62=00111110
-62=11000001+1=11000010
Luego: 179 = 10110011 +
-62 = 11000010
----------------------117 101110101 pero al eliminar el bits más
significativo queda 01110101 = 117
1.3. Representación de reales
Para poder representar números con parte fraccionaria se deben tener en cuenta
tres cosas: como representar la parte entera, la parte decimal y el punto decimal.
Existen dos notaciones:
1.3.1. Con punto fijo
En esta notación se establece una determinada cantidad de bits para la
parte entera y otra para la parte fraccionaria. El punto quedará
arbitrariamente fijado entre estos bits. Por ejemplo el número 3.641 en
binario es aproximadamente 11.101001000001, si el formato que se va a
usar es de 8 bits y el punto se fija en la mitad, entonces la representación
sería: 00111010 (3Ah), donde los dígitos en negrita son la parte entera. Si
para representar este mismo número se fijara el punto decimal después de
los 2 bits más significativos la representación sería: 11101001 (E9h).
Como se comprenderá, al observar los números 3Ah y E9h (o en binario)
no hay forma de determinar la posición del punto decimal a no ser que
previamente se haya establecido o acordado esta. Por lo general la posición
del punto se establece durante el diseño del hardware y queda fijo a ella. El
inconveniente de esta notación es que la precisión queda fija, por ejemplo
en el primer caso solo se tienen 4 bits para representar la parte fraccionaria,
mientras que en el segundo caso se tienen 6 bits, con lo que se obtiene
mayor precisión (3Ah=0011.1010=3.625 ; E9h=11.101001=3.640625). Por
otro lado, si la parte entera en el número a representar fuera mayor o igual
que 4 este no podría ser denotado usando la fijación del punto decimal del
segundo caso porque se necesitaría más de 2 bits para representar estos
6
valores. Por lo tanto, al permanecer el punto fijo, en algunos casos se
necesitaran más bits en la parte fraccionaria (correr el punto hacia la
izquierda) y en otros en la parte entera (correr el punto hacia la derecha).
1.3.2. Con punto flotante
El inconveniente del punto fijo es resuelto con un punto flotante, es decir,
un punto que pueda ser corrido hacia la izquierda o hacia la derecha según
sea necesario.
El proceso se inicia convirtiendo el número al sistema de numeración
binario y luego se normaliza. La normalización consiste en correr el punto
hacia la izquierda o hacia la derecha de tal forma que el 1 que se encuentre
más hacia la izquierda quede posicionado a la izquierda del punto. El valor
resultante se multiplica por 2N donde N es la cantidad de posiciones que se
ha corrido el punto. N es positivo si el punto se corre hacia la derecha y
negativo en caso contrario.
Ejemplo: Convertir 37.4592 al formato de punto flotante de 32 bits.
Primero hay que convertirlo a binario. Utilizar el método de
multiplicaciones sucesivas por 2, para convertir la parte
decimal, es muy largo y tedioso, así que usaremos
multiplicaciones por 16 y lo que obtendremos son los dígitos en
hexadecimal, los cuales son sencillos de pasar a binario.
37 en binario es 100101, ahora vamos a la parte decimal
0.4592*16 = 7.3472
0.3472*16 = 5.5552
0.5552*16 = 8.8832
0.8832*16 = 14.1312
0.1312*16 = 2.0992
0.0992*16 = 1.5872
0.5872*16 = 9.3952
0.3952*16 = 6.3232
0.3232*16 = 5,1712
0.1712*16 = 2.7392
0.7392*16 = 11.8272
0.8272*16 = 13.2352
0.2352*16 = 3,7632
è
è
è
è
è
è
è
è
è
è
è
è
è
7
5
8
E
2
1
9
6
5
2
B
D
3
è
è
è
è
è
è
è
è
è
è
è
è
è
0111
0101
1000
1110
0010
0001
1001
0110
0101
0010
1011
1101
0011
El número en binario será:
100101.0111010110001110001000011001011001010010101111010011
y normalizado:
1.00101011101011000111000100001100101100101001010111101 x 25
El formato para representar números con parte fraccionaria esta
conformado por 1 bit S para el signo y el resto de bits se distribuye entre
la característica C y la mantisa M. La característica es la representación del
exponente E en exceso a 2N-1-1, donde N es la cantidad de bits que tiene la
característica.
NUM = (-1)S * 1.M * 2E
donde E = C-2N-1+1
7
Existen dos formatos básicos:
a) Formato de precisión simple (32 bits), que consta de:
· 1 bit para el signo (S)
· 8 bits para la característica (C) y
· 23 bits para la mantisa (M)
La secuencia de bits del número será la siguiente:
S = 0, debido a que el número es positivo.
C = E+2N-1-1 = 5+28-1-1 = 5+128-1 = 132 = 10000100(2
M = 00101011101011000111000 que son los 23 dígitos que se
encuentran a la derecha del punto del numero normalizado.
Por lo tanto, la representación del valor más próximo a 37.4592 en 32
bits es: 0100 0010 0001 0101 1101 0110 0011 1000 = 4215D638h.
Para hallar su valor en decimal, se toma el número normalizado pero
sólo con los 23 dígitos a la derecha del punto (mantisa) y se corre el
punto hacia la derecha para convertirlo en entero, esto significa que el
punto tendrá que desplazarse 23 posiciones a la derecha y por ende
tendrá que restarse esta cantidad al exponente. Luego el entero se pasa
a decimal y se divide entre 2 elevado al nuevo exponente:
1.00101011101011000111000 x 25 , convertido a entero queda:
1001 0101 1101 0110 0011 1000 x 25-23
95D638h x 2-18= 9819704 x 2-18 = 9819704 / 218
9819704 / 262144 = 37,459197998046875
b) Formato de precisión doble (64 bits)
· 1 bit para signo (S)
· 11 bits para la característica (C)
· 52 bits para la mantisa (M)
La secuencia de bits del número será el siguiente:
S = 0, debido a que el número es positivo.
C = E+2N-1-1 = 5+211-1-1 = 5+1024-1 = 1028 = 10000000100(b
M = 1010101110101100011100010000110010110001010111101001
que son los 52 dígitos a la derecha del punto
La representación del valor más próximo a 37.4592 en 64 bits es:
404ABAC710CB295Eh (muy extenso para representarlo en binario)
Su valor en decimal es:
1.0010101110101100011100010000110010110010100101011110 x 25
10010101110101100011100010000110010110010100101011110 x 2-47
12BAC710CB295Eh x 2-47 = 5271913723799902 x 2-47
5271913723799902 / 247 = 5271913723799902 / 140737488355328
37.459199999999995611688063945621 (mayor precisión)
8
Una vez obtenida las respectivas representaciones de los valores con parte
fraccionaria, hay que evaluar el ERROR de precisión. Hay 2 tipos de error:
por DEFECTO y por EXCESO. El primero se da cuando la representación
obtenida es menor que el valor real y la segunda cuando es mayor,
obviamente se deberá elegir aquella que tenga menor error.
En el caso del formato de 32 bits, podemos apreciar que el digito 24 del
numero normalizado (después del punto) es 1 por lo que procedemos a
redondear (aumentar en 1 la mantisa) lo cual nos dará 95D639h x 2-18 =
37,459201812744140625. Esta representación, aunque genera un error por
exceso, es la más cercana al valor real.
Con el formato de 64 bits ocurre algo semejante. El bit 53 del numero
normalizado también es 1, por lo que se procede a redondear con lo que se
obtiene 12BAC710CB295Fh x 2-47 = 37,45920000000000271711 que
como se aprecia es bastante próximo a 34.4592.
1.4. Otros códigos
En ocasiones, se utilizan otros códigos binarios para números decimales y
caracteres alfanuméricos. Las computadoras digitales también emplean otros
códigos binarios para aplicaciones especiales. Veamos algunos de ellos:
1.5.1. Código Gray
Es la representación de un conjunto de valores de tal manera que los
dígitos que lo conforman (binario) cambia sólo uno de ellos conforme
avanza de un valor al siguiente. Por ejemplo, 3 en binario de cuatro bits es
0011 y 4 es 0100 como se aprecia, para pasar de 3 a 4, tres bits cambian su
estado, lo cual podría producir uno o más estados intermedios, si los tres
bits no cambiasen simultáneamente, esto no ocurre en código Gray.
Para formar una tabla de números en código Gray de N bits se debe seguir
las siguientes reglas:
a) Un código Gray de 1 bit tiene dos palabras código: 0 y 1.
b) Las primeros 2N palabras de N+1 bits son iguales a las palabras de N
bits precedidas por un 0.
c) Las ultimas 2N palabras de N+1 bits son iguales a las palabras de N bits
escritas en orden inverso y precedidas por un 1.
Ejemplo:
N=1
0
1
N=2
00
01
--11
10
N=3
000
001
011
010
----110
111
101
100
9
Para convertir binario a Gray se deben seguir los siguientes pasos:
a) Los bits de un código Gray de N bits se numeran de derecha a
izquierda de 0 a N-1.
b) El bit i es 0 si el bit i e i+1 de la palabra en binario son iguales y 1 en
caso contrario.
Ejemplo: Convertir 1011 a código Gray
Como el bit 0 y 1 son iguales, el bit 0 será: 0
Como el bit 1 y 2 son diferentes, el bit 1 será: 1
Como el bit 2 y 3 son diferentes, el bit 2 será: 1
Como el bit 3 y 4 (se asume 0) son diferentes, el bit 3 será: 1
Por lo tanto 1011 en código Gray es 1110
1.5.2. BCD
Decimal codificado en binario, pertenece a los sistemas de numeración no
posicionales y utiliza una asignación directa del equivalente binario del
digito decimal. Cada digito decimal se codifica por 4 dígitos binarios, pero
como con 4 bits se pueden representar hasta 16 valores, las 6 últimas
combinaciones (después del 9) que no se usan no tienen ningún valor
cuando se utiliza BCD.
Ejemplo: Codificar 5 en BCD = 0101 (igual que en binario)
Ejemplo: Codificar 173 en BCD
1 = 0001, 7=0111 y 3=0011
Por lo tanto 175 en BCD será: 000101110101
1.5.3. ASCII
Muchas aplicaciones requieren el manejo de datos que no solo están
formados por números sino también por letras del alfabeto y por ciertos
caracteres especiales. Un conjunto de caracteres alfanuméricos incluye los
10 dígitos decimales, las 26 letras del alfabeto y otros caracteres como $,
+, -, etc. Por lo que se necesitan 6 bits para codificarlos. Pero si además se
incluyen letras mayúsculas o minúsculas entonces se necesitarían 7 bits,
con lo que se puede codificar hasta 128 caracteres. Este conjunto de
códigos ha sido estandarizado y tiene el nombre de ASCII (Código
estándar americano para intercambio de información) y en la actualidad ha
sido extendido a 8 bits, es decir, 256 caracteres.
10
1.5. Ejercicios
1.5.1. Resueltos
a) Cual es el menor entero negativo y el mayor entero positivo que se
puede almacenar en un formato de 10 bits donde también se
representarán números negativos usando complemento a 2
El menor entero positivo será: -210-1 = -29 = -512
El mayor entero positivo será: 210-1-1 = 29-1 = 511
b) Convertir 8503 a base 13
8503/13
cociente 654, residuo 1 (digito menos significativo)
654/13
cociente 50, residuo 4
50/13
cociente 3, residuo 11
3/13
cociente 0, residuo 3 (digito más significativo)
Por lo tanto 8503 en base 13 será: 3B41
c) Convertir 46.483 a base 16
Primero la parte entera
46/16
cociente 2, residuo 14 = E
2/16
cociente 0, residuo 2 = 2
46 en base 16 es 2E
Ahora la parte fraccionaria
0.483*16 = 7.728
è
7
è
0.728*16 = 11.648
è
11
è
0.648*16 = 10.368
è
10
è
0.368*16 = 5.888
è
5
è
0.888*16 = 14.208
è
14
è
Una aproximación a 46.483 es 2E.7BA5E(16
7
B
A
5
E
d) Si el resultado anterior se almacena en una variable del tipo real de
precisión simple (32 bits) ¿Cuál es la secuencia de bits en este
formato?
46.483=2E.7BA5(16=101110.01111011101001011110
Normalizado: 1.0111001111011101001011110 x 25
Por lo tanto:
S = 0 (por ser positivo)
C = E+2N-1-1 = 5+27-1 = 132 = 10000100(2 (N= bits de la caracter.=8)
M = 01110011110111010010111 (sólo 23 bits), pero como el bit 24 es
1, hay que redondear a 01110011110111010011000 (+1)
Uniendo todos los bits: 01000010001110011110111010011000
Abreviado: 4239E98h
e) ¿Cual es el valor real almacenado en la variable del ejercicio anterior?
El número anterior normalizado a 23 bits y redondeado es:
1.01110011110111010011000 x 25
Convertido a entero:
101110011110111010011000 x 25-23
Convertido a hexadecimal
B9EE98 x 2-18
Convertido a decimal
12185240 x 2-18 = 46,483001708984375
11
f) Si A, B y C son variables enteras sin signo de 8 bits que contienen los
valores 203, 151 y 0 respectivamente. Determine el valor de C luego de
hacer la siguiente operación C=A+B
A = 203 = 11001011 +
B = 151 = 10010111
---------------------354 = 101100010
Como se observa el resultado es 354, pero se necesitan 9 bits para
poder representarlo y la variable C solo tiene 8 bits, por lo que sólo se
tomarán los 8 bits menos significativos (el bits más significativo se
desborda). Por lo tanto C = 01100010 = 98
g) Si A, B y C son variables enteras con signo de 16 bits que contienen
los valores 28391, 15016 y 0 respectivamente. Determine el valor de C
luego de hacer la siguiente operación C=A+B
A = 28391 = 0110111011100111 +
B = 15016 = 0011101010101000
-------------------------------------43407 = 1010100110001111
Aparentemente el resultado es 43407 (incluso no hay desbordamiento),
pero al ser C una variable entera con signo y como el bit más
significativo del resultado es 1 inmediatamente nos lleva a pensar que
el resultado es negativo, por lo que procedemos a hallar su
complemento a 2 para determinar su verdadero valor.
C = 1010100110001111
0101011001110000 (0s a 1s y 1s a 0s)
1 (sumamos 1)
-------------------------0101011001110001 = 22129
Pero como se ha complementado, entonces: C = -22129. Aunque
parezca increíble, el sumar dos números positivos puede dar como
resultado un número negativo.
h) Convertir a código Gray 158 (8 bits)
Primero convertimos 158 a binario de 8 bits esto es: 10011110
Analizando los bits de derecha a izquierda tenemos:
0 1 0 0 1 1 1 1 0
1 1 0 1 0 0 0 1
158 en codigo Gray es 11010001 = 209
i) Codifique en binario 2837 (BCD)
2=0010, 8=1000, 3=0011 y 7=0111
2837 en BCD es 0010100000110111
12
1.5.2. Propuestos
a) Cual es el menor entero negativo y el mayor entero positivo que se
puede almacenar en un formato de enteros con signo de 8 bits.
b) Se desea representar sólo enteros positivos con 12 bits, ¿Cuál es el
mayor entero que se puede representar?
c) Convertir 97058 a base 7.
d) Convertir 23.81 a base 12
e) Determine la secuencia de bits para la representación de -7903.37 en
un formato de 32 bits.
f) Determine el verdadero valor (en decimal) almacenado en el ejercicio
anterior.
g) Determine la secuencia de bits para la representación de 0.00517 en un
formato de 32 bits.
h) Determine el verdadero valor (en decimal) almacenado en el ejercicio
anterior.
i) Si A, B y C son variables enteras con signo de 16 bits que contienen
los valores -10732, 6932 y 0 respectivamente. Determine el valor de C
luego de hacer la siguiente operación C=A-B.
j) Si A, B y C son variables enteras sin signo de 10 bits que contienen los
valores 372, 998 y 0 respectivamente. Determine el valor de C luego de
hacer la siguiente operación C=A+B.
k) Convertir a código Gray 826 (10 bits).
l) Codifique en binario 8037 (BCD)
13
II CIRCUITOS DE LOGICA DIGITAL
2.1. Compuertas lógicas.
Las compuertas lógicas son bloques de hardware que producen señales de 0 o 1
cuando los requerimientos lógicos de entrada son satisfechos. Esta característica
permite utilizar el álgebra booleana como herramienta para el análisis y diseño de
circuitos lógicos digitales.
Cada compuerta tiene un símbolo gráfico distinto y su funcionamiento puede
describirse por medio de una expresión algebraica. La relación de entrada/salida
de las variables binarias para cada compuerta puede representarse en forma tabular
por una tabla de verdad. Los nombres, símbolos, tablas de verdad y funciones
algebraicas de las siete compuertas lógicas se listan en la figura 2.1
C=A∙B
A B C
0 0 0
0 1 0
1 0 0
1 1 1
C=A+B
A B C
0 0 0
0 1 1
1 0 1
1 1 1
C=A´
A C
0 1
1 0
C=(A∙B)´
A B C
0 0 1
0 1 1
1 0 1
1 1 0
C=AÅB
A B C
0 0 0
0 1 1
1 0 1
1 1 0
C=(AÅB)´
A B C
0 0 1
0 1 0
1 0 0
1 1 1
C=(A+B)´
A B C
0 0 1
0 1 0
1 0 0
1 1 0
Figura 2.1 Compuertas lógicas digitales
Las compuertas lógicas pueden combinarse para producir circuitos lógicos.
2.2. Álgebra booleana
El álgebra booleana difiere de forma significativa del álgebra en que las constantes
y variables booleanas sólo pueden tener, en diferentes ocasiones, dos valores
posibles: 0 o 1.
Las tres operaciones lógicas básicas son AND, OR y complemento.
Una función booleana puede expresarse algebraicamente con variables binarias,
símbolos de operadores lógicos, paréntesis y signos de igualdad. Para un valor
dado de las variables, la función sólo puede ser 0 o 1.
La relación entre una función y sus variables binarias se pueden representar en una
tabla de verdad, donde se lista las 2N combinaciones de las N variables binarias y,
también, mediante un diagrama lógico.
14
Ejemplo: F = A∙(B+C)´
A, B, C y F, por ser variables booleanas sólo
puede ser 0 o 1.
En la figura 2.2 se muestra la tabla de verdad con todas las posibles
combinaciones de A, B y C, así como el diagrama lógico para la función F
A
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
C
0
1
0
1
0
1
0
1
F
0
0
0
0
1
0
0
0
Figura 2.2 Tabla de verdad y diagrama lógico para F = A∙(B+C)´
La tabla de verdad la podemos interpretar de la siguiente manera: Cuando
las entradas A, B y C son 0, la salida F es 0 que es lo que se obtiene al
reemplazar A, B y C en la función.
F= A∙(B+C)´ = 0∙(0+0)´ = 0∙0´ = 0∙1 = 0
Ahora si A=1, B=0 y C=0, F tomará el valor de:
F= A∙(B+C)´ = 1∙(0+0)´ = 1∙0´ = 1∙1 = 1
Así, se va probando con todas las posibles combinaciones de las entradas
A, B y C (23=8 combinaciones) y se van obteniendo los valores de la salida
F.
Existen un conjunto de reglas que se pueden usar para simplificar
expresiones lógicas, es decir, para reducir el número de términos de una
expresión. Al hacer esto, la expresión reducida generará un circuito lógico
menos complejo que el de la expresión original. Las identidades se listan a
continuación:
1)
2)
3)
4)
5)
6)
7)
8)
A+0=A
A+1=1
A+A=A
A+A´=1
A+B=B+A
A+(B+C)=(A+B)+C
A∙(B+C)=AB+AC
(A+B)´=A´B´
9)
10)
11)
12)
13)
14)
15)
16)
17)
A∙0=0
A∙1=A
A∙A=A
A∙A´=0
A∙B=B∙A
A∙(B∙C)=(A∙B)∙C
A+B∙C=(A+B)∙(A+C)
(A∙B)´=A´+ B´
(A´)´=A
15
Las identidades 8) y 16) se conocen como los teoremas de DeMorgan y se
pueden generalizar de la siguiente manera:
(A+B+C+D+E+…)´ = A´B´C´D´E´…
(ABCDE…)´ = A´+B´+C´+D´+E´…
2.3. Mintérminos y Maxtérminos
La representación más básica de una función lógica es la tabla de verdad, pero la
información contenida en ella puede también expresarse en forma algebraica
mediante una suma canónica o un producto canónico.
La suma canónica de una función lógica es la suma de los productos lógicos de
las variables correspondientes a las líneas de la tabla de verdad para las que la
función produce una salida de 1. Cuando en la columna de la variable hay un 1 se
toma la variable y cuando hay un 0 se toma su complemento.
El producto canónico de una función lógica es un producto de las sumas lógicas
de las variables correspondientes a las combinaciones de entradas para las que la
función produce una salida de 0. En este caso, cuando en la columna de la variable
hay un 0 se toma la variable y cuando hay un 1 se toma su complemento.
Por ejemplo, dada la función lógica de la tabla siguiente:
Línea
0
1
2
3
4
5
6
7
X
0
0
0
0
1
1
1
1
Y
0
0
1
1
0
0
1
1
Z
0
1
0
1
0
1
0
1
F
1
0
0
1
1
0
1
1
Las líneas donde F es 1 son: 0, 3, 4 6 y 7 y el producto lógico de la fila:
0 es X´Y´Z´
en la columna X es 0, en Y es 0 y en Z es 0
3 es X´YZ
en la columna X es 0, en Y es 1 y en Z es 1
4 es XY´Z´
en la columna X es 1, en Y es 0 y en Z es 0
6 es XYZ´
en la columna X es 1, en Y es 1 y en Z es 0
7 es XYZ
en la columna X es 1, en Y es 1 y en Z es 1
Por consiguiente la suma canónica de la función es:
F = ∑xyz(0,3,4,6,7) = X´Y´Z´ + X´YZ + XY´Z´ + XYZ´ + XYZ
Para el producto canónico se tiene que:
Las líneas donde F es 0 son: 1, 2 y 5 y la suma lógica de la fila:
1 es X+Y+Z´ en la columna X es 0, en Y es 0 y en Z es 1
2 es X+Y´+Z en la columna X es 0, en Y es 1 y en Z es 0
5 es X´+Y+Z´ en la columna X es 1, en Y es 0 y en Z es 1
F = ∏ xyz(1,2,5) = (X+Y+Z´)(X+Y´+Z)(X´+Y+Z´)
16
2.4. Simplificación por Álgebra Booleana
Manipulando una expresión booleana, de acuerdo con las reglas del álgebra
booleana, se puede obtener una expresión más simple, una expresión que requiera
menos compuertas lógicas.
Ejemplo: Simplificar F = XY´Z + XY´Z´
Figura 2.3 Diagrama lógico de F = XY´Z + XY´Z´
Si hacemos que: A = XY´
F = AZ + AZ´
F = A(Z + Z´)
F=A1
F=A
F = XY´
entonces tenemos:
si aplicamos la identidad 7) queda:
aplicando la identidad 4) Z + Z´ = 1
por la identidad 10)
regresando el valor original
La tabla de verdad (del diagrama original y el simplificado) y el diagrama
lógico simplificado se muestran en la figura 2.4
X
0
0
0
0
1
1
1
1
Y
0
0
1
1
0
0
1
1
Z
0
1
0
1
0
1
0
1
F
0
0
0
0
1
0
1
0
Figura 2.4 Tabla de verdad y Diagrama lógico y para F = XY´
Por lo tanto las expresiones booleanas: XY´Z + XY´Z´ y XY´ son
equivalentes, esto implica que ambas expresiones tienen la misma tabla de
verdad a pesar que sus diagramas lógicos son diferentes.
Nótese que mientras en el diagrama lógico original se requieren 7
compuertas lógicas (2 NOT, 4 AND y 1 OR) en el diagrama simplificado
solo se necesitan 2 compuertas (1 NOT y 1 AND). Pero lo que debe quedar
bien claro es que ambos diagramas tienen la misma tabla de verdad, es decir,
que si a ambos diagramas se les aplica las mismas entradas, éstos generarán
las mismas salidas.
17
Ejemplo: Simplificar F = (A´ + B)(A + B)
Figura 2.5 Diagrama lógico F = (A´+B)(A +B)´
F = (A´ + B)(A + B)
F = (A´ + B)A + (A´ + B)B
F = A´A + BA + A´B + BB
por la identidad 7) o como,
simplemente, el producto
de 2 binomios
Aplicando la 12) A´A=0 y por la 11) BB=B queda
F = 0 + BA + A´B + B
F = 0 + AB + A´B + B
F = 0 + (A + A´)B + B
F = 0 + 1B + B
F=0+B+B
F=0+B
F=B
por la 13) BA=AB
por la 7)
por la 4)
por la 10)
por la 3)
por la 1)
Con esto queda demostrado que (A´ + B)(A + B) puede ser reemplazado por
simplemente B, es decir, que la salida F sólo y únicamente depende de la
variable de entrada B y no se toma en cuenta, para nada, el valor que pueda
tomar la variable A, esto también se puede apreciar en la tabla de verdad y el
diagrama simplificado de la expresión original de la figura 2.6
A
0
0
1
1
B
0
1
0
1
F
0
1
0
1
Figura 2.6 Tabla de verdad y Diagrama lógico y para F = B
En este caso se puede ver como queda simplificada una expresión booleana
al máximo.
Cabe recalcar, una vez más, que la tabla de verdad que se muestra en la
figura 2.6 satisface las condiciones de salida para ambos diagramas lógicos
(el original y el simplificado)
18
Ejemplo: Simplificar F = ((A´ + C)(B + D´))’
Figura 2.7 Diagrama lógico de F = ((A´+C)(B+D´))´
Hacemos que X=A´+C y Y=B+D´ y sustituimos en F
F = (XY)´
por la 16)
F = X´ + Y´
restableciendo valores
F = (A´ + C)´ + (B + D´)´
por la 8)
F = AC´ + B´D
Figura 2.8 Diagrama lógico de F = AC´ + B´D
La tabla de verdad que satisface las condiciones de salida de los dos
diagramas lógicos es la siguiente:
A
0
0
0
0
0
0
0
0
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
0
1
0
1
0
0
0
0
A
1
1
1
1
1
1
1
1
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
1
1
0
1
1
1
0
0
Figura 2.9 Tabla de verdad de F = AC´ + B´D
En este caso, como se observará en los diagramas, no se ha simplificado
mucho la expresión, pero se ha obtenido un equivalente con mayor presencia
de compuertas AND.
19
2.5. Simplificación por mapa de Karnaugh.
Si bien es cierto que una expresión booleana se puede simplificar mediante las
relaciones básicas del álgebra booleana, en algunas ocasiones esto se puede
complicar debido a que no esta definido una serie de pasos sucesivos a realizar en
el proceso de simplificación.
Existe un método grafico que proporciona un procedimiento sencillo y directo
para simplificar las expresiones booleanas y se denomina Mapa de Karnaugh.
El Mapa de Karnaugh se puede utilizar para resolver problemas con cualquier
número de variables de entrada, su utilidad práctica se limita a seis variables, con
una cantidad mayor será necesario el empleo de una computadora.
El método consiste en agrupar 2 o más términos de una suma canónica en los
cuales exista un cambio mínimo de bits (código Gray) entre las variables que los
conforman. Por ejemplo la suma canónica ABC + ABC´ (111 y 110,
respectivamente), puede simplificarse a AB(C+C´) = AB
La idea es hacer un mapa colocando juntas las líneas cuyos valores en binario
tengan un cambio mínimo de sus bits. Por ejemplo la línea 0 (0000) con las líneas
1, 2, 4 y 8 (0001, 0010, 0100 y 1000, respectivamente).
La línea 2 (0010) con las líneas 0, 3, 6 y 10 (0000, 0011, 0110 y 1010)
La línea 5 (0101) con las líneas 1, 4, 7 y 13 (0001, 0100, 0111 y 1101)
La línea 15 (1111) con las líneas 7, 11, 13 y 14 (0001, 0100, 0111 y 1101)
Siguiendo esta regla un mapa de 16 líneas (4 variables) seria el siguiente:
0
(0000)
4
(0100)
12
(1100)
8
(1000)
1
(0001)
5
(0101)
13
(1101)
9
(1001)
3
(0011)
7
(0111)
15
(1111)
11
(1011)
2
(0010)
6
(0110)
14
(1110)
10
(1010)
10
2
6
14
10
2
8
0
4
12
8
0
9
1
5
13
9
1
11
3
7
15
11
3
10
2
6
14
10
2
8
0
4
12
8
0
Figura 2.10 Mapa de Karnaugh para 4 variables
Como se observa la línea 0 tiene adyacentes a las líneas 1 y 4 pero no a las líneas
2 y 8. Igual ocurre con la línea 2 que tiene adyacentes a las líneas 3 y 6 pero no a
las líneas 0 y 10. Este inconveniente se resuelve copiando la tabla alrededor de la
tabla original como se muestra en la figura 2.10
Una vez que se tiene el mapa se forman grupos de 2, 4, 8, 16, etc. líneas
adyacentes cuya función de salida es 1. Esto significa que se pueden agrupar de:
2 términos: Las líneas (0,1), (0,4), (0,2), (0,8); (5,1), (5,7), (5,4), (5,13); (11,9),
(11,3), (11,10), (11,15), etc.
4 términos: Las líneas (0,1,3,2), (0,4,12,8), (0,1,4,5), (0,2,8,10); (1,5,13,9),
(1,3,9,11), (1,3,5,7); (6,4,14,12), (6,2,14,10), (6,7,15,14), etc.
8 términos: Las líneas (0,1,3,2,4,5,7,6), (0,4,12,8,1,5,13,9), (0,4,12,8,2,6,14,10),
(0,1,3,2,8,9,11,10), etc.
No hay que olvidar que solo se agruparán las líneas cuya función de salida es 1
20
Por ejemplo para la siguiente suma canónica ∑ABC(0,1,2,3,4,5,9,10) que se
corresponde con la siguiente tabla:
0
1
2
3
4
5
6
7
A
0
0
0
0
0
0
0
0
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
1
1
1
1
1
1
0
0
A
1
1
1
1
1
1
1
1
8
9
10
11
12
13
14
15
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
0
1
1
0
0
0
0
0
Figura 2.11 Tabla de verdad de ∑ABC(0,1,2,3,4,5,9,10)
La expresión sin simplificar será:
F = A´B´C´D´ + A´B´C´D + A´B´CD´ + A´B´CD + A´BC´D´ + A´BC´D + AB´C´D+ AB´CD´
El mapa de karnaugh, quedará así:
C´D´
00
A´B´
00
A´B
01
AB
11
AB´
10
C´D
01
0
1
1
1
4
1
12
5
13
1
7
15
0
9
8
0
2
1
0
0
CD´
10
3
1
1
0
CD
11
11
0
6
0
14
0
10
1
Figura 2.12 Mapa de Karnauhg de ∑ABC(0,1,2,3,4,5,9,10)
Los números en la esquina superior derecha de las celdas se corresponden con los
números de línea y los números en el centro son los valores que toma la función
de salida en esa línea.
En los bordes superior e izquierdo, aparecen los valores que pueden tomar las
variables lógicas. Por ejemplo, la intersección de la fila A´B y la columna C´D
definen el término A´BC´D (0101, línea 5). Otro detalle a tener en cuenta es el
orden o secuencia que tienen los elementos de los bordes, así, A´B´, A´B, AB y
AB´ se corresponden con 00, 01, 11 y 10 (código Gray para 0, 1, 2 y 3), de igual
manera ocurre con el borde superior.
A continuación se procederá a agrupar. Cuanto mayor número de elementos
tenga el grupo, mayor será la simplificación
Las líneas 0, 1, 3 y 2 forman el grupo 1.
Las líneas 0, 1, 4 y 5 forman el grupo 2.
Las líneas 1 y 9 forman el grupo 3 y, finalmente,
Las líneas 2 y 10 el grupo de 4.
21
No importa que se tomen líneas que pertenecen a algún grupo para formar otro
grupo.
Ahora pasaremos a simplificar. La regla de simplificación es sencilla:
“QUEDARÁN SOLO AQUELLAS VARIABLES LÓGICAS PARA LAS
QUE NO APARECE SU COMPLEMENTO EN EL GRUPO”
En el grupo 1 (A´B´C´D´ + A´B´C´D + A´B´CD + A´B´CD´) quedará: A´B´
En el grupo 2 (A´B´C´D´ + A´B´C´D + A´BC´D´ + A´BC´D) quedará: A´C´
En el grupo 3 (A´B´C´D + AB´C´D) quedará: B´C´D
En el grupo 4 (A´B´CD´ + AB´CD´) quedará: B´CD´
Por ultimo, se unen las reducciones mediante un operador OR (+) quedando:
F = A´B´ + A´C´ + B´C´D + B´CD´
Condición no importa
En algunos casos se va a dar que, ciertas entradas nunca van a ocurrir, por lo que
no estarán definidos los correspondientes valores para la función de salida. Esto se
conoce como condición NO IMPORTA, es decir, que no importa si la función de
salida toma el valor de 0 o 1, por lo que se puede establecer un valor arbitrario
para la función de salida de tal manera que permita simplificar aún más la
expresión.
Ejemplo: Diseñar un detector de dígitos BCD primos.
Como sabemos, los dígitos BCD son del 0 al 9 (0000 a 1001) y están
conformados por 4 bits. Por consiguiente, los dígitos BCD primos son: 1, 2,
3, 5 y 7.
La tabla de verdad para esta función será:
0
1
2
3
4
5
6
7
A
0
0
0
0
0
0
0
0
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
0
1
1
1
0
1
0
1
8
9
10
11
12
13
14
15
A
1
1
1
1
1
1
1
1
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
0
0
?
?
?
?
?
?
Figura 2.13 Tabla de verdad para detector de números primos
En la tabla, ABCD representan los 4 dígitos del código BCD. Nótese que
desde la línea 10 hasta la 15, la función de salida tiene el valor “?” debido a
que esos valores no están definidos para el código BCD, en otras palabras, si
las entradas es un código BCD, estas entradas (10-15) nunca ocurrirán.
22
Ahora construiremos el mapa de Karnaugh tal como se muestra en la figura
2.14. Nótese las líneas del 10 al 15, los ? significa que pueden tomar el valor
de 0 o 1 según nos convenga.
C´D´
00
A´B´
00
A´B
01
AB
11
AB´
10
C´D
01
0
0
1
1
4
0
12
5
13
8
0
7
15
?
9
0
2
1
1
?
CD´
10
3
1
1
?
CD
11
11
?
6
0
14
?
10
?
Figura 2.14 Mapa de Karnauhg de números primos BCD
Hay un grupo que está completamente definido, que es el grupo conformado
por las líneas 1, 3, 5 y 7, el problema es, con qué líneas agrupar la línea 2.
Un primer intento sería agrupar la línea 2 con la línea 3, con lo que se forma
un grupo de 2 líneas.
Un segundo intento es hacer 1 la línea 10 y agruparla con la línea 2, también
sería un grupo de 2 líneas.
Un tercer intento, es hacer 1 las líneas 11 y 10 y agruparlas con las líneas 3 y
2 (grupo de 4) con lo que obtendríamos una mayor simplificación. Al
parecer esto sería lo óptimo, por lo que la función quedará:
F = A´D + B´C
Esto también significa que la función de salida del resto de líneas (12, 13, 14
y 15) debemos asignarle el valor de 0.
2.6. Circuitos lógicos combinacionales.
Es un grupo de compuertas lógicas conectadas de una manera específica,
definiendo de esta forma un circuito con un conjunto de entradas y salidas
binarias. La característica principal de un circuito combinacional es que los
valores binarios de las salidas dependen o están en función, sólo y únicamente, de
una combinación binaria de entradas.
N variables
de entrada
A
B
Circuito
Combinacional
F1
F2
M variables
de salida
FM
Figura 2.15 Diagrama de bloque de un circuito combinacional
Un circuito combinacional puede describirse mediante una tabla de verdad que
muestre la relación binaria entre las N variables de entrada y las M variables de
salida.
23
2.6.1. Semisumador.
Es el circuito combinacional más simple y realiza la suma aritmética de
dos dígitos binarios. Se denomina semisumador porque las entradas están
conformadas por sólo los dos dígitos binarios a sumar y como salidas,
tiene el resultado de la suma y el acarreo generado.
A
0
0
1
1
B
0
1
0
1
S
0
1
1
0
C
0
0
0
1
Figura 2.16 Tabla de verdad y circuito combinacional de un semisumador
De la tabla podemos obtener las siguientes funciones lógicas S = A´B+AB´
y C = AB, pero A´B+AB´ = AÅB por lo que el circuito quedaría:
Figura 2.17 Circuito combinacional simplificado de un semisumador
2.6.2. Sumador completo.
Este circuito combinatorio tiene como entradas los dos dígitos binarios a
sumar (A, B) y además un acarreo inicial (K), es decir, tres entradas. Como
salidas, el resultado de la suma (S) y el acarreo generado o de salida (C).
A
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
K
0
1
0
1
0
1
0
1
S
0
1
1
0
1
0
0
1
C
0
0
0
1
0
1
1
1
Figura 2.18 Tabla de verdad y circuito combinacional de un sumador completo
De la tabla de la figura 2.18 se obtienen las funciones:
S = A´B´K+ABK +A´BK´+AB´K´ = (A´B´+AB)K+(A´B+AB´)K´
S = (AÅB)´K+(AÅB)K´ = (AÅB)ÅK
C = A´BK+AB´K+ABK´+ABK = (A´B+AB´)K+AB(K´+K)
C = (AÅB)K+AB
24
2.6.3. Sumador restador.
Los circuitos anteriores pueden tratarse como cajas negras, donde solo
sepamos las salidas que se van a obtener al ingresar entradas determinadas,
por ejemplo el diagrama de bloque para el sumador completo seria el
siguiente:
Figura 2.19 Diagrama de bloque de un sumador completo
Donde A y B son las entradas de los dígitos binarios a sumar, Ci es el
acarreo de entrada, Σ es la salida de la suma de los bits de entrada y Co el
acarreo de salida.
Se pueden usar estos circuitos simples para diseñar circuitos
cambinacionales más complejos como por ejemplo un sumador de 4 bits
tal como se muestra en la figura siguiente:
Figura 2.20 Diagrama de un Sumador de 4 bits
En el diagrama de la figura 2.20 hay 4 sumadores completos. K es el
acarreo de entrada, A3, A2, A1 y A0 son los 4 bits del numero A, al igual
que B3, B2, B1 y B0 del numero B.
El acarreo de salida Co de cada sumador se conecta al acarreo de entrada Ci
del siguiente bloque sumador. S3, S2, S1 y S0 es un número de 4 bits
resultado de la suma de A y B. Finalmente C contiene el acarreo de salida
resultado de la suma de los números de 4 bits A y B.
De igual forma su puede diseñar un sumador de 8, 16 o 32 bits o, en todo
caso, usando 2 sumadores de 4 bits se puede construir un sumador de 8
bits, con 4 uno de 16 y así sucesivamente.
Figura 2.21 Diagrama de un Sumador de 8 bits usando sumadores de 4 bits
25
La figura 2.21 muestra un sumador de 8 bits diseñado con 2 sumadores de
4 bits y estos a su vez se han diseñado usando sumadores completos de un
bit.
Usando la misma lógica se puede diseñar un restador, pero mejor aun,
pasemos a hablar de un circuito que realice ambas operaciones: un
sumador-restador.
Primero recordemos que una resta binaria (A-B) es igual que una suma
pero complementando a 2 el segundo operando (A+C2(B)), es decir que:
10 – 2 = 10 + C2(2)
En binario con 4 bits sería:
1010 – 0010 = 1010 + C2(0010) = 1010 + (1101 + 1)
Por consiguiente necesitamos diseñar un circuito tal, que cuando la
operación sea una suma el segundo operando B se mantenga igual pero, si
la operación es una resta se complemente (cambiar 1s por 0s y 0s por 1s y
sumarle 1). Una vez tratado el segundo operando se realiza una simple
suma.
Una entrada adicional (M) nos puede indicar si la operación a realizar es
una suma (0) o una resta (1). Si M=0, entonces el digito Bi debe quedar
igual (sumar), caso contrario el digito Bi debe ser complementado (restar).
Si miramos la tabla de verdad generada, donde B es la entrada al sumador,
(figura 2.22) lo que obtenemos es una operación XOR.
M
0
0
1
1
Bi
0
1
0
1
B
0
1
1
0
Figura 2.22 Tabla de verdad de la operación
Por lo tanto, mediante una operación XOR podemos, si fuera una resta,
complementar los 0s y los 1s del segundo operando; pero al hacer esto sólo
estamos hallando el complemento a 1, falta sumarle 1 para que se convierta
en el complemento a 2. Esto se logra conectando la entrada M al acarreo de
entrada (sumar 1), tal como se aprecia en la figura 2.23.
26
Figura 2.23 Diagrama de un Sumador-Restador de 4 bits
2.7. Flip-flops
Es una celda binaria capaz de almacenar un bit de información. Tiene 2 salidas,
una para el valor normal y una para el valor complementado del bit almacenado en
él. La diferencia entre los diversos tipos de flip-flops está en el número de entradas
que posean y la manera en la cual las entradas afectan el estado binario.
Comúnmente los flip-flops reciben el nombre de registros.
2.7.1. Flip Flop Básico con compuertas NAND y NOR
El circuito Flip-Flop más elemental que se puede construir es con 2
compuertas NAND como muestra la figura 2.24
R
0
0
1
1
S
0
1
0
1
Q
Q=Q’=1
1
0
Sin Cambio
Figura 2.24 Flip-flop básico NAND y su tabla d verdad
Resumen del flip-flop básico con compuertas NAND
1. R=S=1: Esta condición no tiene efecto alguno sobre el estado de salida.
Las salidas Q y Q’ permanecerán en el estado en el que se encontraban
antes de presentarse esta condición de entrada.
2. R=0, S=1: Este estado siempre ocasionará que la salida pase al estado
Q=1, donde permanecerá aun después de que R=1.
3. R=1, S=0: Esto siempre producirá el estado Q=0, donde la salida
permanecerá aun después de que S=1.
4. R=S=0: Esta condición intenta iniciar y borrar el registro básico en
forma simultanea y produce Q=Q’=1. No debe utilizarse.
La figura 2.25 muestra el diagrama de estados del flip-flop, donde los
círculos son los estados del flip-flop (salida Q) y las flechas las
transiciones que permiten pasar de un estado a otro.
Los valores 00, 01, 10 y 11 son los valores que pueden tomar las entradas
RS cuando el flip-flop se encuentre en alguno de sus 2 estados (0 o 1).
Como se aprecia la salida Q o estado al que pasaría, esta en función de las
entradas R, S y del estado actual en el que se encuentre el flip-flop. Por
ejemplo, si el flip-flop se encuentra en el estado 0 y RS=11 la salida Q es
0, pero si se encontrara en el estado 1, la salida Q sería 1.
10
10
0
11
00
01
1
00
01
11
Figura 2.25 Diagrama de estados del flip-flop NAND
27
Otra alternativa de flip-flop básico es la mostrada en la figura 2.26,
construido con 2 compuertas NOR
R
0
0
1
1
S
0
1
0
1
Q
Sin cambio
1
0
Q=Q’=0
Figura 2.26 Registro básico NOR y su tabla d verdad
Resumen del flip-flop básico con compuertas NOR
1. R=S=0: Esta condición no tiene efecto alguno sobre el estado de salida.
Las salidas Q y Q’ permanecerán en el estado en el que se encontraban
antes de presentarse esta condición de entrada.
2. R=0, S=1: Este estado siempre ocasionará que la salida pase al estado
Q=1, donde permanecerá aun después de que R=1.
3. R=1, S=0: Esto siempre producirá el estado Q=0, donde la salida
permanecerá aun después de que S=1.
4. R=S=1: Esta condición intenta iniciar y borrar el registro básico en
forma simultanea y produce Q=Q’=0. No debe utilizarse.
00
10
0
11
10
01
00
1
01
11
Figura 2.25 Diagrama de estados del flip-flop NOR
Al modificar el valor de una de las entradas del fli-flop, la salida Q cambia
inmediatamente, por lo que podemos considerar estas entradas como
asíncronas. Pero por lo general es necesario que las salidas se sincronicen
con una señal maestra conocida como señal del Reloj. Esto se logra
agregando un par de compuertas AND, con lo que ahora obtenemos un
flip-flop con entradas síncronas, lo que implica que las salidas no se
actualizaran mientras la señal de reloj no sea 1.
28
Figura 2.25 Diagrama de un flip-flop con entradas síncronas
2.7.2. Flip-flop SR sincronizado por reloj
S
0
0
1
1
R
0
1
0
1
CLK
↑
↑
↑
↑
Q
Q anterior
0
1
1
Q0
0
0
1
1
Q1
0
1
0
1
S
0
1
0
¿
R
¿
0
1
0
Figura 2.26 Símbolo grafico, Tabla característica y excitación de un FF RS
Ecuación característica: Q = S + R´Q
2.7.3. Flip-flop D sincronizado por reloj
D
0
1
CLK
↑
↑
Q
0
1
Q0
0
0
1
1
Q1
0
1
0
1
D
0
1
0
1
Figura 2.27 Símbolo grafico, Tabla característica y excitación de un FF D
Ecuación característica: Q = D
2.7.4. Flip-flop JK sincronizado por reloj
J
0
0
1
1
K
0
1
0
1
CLK
↑
↑
↑
↑
Q
Q anterior
0
1
Q´
Q0
0
0
1
1
Q1
0
1
0
1
J
0
1
¿
¿
K
¿
¿
1
0
Figura 2.28 Símbolo grafico, Tabla característica y excitación de un FF JK
Ecuación característica: Q = JQ´ + K´Q
2.7.5. Flip-flop T sincronizado por reloj
T
T
0
1
CLK
↑
↑
Q
Q anterior
Q´
Q0
0
0
1
1
Q1
0
1
0
1
T
0
1
1
0
Figura 2.29 Símbolo grafico, Tabla característica y excitación de un FF T
Ecuación característica: Q = Q Å T
29
2.8. Circuitos lógicos secuenciales.
Es un conjunto de compuertas lógicas (circuito combinacional) y flip-flops
interconectados entre si. La característica principal de un circuito secuencial es
que los valores binarios de las salidas no sólo dependen de sus entradas actuales
sino también de la secuencia de entradas previas.
2.8.1. Ecuaciones de entrada de los flip-flops
La figura 2.30 muestra un circuito secuencial conformado por 2 flip-flops
D y algunas compuertas lógicas.
Figura 2.30 Diagrama de un circuito secuencial con FF D
En un flip-flop tipo D la ecuación característica es Q=D (nótese que Q será
A en el primer flip-flop y B en el segundo), es decir A=DA y B=DB. Por lo
tanto DA será igual a la salida del circuito conformado por las compuertas
1, 2 y 3, es decir: A=DA=Ax+xB y DB a la salida de la compuerta 4,
B=DB=A´x. La salida “y” será igual al resultado de las compuertas 5, 6, 7
y 8; entonces: y=Ax´+Bx´.
Esto significa que el nuevo valor de A dependerá del actual valor de A, B y
x, mientras que el valor de B estará en función de B y A´. Lo siguiente será
construir la tabla de estados del circuito usando las expresiones halladas.
Estado actual
A
B
0
0
0
0
0
1
0
1
1
0
1
0
1
1
1
1
Entrada
x
0
1
0
1
0
1
0
1
Estado nuevo
A
B
0
0
0
1
0
0
1
1
0
0
1
0
0
0
1
0
Salida
y
0
0
1
0
1
0
1
0
30
Figura 2.31 Tabla de estados
Por ejemplo si los valores actuales de las variables A, B y x son 0, 1 y 1
respectivamente y los reemplazamos en las expresiones halladas,
obtendremos los nuevos valores de A y B:
A = Ax+xB
= 0∙1 + 1∙1 = 0 + 1 = 1
B = A´x
= 1∙1 = 1
y = Ax´+Bx´
= 0∙0 + 1∙0 = 0 + 0 = 0
Ahora, a partir de la tabla de estados, construiremos el diagrama de estados
Como tenemos 2 (N) Flip-flops y cada uno de ellos puede tener 2 estados
posibles, esto significa que el circuito secuencial tendrá 4 (2N) estados
(AB) en total 00, 01, 10 y 11.
Cuando el estado actual (AB) es 00 y x es 0, el estado siguiente es 00 y la
salida y=0, pero si x=1 el siguiente estado es 01 y la salida y=0.
Si el estado actual es 11 y x=0 el siguiente estado es 00 y la salida y=1,
pero si x=1 el estado siguiente es 10 y la salida y=0. Si continuamos con
este razonamiento, obtendremos el siguiente diagrama:
0/0
1/0
0/1
00
0/1
10
0/1
1/0
01
1/0
11
1/0
Figura 2.31 Diagrama de estados
Los números que aparecen en el numerador son las entradas, mientras los
denominadores son las salidas.
Ahora analicemos un circuito secuencial con flip-flops tipo JK.
Figura 2.32 Diagrama de circuito secuencial con FF JK
Las ecuaciones de entrada son: JA=x, KA=x, JB=z, KB=z, z=(x+A)B´ y la
ecuación característica para estos flip-flops es Q=JQ´+K´Q que para este
caso sería: A=JAA´+KA´A y B=JBB´+KB´B
31
Estado actual
A
0
0
0
0
1
1
1
1
Entrada
=x
=x
x
0
1
0
1
0
1
0
1
JA
0
1
0
1
0
1
0
1
KA
0
1
0
1
0
1
0
1
B
0
0
1
1
0
0
1
1
Salida
(x+A)B´
z
0
1
0
0
1
1
0
0
=z
=z
JB
0
1
0
0
1
1
0
0
KB
0
1
0
0
1
1
0
0
Estado nuevo
= JQ´+K´Q
A
B
0
0
1
1
0
1
1
1
1
1
0
1
1
1
0
1
Figura 2.33 Tabla de estados
Por ejemplo si A, B y x valen 1, 0 y 0, respectivamente, entonces:
JA= x = 0
KA = x = 0
z = (x+A)B´ = (0+1)1 = 1
JB = z = 1
KB = z = 1
A = JAA´+KA´A = 0∙0+1∙1 = 1
B = JBB´+KB´B = 1∙1+0∙0 = 1
Todo esto queda resumido en el diagrama de estados siguiente
0/0
0/0
00
01
1/0
1/1
1/1
1/0
11
10
0/0
0/1
Figura 2.34 Diagrama de estados
Hasta ahora hemos partido del diagrama de un circuito secuencial para
determinar el comportamiento de éste, pero también se puede dar el caso
contrario, es decir, que a partir del comportamiento del circuito secuencial
determinar o diseñar dicho circuito.
Por ejemplo: Dado el diagrama de estados de la figura 2.35 diseñar un
circuito secuencial haciendo uso de flip-flops tipo JK
0/0
0/1
1/0
00
11
1/1
1/1
01
10
0/1
0/0
1/0
32
Figura 2.35 Diagrama de estados
En este tipo de problemas conocemos el estado actual (Q0) y el estado
nuevo (Q1) al que pasaría el circuito secuencial al generarse una entrada x.
En este caso haremos uso de la tabla de excitación del FF JK, la cual nos
permite saber que valores deben tener las entradas J y K para poder pasar
de Q0 a Q1
Estado actual
Q0
A
B
0
0
0
0
0
1
0
1
1
0
1
0
1
1
1
1
Entrada
x
0
1
0
1
0
1
0
1
Estado nuevo
Q1
A
B
0
0
0
1
0
1
1
0
1
0
1
1
1
1
0
0
FF-A
JA
0
0
0
1
¿
¿
¿
¿
FF-B
KA
¿
¿
¿
¿
0
0
0
1
JB
0
1
¿
¿
0
1
¿
¿
KB
¿
¿
0
1
¿
¿
0
1
Salida
z
0
1
1
0
0
1
1
0
Figura 2.35 Tabla de estados
Por ejemplo, si el estado actual del FF A es 0, para que pueda pasar al
estado 0 (se queda en el mismo estado), la entrada J (JA) debe ser 0 y K
(KA) debe ser ¿ (entrada no importa), según la tabla de excitación.
Para el caso del FF B, si su estado actual es 1, para que pueda pasar al
estado 1 (se queda en el mismo estado), la entrada J (JB) debe ser ¿
(entrada no importa) y K (KB) debe ser 0.
Continuando con este razonamiento se completa la tabla y luego se
procede a determinar JA, KA, JB y KB en función de A, B y x, es decir, que
se toma a A, B (estado actual), x como entradas y a JA, KA, JB y KB como
funciones de salida. Obviamente el método más práctico para todos estos
casos es: El mapa de Karnaugh.
JA
X´
X
0
1
A´B´
0
A´B
0
AB
¿
AB´
¿
2
6
4
0
3
1
7
¿
5
¿
KA
X´
X
0
1
A´B´
¿
A´B
¿
AB
0
AB´
0
2
6
4
¿
3
¿
7
1
5
0
JB
X´
X
0
1
A´B´
0
A´B
¿
AB
¿
AB´
0
2
6
4
1
3
¿
7
¿
5
1
KB
X´
0
A´B´
¿
A´B
0
AB
0
AB´
¿
2
6
4
X
1
¿
3
1
7
1
5
¿
Figura 2.36 Mapas de Karnaugh para JA, KA, JB y KB
De los mapas de Karnaugh podemos determinar que:
JA = Bx
KA = Bx
JB = x
KB = x
33
Del mismo modo se puede determinar z = Bx´ + B´x = BÅx
Con todas estas expresiones procedemos a diseñar el circuito secuencial tal
como se muestra en la figura 2.37
Figura 2.37 Diagrama del circuito secuencial
2.9. Solución de ejercicios con Boole
Boole es un programa que permite diseñar y analizar circuitos combinacionales y
secuenciales. Este software es de libre uso y puede ser descargado de la siguiente
página: http://paginaspersonales.deusto.es/zubia/BOOLE_SP.zip
Una vez descargado y descomprimido se ejecuta Boole.exe y aparece una ventana
con 2 botones: “Sistema combinacional” y “Sistema secuencial. Autómatas”
2.9.1. Circuitos combinacionales.
Seleccionado el botón “Sistema combinacional” aparecerá la ventana
mostrada en la figura 2.38
34
Figura 2.38 Ventana de Sistema combinacional de Boole
Primero debemos darle un nombre al sistema (Ejercicio1) y luego
establecer la cantidad de variables de entrada (3) y salida (1). Se puede
establecer un nombre para las variables de entrada (X, Y, Z) y de salida o
dejarlos con sus valores por defecto A, B, C y F respectivamente.
Ahora elegimos el botón “Tabla de verdad manual” para ingresar los
valores de la tabla de verdad del circuito. La ventana que aparecerá es la
mostrada en la figura 2.39.
Figura 2.39 Ventana para el llenado de la tabla de verdad
El botón “Condiciones libres” llenara de X la función de salida F, mientras
que el botón “Ceros” de ceros y “Unos” de unos. Obvio!
Bastara con hacer clic, una o varias veces, en cualquiera de las celdas de la
función F para que cambie a 0, 1 o X
Una vez llenada la tabla hacemos clic en “Evaluar” y luego en “Salir”, para
regresar a la ventana anterior en donde haremos clic en el botón “Expr.
SOP simplificada” donde aparecerá la siguiente ventana:
35
Figura 2.40 Ventana de Expresión SOP simplificada
En ella se observa las expresiones lógicas simplificadas de las funciones
(F:1, F:2, …) y 4 botones:
Veitch-Karnough, que permite ver el mapa de Karnaugh de la función
con las agrupaciones de líneas que se han empleado para la simplificación
Figura 2.41 Ventana de mapa de Karnaugh
Nand/Nor que muestra una ventana con expresiones lógicas de F, pero
empleando solo operadores Nand o Nor
Visualizar circuito que muestra una ventana con el diagrama del circuito
simplificado, como se muestra en la figura 2.42
Figura 2.42 Ventana de diagrama del circuito
36
2.9.2. Circuitos secuenciales.
Al seleccionar el botón “Sistema secuencial. Autómatas” aparecerá la
ventana de la figura 2.43
Figura 2.43 Ventana de Sistema Secuencial
Al seleccionar la opción “Nuevo” del menú “Archivo” aparecerá la
ventana de la figura 2.44 que nos permitirá elegir el tipo de autómata con
el que se desea trabajar: Moore y Mealy (en el tipo Mealy tenemos que
ingresar el valor de la transición y el valor de la salida por cada flecha,
mientras que en el Moore ingresamos la transición en cada flecha y la
salida en cada círculo). Así también, se establece la cantidad de entradas y
salidas y sus nombres respectivos.
Figura 2.44 Ventana de Sistema Secuencial
El ejemplo a desarrollar es el autómata de la figura 2.31 y el tipo de
autómata, Mealy. Una vez establecido la cantidad de variables y sus
nombres se hace clic en “Aceptar” para que aparezca la ventana de la
figura 2.44 donde se procederá a dibujar el autómata.
Hay que reconocer que la interfaz grafica para dibujar el autómata es un
poco dura, pero con un poco de práctica se logrará dominarla.
Primero dibujaremos los estados, 4 en este caso. Para ello se hace clic en el
botón círculo de la ventana “Barra” (barra de herramientas) y luego
hacemos clic en el fondo blanco tantas veces como estados deseemos.
Para dibujar las transiciones, seleccionamos el botón flecha derecha de la
ventana “Barra” y luego hacemos clic en el estado inicial y luego en el
37
estado final los cuales quedarán unidos mediante una flecha. Esta
operación deberá repetirse tantas veces como transiciones tenga el
autómata.
Figura 2.45 Ventana donde se dibuja el Autómata
Para hacer cualquier modificación respecto a la posición de los estados, se
debe seleccionar primero la flecha tipo puntero de mouse y luego arrastrar
el elemento a mover (círculo o flecha). Así mismo se puede también
establecer los valores de las entradas y salidas; haciendo doble clic sobre
cualquier flecha, aparecerá una ventana donde se ingresará la entrada y
salida respectivamente
Para visualizar el circuito abrimos el menú “Ver circuito” y podemos elegir
la opción “Con flip-flops D”
Figura 2.46 Circuito secuencial con Flip-Flop tipo D
38
O la opción “Con flip-flops JK”
Figura 2.47 Circuito secuencial con Flip-Flop tipo JK
Otra opción interesante es “Simulación interactiva” del menú “Resultados”
donde se podrá simular las transiciones de los estados al tomar un valor
determinado la entrada “x” cada vez que se haga clic en el botón “CLK”
Figura 2.48 Ventana de simulación interactiva
39
2.10. Simulación de circuitos con Electronics WorkBench
Electronics Workbench (EWB) o Banco de Trabajo de Electrónica, es un
programa para diseñar y simular circuitos electrónicos y lógicos, desarrollado por
INTERACTIVE IMAGE TECHNOLOGIES LTD. El programa tiene una interfaz
gráfica con el usuario que lo hace muy intuitivo, cómodo de usar y rápido de
trabajar, razón por la cual no vamos a describir, con detalle, como hacer los
circuitos sino, mas bien, las herramientas a usar para simular nuestros circuitos.
Activar
simulación
Figura 2.50 Ventana principalde WorkBench
La figura 2.50 muestra la ventana principal del WorkBench v5.12, junto con
algunas cajas de herramientas que se van a emplear en el diseño y simulación de
circuitos digitales.
Para iniciar el diseño de un circuito, se hace clic en el botón respectivo de la barra
de herramientas, para que aparezca la caja de herramientas con la que deseamos
trabajar (Logic Gates - Compuertas Lógicas, por ejemplo). A continuación
seleccionamos el elemento de la caja de herramientas que queremos agregar y lo
arrastramos hacia el área de trabajo (ventana de fondo blanco), esta operación la
repetimos tantas veces como elementos deseemos.
Todos los elementos tienen una o más salidas, las cuales al señalarlas con el
puntero del mouse aparece un círculo negro sobre ellas, lo cual indica que
podemos iniciar la operación de conexión con otros componentes. Al arrastrar y
llegar a la salida (entrada) de otro componente, también aparecerá un círculo
negro, con lo cual podemos finalizar la conexión.
Al finalizar este proceso veremos una línea que conecta ambos componentes y así
sucesivamente se puede repetir esta operación con el resto de elementos.
La figura 2.51 muestra un circuito terminado. Como se aprecia es el diagrama de
un sumador completo de un bit (figura 2.18) al cual se le han agregado una batería
40
de 5v, 3 switch (A, B y C), 2 probadores (rojo y azul) para poder hacer la
simulación.
Figura 2.51 Circuito de un sumador completo de un bit
La batería se usa para simular los 0s y 1s digitales (0V. y 5V.) y los switch para
conmutar las entradas a 0V. o 5V. (0 o 1). Para establecer las propiedades de los
componentes basta con hacer doble clic sobre ellos y elegir la ficha respectiva
donde se establecerán los valores deseados. Por ejemplo, hacer doble clic sobre
batería, elegir la ficha “Value” y establecemos el valor de 5V, para los switch,
también, elegimos la ficha Value y establecemos la tecla (A, B y C
respectivamente) con la cual conmutará el switch.
Para iniciar la simulación hacer clic en el botón 0/1 que se encuentra en la esquina
superior derecha de la ventana. Bastará con presionar A, B o C para conmutar las
entradas para las compuertas. Cada vez que la salida sea 1, los probadores se
encenderán con el color respectivo.
El ejemplo anterior es sólo para iniciarnos en el proceso de simulación pero lo mas
apropiado es utilizar el Generador de Palabras (Word Generador) tal como se
muestra en la figura siguiente:
Figura 2.52 Circuito del sumador completo con el generador de palabras
Un Generador de Palabras es un instrumento que permite generar palabras de 16
bits y hacer que sus salidas contengan estos valores. Al conectar las salidas del
Generador de Palabras a las entradas de los diferentes componentes podemos
estudiar el comportamiento del circuito, o mejor dicho las salidas de éste, frente a
un conjunto de valores de entrada.
El Generador de Palabras es el 5to botón (Word Generador) de la caja de
herramientas Instruments (Instrumentos) y al hacer doble clic sobre él aparecerá
la ventana de la figura 2.53, con la cual podemos configurarlo.
41
Figura 2.53 Ventana de configuración del Generador de Palabras
En la parte izquierda hay una lista donde se puede ingresar las palabras en
hexadecimal (4 dígitos) que deseamos generar. Esto también lo podemos hacer
ubicándonos primero en la posición dentro de la lista donde deseamos insertar la
palabra y luego en la parte inferior derecha (Binary) escribir el valor en binario
(16 dígitos).
En el área Address se puede ver:
· Edit.- Muestra el valor de la palabra a generar, ingresada o editada.
· Current.- Cuando se esta simulando, muestra el valor actual que se está
generando o que esta presente en las salidas del generador.
· Initial.- Muestra o establece la dirección de la primera palabra a generar.
· Final.- Muestra o establece la dirección de la última palabra a generar.
En Frecuency se establece la frecuencia con la que se generaran las palabras. Para
la simulación es recomendable 1 Hz, pero se puede cambiar a kHz o MHz
Finalmente en la parte superior derecha se encuentran 4 botones que permiten
establecer el ciclo de generación de las palabras
· Cycle.- Permite generar las palabras en forma cíclica, es decir que una vez
que se genero la última, continúa con la primera y así sucesivamente.
· Burst.- Una vez generada la última palabra se detiene.
· Step.- En esta modalidad, cada vez que se desee generar una palabra se tiene
que hacer clic en este botón.
· Breakpoint.- Sirve para crear puntos de parada, es decir que, cuando se vaya
a generar cierta palabra establecida como Breakpoint el simulador se detiene.
Para ello sólo basta seleccionar la palabra y hacer clic en este botón
· Pattern.- Muestra una ventana que permite establecer la forma como se
llenará la lista de palabras:
v Clear buffer: Limpia la lista de palabras (la llena de ceros).
v Open: Carga la lista de palabras desde un archivo texto.
v Save: Graba en un archivo texto la lista de palabras.
v Up counter: Carga la lista de palabras desde el 0000 hasta el 03FF.
v Down counter: Carga la lista de palabras desde el 03FF hasta el 0000.
v Shift right: Carga la lista de palabras con potencias de 2 (decrecientes).
v Shift left: Carga la lista de palabras con potencias de 2 (crecientes).
42
Otro instrumento interesante es el Convertidor Lógico (Logic Converter). Es el
7mo botón de la caja de herramientas Instruments. Este instrumento permite
generar la tabla de verdad, la expresión booleana original y simplificada a partir de
un circuito. También permite crear una tabla de verdad y a partir de ella las
expresiones booleanas correspondientes así como el circuito respectivo.
La figura 2.54 muestra las conexiones que se deben realizar para evaluar la salida
F del circuito de la figura 2.3.
Figura 2.54 Conexión del Convertidor Lógico
Igual que el caso anterior, hacer doble clic sobre el Convertidor Lógico para que
aparezca la ventana de la figura 2.55 que es donde se visualizan los resultados
Figura 2.54 Ventana del Convertidor Lógico
·
·
·
Con el primer botón, se generará la tabla de verdad con los respectivos valores
de la función de salida
Con el segundo botón se obtiene la expresión booleana tomada directamente
de la tabla, sin simplificar (maxtérminos).
Con el tercer botón se obtiene la expresión booleana simplificada
También se puede trabajar sin tener un circuito, generando una tabla de verdad o
ingresando una expresión booleana.
En el primer caso, se hace clic sobre las variables que se van a usar (A, B, C,…H)
y en forma automática se va generando la tabla de verdad. Luego hay que ubicarse
sobre los valores que aparecen a la derecha (función de salida) y establecer los
nuevos. Ahora ya podemos hacer uso del segundo, tercero, quinto y sexto botón.
43
En el segundo caso se ingresa una expresión booleana en el rectángulo blanco de
la parte inferior de la ventana, con lo que luego se podrá hacer uso de los botones
cuarto, quinto y sexto
·
·
·
Con el cuarto botón, dada una expresión booleana, se obtiene la tabla de
verdad a partir de dicha expresión.
Con el quinto botón, a partir de una expresión booleana, se obtiene el circuito
o diagrama.
Con el sexto botón se obtiene el diagrama pero compuesto por sólo
compuertas NAND
Ahora veamos un circuito secuencial.
Al diagrama de la figura 2.37 se le ha agregado una batería y witch, para simular
los valores de la entrada X. Algo semejante se pudo haber usado para generar la
señal de reloj (CLK) que se encarga de sincronizar los flip-flops, pero en su lugar
es mejor usar un Generador de Señales (Function Generator) tal como se puede
ver en la figura 2.55
Figura 2.55 Circuito con Generador de Señales
El Generador de Señales, es un instrumento que se usa para generar 3 tipos de
señales u ondas: Sinusoidal, triangular y cuadrada
Haciendo doble clic en el Generador de Señales aparecerá una ventana que
permitirá establecer la configuración de éste. Aquí se puede seleccionar el tipo de
señal, frecuencia, amplitud, ciclo útil y desplazamiento. Ver figura 2.56
Figura 2.56 Generador de Señales
44
2.11. Ejercicios resueltos y propuestos
2.11.1. Resueltos
a) Simplificar AB+A(CD+CD´)
AB+A(C(D+D´)
AB+A(C(1))
AB+AC
A(B+C)
b) Simplificar (BC´+A´D)(AB´+CD´)
BC´AB´+BC´CD´+A´DAB´+A´DCD´
ABB´C´+BC´CD´+A´AB´D+A´CDD´
AC´ + BD´ + B´D + A´C
AC´+A´C+ BD´+ B´D
AÅC+BÅD
c) Dada la función boaleana: F=XY´Z+X´Y´Z+XYZ
i.
Listar la tabla de verdad
Los términos que conforman la expresión booleana son los
valores de las variables para las cuales F es 1, por consiguiente:
Para XY´Z=101, X´Y´Z=001, XYZ=111 F=1 entonces:
X
0
0
0
0
1
1
1
1
Y
0
0
1
1
0
0
1
1
Z
0
1
0
1
0
1
0
1
F
0
1
0
0
0
1
0
1
ii.
Simplificar la expresión booleana
XY´Z+X´Y´Z+XYZ
(X+X´)Y´Z+XYZ
(1)Y´Z+XYZ
Y´Z+XYZ
(Y´+XY)Z
((Y´+X)(Y´+Y))Z
((Y´+X)(1))Z
(Y´+X)Z
Y´Z+XZ
iii.
Dibujar el diagrama lógico original y el simplificado
45
d) Simplificar la siguiente función usando mapas de Karnaugh
F(x,y,z)= ∑(1,2,3,6,7)
La función original es: F=X´Y´Z+X´YZ´+X´YZ+XYZ´+XYZ
Z´
Z
X´Y´
0
0
1
1
X´Y
2
1
3
1
XY
6
1
7
1
XY´
4
0
5
0
La función simplificada quedará: F=X´Z+Y
e) Simplificar la siguiente función usando mapas de Karnaugh
F(x,y,z)= ∑(0,2,3,4,6)
La función original es: F=X´Y´Z´+X´YZ´+X´YZ+XY´Z´+XYZ´
Z´
Z
0
X´Y´
1
1
0
2
X´Y
1
6
XY
F=Z´+X´Y
7
1
0
4
XY´
La función simplificada quedará:
3
1
5
1
0
f) En una cierta empresa los cuatro directivos se distribuyen las acciones
según A=45%, B=30%, C=15% y D=10%. Diseñar una máquina de
escrutinio sabiendo que cada miembro tiene un porcentaje de voto
igual a su número de acciones y que para aprobar una moción los votos
afirmativos deben superar el 50 %
Cada vez que A=1 se deberá sumar 45% al resto de los votos, si B=1
se debe adicionar un 30% más, si C=1 un 15% más y si D=1 un 10%
más. Si al final la suma de los porcentajes es mayor que 50% entonces
F=1. Con lo anterior se construye la tabla siguiente:
0
1
2
3
4
5
6
7
A
0
0
0
0
0
0
0
0
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
0
0
0
0
0
0
0
1
8
9
10
11
12
13
14
15
A
1
1
1
1
1
1
1
1
B
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
D
0
1
0
1
0
1
0
1
F
0
1
1
1
1
1
1
1
La expresión booleana resultante es:
F=A´BCD+AB´C´D+AB´CD´+AB´CD+ABC´D´+ABC´D+ABCD´+ABCD
Simplificándola ya sea por álgebra booleana o por mapas de karnaugh
quedara:
F=AB+AC+AD+BCD=A(B+C+D)+BCD
46
El diagrama lógico del dispositivo es:
g) Se desea gobernar un motor desde 4 interruptores: A,B,C y D de forma
que entre en funcionamiento si están cerrados 3 y sólo 3 de ellos.
1, 2, 4 y 8 son números con 3 bits igual a 0, por lo tanto:
F(A,B,C,D)= ∑(1,2,4,8)
Luego: F=A´B´C´D+A´B´CD´+A´BC´D´+AB´C´D´
Al no poderse simplificar el diagrama lógico queda:
h) Un circuito secuencial tiene 2 flip-flops D: A y B; 2 entradas X y Y, y
una salida Z. Las ecuaciones de entrada de los flip-flops y la salida del
circuito son como sigue: DA=X´Y+XA, DB=X´B+XA y Z=B
i. Tabular la tabla de estadosDibujar el diagrama lógico del circuito
Estado actual
A
B
0
0
0
0
0
0
0
0
0
1
0
1
0
1
0
1
Entradas
x
y
0
0
0
1
1
0
1
1
0
0
0
1
1
0
1
1
Estado nuevo
A
B
0
0
1
0
0
0
0
0
0
1
1
1
0
0
0
0
Salida
z
0
0
0
0
1
1
0
0
47
Estado actual
A
B
1
0
1
0
1
0
1
0
1
1
1
1
1
1
1
1
Entradas
x
y
0
0
0
1
1
0
1
1
0
0
0
1
1
0
1
1
Estado nuevo
A
B
0
0
1
0
1
1
1
1
0
1
1
1
1
1
1
1
Salida
z
0
0
1
1
1
1
1
1
Con las ecuaciones de entrada se llena la tabla anterior, recordando
que DA es el nuevo estado del flip-flop A y DB del flip-flop B es
decir que: A=DA=X´Y+XA y B=DB=X´B+XA
ii. Dibujar el diagrama lógico del circuito.
iii. Dibujar el diagrama de transición de estados.
00/0
00/1
10/0
(10|11)/0
00
01
11/0
01/0
00/0
01/1
10
01/0
00/1
11
(10|11)/1
01/1
10/1
11/1
Donde el rotulado de las flechas significa: xy/z
i) Diseñe un contador binario de 2 bits usando flip-flop JK. El contador
debe tener una entrada X la cual cuando es 0 el contador es ascendente
y cuando X=1, descendente.
Como el contador es de 2 bits significa que se va a requerir de 2 flipflop y por consiguiente existirán 4 estados 00, 01, 10 y 11 que su vez
se corresponderán con las salidas deseadas 0, 1, 2 y 3, es decir que no
se requiere de salida alguna ya que el estado o salida del flip-flop será
la salida del contador
48
Primero diseñaremos el diagrama de estados de transición
0
00
01
1
1
0
0
1
1
11
10
0
Luego, haciendo uso de la tabla de excitación para flip-flop JK, la tabla
de estados
Estado actual
Q0
A
B
0
0
0
0
0
1
0
1
1
0
1
0
1
1
1
1
Entrada
X
0
1
0
1
0
1
0
1
Estado nuevo
Q1
A
B
0
1
1
1
1
0
0
0
1
1
0
1
0
0
1
0
FF-A
JA
0
1
1
0
?
?
?
?
FF-B
KA
?
?
?
?
0
1
1
0
JB
1
1
?
?
1
1
?
?
KB
?
?
1
1
?
?
1
1
Y mediante mapas de Karnaugh hallar JA, KA, JB y KB en función de A,
ByX
JA
X´
X
0
1
A´B´
0
A´B
1
AB
?
AB´
?
2
6
4
1
3
0
7
?
5
?
JA=BX´+B´X
KA
X´
X
0
1
A´B´
?
A´B
?
AB
1
AB´
0
2
6
4
?
3
?
7
0
5
1
KA=BX´+B´X
JB
X´
X
0
1
A´B´
1
A´B
?
AB
?
AB´
1
2
6
4
JB=1
1
3
?
7
?
5
1
KB
X´
X
0
A´B´
?
A´B
1
AB
1
AB´
?
1
?
2
3
1
6
7
1
4
5
?
KB=1
Finalmente usando las ecuaciones booleanas diseñamos el diagrama
lógico
49
2.11.2. Propuestos
a) Simplificar X´Z´ + Y´Z´ + YZ´ + XY
b) Simplificar (A+B)(A´+C)(B´+C´)
c) Dada la función boaleana: AC´ + B´D + A´CD + ABCD
i.
Listar la tabla de verdad
ii.
Simplificar la expresión booleana
iii.
Dibujar el diagrama lógico original y simplificado
d) Indicar, explicando su respuesta, cual de las siguientes igualdades es
correcta.
i.
a b + a c + c b = (a + b) ( a + c ) ( c + b )
ii.
(a + b + c )( a + b + c ) + a b = ( a b c + a b c) ( a + b )
iii.
a (a Å c) = a b Å a c
e) Simplificar la siguiente función usando mapas de Karnaugh
F=A´B´C´+A´BC+ABC+AB´C´+AB´C
f) Se desea controlar dos motores M1 y M2 por medio de los contactos de
tres interruptores A, B y C, de forma que se cumplan las siguientes
condiciones:
i.
Si A está cerrado y los otros dos no, se activa M1.
ii.
Si C está cerrado y los otros dos no, se activa M2.
iii.
Si los tres interruptores están cerrados se activan M1 y M2.
Para el resto de condiciones los motores estarán parados.
g) Diseñe un circuito lógico que tenga 4 entradas y una salida. Las 4
entradas son para ingresar un número de 4 bits y la salida debe ser 1
cuando el número sea mayor que 2 y menor que 8.
h) Diseñe un contador módulo 8 (diagrama lógico y diagrama de estados)
con flip-flop tipo D.
i) Dado el siguiente diagrama de estados diseñe el diagrama lógico
usando flip-flops tipo JK
0
0
1
1
1
1
0
0
50
III COMPONENTES DIGITALES
3.1. Registros.
El uso más común de los flip-flops es para el almacenamiento de datos o
información. Los datos generalmente se almacenan en grupos de flip-flops
llamados registros, donde cada flip-flop es capaz de almacenar un bit de
información. Un registro de N bits es un grupo de N flip-flops y puede almacenar
cualquier información binaria de N bits.
En realidad, un registro está conformado por un conjunto de flip-flops, que se
encargan de almacenar o retener la información y un conjunto de compuertas que
controlan cuándo y cómo se transfiere la información.
Antes de ver algunos tipos de registros, hablemos primero de las entradas
asíncronas de los flip-flops. Estas entradas aparecen en la parte superior (Preset) e
inferior (Reset) de cada flip-flop y permiten establecer a 0 o 1 la salida,
independientemente de la entrada o de la señal del reloj. El comportamiento del
flip-flop se puede apreciar en la siguiente tabla
PRESET
0
0
1
RESET
0
1
0
1
1
SALIDA
1 (No se utiliza)
1
0
Se sincroniza con
la entrada
3.1.1. Registro simple (de 4bits).
Es un registro que está compuesto por sólo flip-flops.
Según la tabla anterior, si PRESET=1, RESET=1 y llega a los flip-flops un
flanco positivo del reloj, entonces S0=E0, S1=E1, S2=E2 y S3=E3, es decir
que, la salida estará sincronizada con la entrada. Cuando PRESET=1,
RESET=0, entonces S0=S1=S2=S3=0 que es equivalente a limpiar el
registro o hacerlo cero. Nótese que PRESET siempre será 1, ver figura 3.1
Figura 3.1 Registro simple de 4 bits sin compuertas
51
3.1.2. Registro de carga paralela.
Se trata de un registro cuyas entradas E no son transferidas a las salidas S
mientras no se aplique una señal de carga L. Cuando L=0, D deberá
permanecer sin cambios (D=Q) y cuando L=1, D deberá ser igual a la
entrada (D=E), ya que en el siguiente pulso de reloj D será transferido a Q
o sea S. Con esta información se puede construir la siguiente tabla de
verdad, para flip-flop tipo D:
L
0
0
0
0
1
1
1
1
E
0
0
1
1
0
0
1
1
Q
0
1
0
1
0
1
0
1
D
0
1
0
1
0
0
1
1
De la tabla, se obtiene la siguiente función lógica:
D = L´E´Q + L´EQ + LEQ´ + LEQ
la cual al simplificarla quedará:
D = L´Q + LE
Con la expresión anterior se puede diseñar un registro de un bit, bastará
con replicar éste, tantas veces como bits se desea que tenga el registro. Ver
el diagrama del registro de 4 bits de la figura 3.2
Figura 3.2 Registro 4 bits de carga paralela
52
3.1.3. Registro de corrimiento
Es un registro con la característica de desplazar sus bits almacenados, una
posición con cada pulso de reloj.
En la figura 3.3 muestra un registro de 4 bits con entrada serial E y salida
serial S. Como se puede observar la salida Q del primer flip-flop está
conectado con la entrada D del segundo flip-flop, la salida Q del segundo
con la entrada del tercero y así sucesivamente, con esto se logra que en
cada pulso de reloj, la salida de un flip-flop pase a ser la entrada del
siguiente, lo cual genera un corrimiento de bits.
En este caso es un registro de 4 bits, el bit que entra por la entrada E
aparecerá en la salida S después de 4 pulsos de reloj.
Figura 3.3 Registro de corrimiento de 4 bits
3.1.4. Registro de corrimiento con carga paralela
Si analizamos el diagrama de la figura 3.2 las salidas de las compuertas
OR (que luego serán las entradas D) serás 1: si L=1 y E=1 o si L=0 y Q=1.
En otras palabras, si L=1, la entrada D del flip-flop será igual al valor de la
entrada E, en caso contrario (L=0) será igual a la entrada de la primera
compuerta AND que en este caso es la salida del mismo flip-flop, logrando
mantener sin cambios la salida. Ahora, si queremos generar un corrimiento
cuando L=0 (ya no mantener sin cambios), entonces la salida Q de un flipflop tiene que estar conectada a la compuerta AND del siguiente flip-flop
para transferirla a la entrada D (en el siguiente pulso de reloj) del flip-flop
que se encuentra a continuación, tal como se muestra en la figura 3.4
Figura 3.4 Registro de corrimiento con carga paralela
53
De la figura 3.4 se obtienen las siguientes ecuaciones lógicas:
D0=S0=ESerL´+ E0L
D1=S1=S0L´+E1L
D2=S2=S1L´+E2L
D3=S3=SSer=S2L´+E3L
Cuando L=0, el registro realiza una carga serial a través de la entrada ESER. En cada pulso de reloj el valor de esta entrada es transferida a la
salida S0, lo que había en S0 es transferido a S1 y así sucesivamente hasta
llegar a S2 que es transferido a S3 (S-SER) que es la salida serial.
Cuando L=1, en cada pulso de reloj, los valores de las entradas E0, E1, E2 y
E3 son transferidas a S0, S1, S2 y S3 respectivamente.
3.2. Contadores.
Es un circuito secuencial sincronizado cuyo diagrama de estados contiene un solo
ciclo, es decir que en cada pulso de entrada, el circuito pasa por una secuencia de
estados predeterminados. Estos circuitos se usan para contar el número de
ocurrencias de un evento y son útiles para generar señales de tiempo.
3.2.1. Contadores asíncronos o de propagación.
Es un contador que está conformado por sólo flip-flops y ningún otro
componente. En este tipo de contador no todos los flip-flops cambian de
estado simultáneamente debido a que la señal de reloj se aplica solamente
al primer flip-flop el cual al tener sus entradas J y K en 1 (al igual que el
resto de flip-flops) complementará su salida Q en cada pulso. Esta salida Q
a su vez será la señal de reloj del siguiente flip-flop y así sucesivamente.
La salida Q del primer flip-flop es el bit menos significativo del contador,
ver figura 3.5.
Este tipo de contador es el más lento de todos.
Figura 3.5 Contador asíncrono
Ver diagrama de tiempos
S0
S1
S2
S3
54
3.2.2. Contadores sincrónicos.
Todos los flip-flops de este tipo de contador están conectados a la misma
señal de reloj, por lo tanto, las salidas de los flip-flops se actualizan al
mismo tiempo.
El contador que se va a estudiar es un contador de 4 bits con entrada de
activación, es decir, que cuando la entrada E sea 1 inicie o continué el
conteo y cuando sea 0 se detenga y mantenga sin cambios las salidas de los
flip-flops.
Observar la tabla de estados siguiente:
E
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
Estado inicial
Q3 Q2 Q1 Q0
Cualquier valor
0
0
0
0
0
0
0
1
0
0
1
0
0
0
1
1
0
1
0
0
0
1
0
1
0
1
1
0
0
1
1
1
1
0
0
0
1
0
0
1
1
0
1
0
1
0
1
1
1
1
0
0
1
1
0
1
1
1
1
0
1
1
1
1
Estado siguiente
Q3 Q2 Q1 Q0
Sin cambios
0
0
0
1
0
0
1
0
0
0
1
1
0
1
0
0
0
1
0
1
0
1
1
0
0
1
1
1
1
0
0
0
1
0
0
1
1
0
1
0
1
0
1
1
1
1
0
0
1
1
0
1
1
1
1
0
1
1
1
1
0
0
0
0
3
JK
00
0X
0X
0X
0X
0X
0X
0X
1X
X0
X0
X0
X0
X0
X0
X0
X1
2
JK
00
0X
0X
0X
1X
X0
X0
X0
X1
0X
0X
0X
1X
X0
X0
X0
X1
1
JK
00
0X
1X
X0
X1
0X
1X
X0
X1
0X
1X
X0
X1
0X
1X
X0
X1
0
JK
00
1X
X1
1X
X1
1X
X1
1X
X1
1X
X1
1X
X1
1X
X1
1X
X1
Resolviendo el sistema de ecuaciones lógicas se obtiene:
J0 = K0 = E
J1 = K1 = EQ0
J2 = K2 = EQ0Q1
J3 = K3 = EQ0Q1Q2
Ver figura 3.6
Figura 3.6 Contador síncrono
55
3.3. Decodificadores – Codificadores.
3.3.1. Decodificadores
Es un circuito lógico que acepta un conjunto de N entradas que representan
números binarios y que activa solamente 1 de las M salidas, que
corresponde a dicho dato de entrada. Donde 2N≥M.
Por ejemplo un decodificador de 2 a 4 con entradas I1 e I0, por donde se
puede ingresar números de 2 bits (de 0 a 3). Cuando el valor ingresado es 0
(00) se activará sólo la salida S0, cuando sea 1(01) sólo S1, cuando sea 2
(10) sólo S2 y cuando sea 3 (11) sólo se activará S3. Si además se desea
contar con una entrada de activación E, la tabla de este circuito quedará
como se muestra a continuación:
E
0
1
1
1
1
I1
x
0
0
1
1
I0
x
0
1
0
1
S3
0
0
0
0
1
S2
0
0
0
1
0
S1
0
0
1
0
0
S0
0
1
0
0
0
Figura 3.7 Tabla de verdad de un decodificador de 2 a 4
Cuando la entrada de activación E es 0, no importa que valor tengan las
entradas I, las salidas Si serán todas 0.
De la tabla anterior se puede fácilmente obtener el diagrama lógico del
decodificador de 2 a 4, como se muestra en la figura 3.7.
Figura 3.8 Diagrama lógico del decodificador de 2 a 4
Se puede combinar 2 o más decodificadores con entradas de activación
para formar un decodificador con mayor número de salidas. Así por
ejemplo, con 5 decodificadores de 2 a 4 con entrada de activación se puede
obtener un decodificador de 4 a 16. La idea básica es que un decodificador
controle a los otros 4 mediante sus entradas de activación. Las entradas de
este decodificador serán los 2 bits más significativos (I3 e I2) del número
binario a ingresar y sus salidas se conectaran a las entradas de activación
de los otros 4 decodificadores, de esta forma cuando los bits I3 e I2 sean 00
56
se activará el primer decodificador; cuando sea 01, el segundo; 10 el
tercero y 11 el cuarto.
Los bits menos significativos (I1 e I0) se conectan a las entradas de cada
uno de los cuatro decodificadores y son los que establecerán la salida a
activar del decodificador activo.
Por ejemplo, si los bits menos significativos (I1 e I0) son 1 y 0, se deberán
activar las salidas S2, S6, S10 y S14, pero son los bits más significativos los
que definirán el decodificador a activar. Si estos son 0 y 1 (el valor binario
será 0110) se activará sólo el segundo decodificador y por lo tanto la única
salida que se activará será S6. Pero si éstos hubieran sido 1 y 0 (el valor
binario sería 1010) se activará sólo el tercer decodificador y entonces la
salida que se activará será S10.
Esto se puede observar en la figura 3.9
S0
S1
S2
S3
I0
I1
S4
S5
S6
S7
I2
S8
S9
S10
S11
I3
E
S12
S13
S14
S15
Figura 3.9 Decodificador de 4 a 16 con decodificadores de 2 a 4
3.3.2. Codificadores
Este circuito hace la función inversa al Decodificador, es decir, que acepta
una sola entrada (de las M posibles) y activa 0 o varias salidas de las N
posibles codificando un número binario. Aquí también se cumple que
M≤2N.
Por ejemplo un codificador de 4 a 2 tiene 4 entradas I, de las cuales sólo
una puede estar activa a la vez, y 2 salidas S que forman un número binario
de 2 bits, por lo tanto si se activara la entrada I2 en las salidas S1 y S0
debería formarse el número binario 10 y si se activara la entrada I0 la salida
binaria será 00. Si seguimos con este análisis se podrá construir la tabla de
la figura 3.10
I3
0
0
0
1
I2 I1
0 0
0 1
1 0
0 0
Resto
I0
1
0
0
0
S1
0
0
1
1
x
S0
0
1
0
1
x
Figura 3.10 Tabla de verdad de un codificador de 4 a 2
57
De la tabla anterior se puede obtener una expresión de suma de productos
y otra de producto de sumas:
S1=I´1I´0
S1=I3+I2
S0=I´2I´0
S0=I3+I1
(suma de productos)
(producto de sumas)
Con las que se puede diseñar dos diagramas lógicos. Ver figura 3.11
Figura 3.11 Diagramas lógicos de un codificador de 4 a 2
Pero qué pasa cuando se activa más de una entrada a la vez?
En estos casos sólo se debe tener en cuenta la entrada (bit) más
significativa o la entrada menos significativa.
En el ejemplo siguiente se va a considerar el bit menos significativo para
un codificador de 4 a 2. No importa cuantas entradas se activen a la vez
sólo se tomará en cuenta la entrada menos significativa. La tabla de verdad
y el diagrama de este codificador se pueden apreciar en las figuras 3.12 y
3.13 respectivamente.
I3
x
x
x
1
I2 I1
x x
x 1
1 0
0 0
Resto
I0
1
0
0
0
S1
0
0
1
1
x
S0
0
1
0
1
x
Figura 3.12 Tabla de verdad de un codificador de 4 a 2
con prioridad de bit menos significativo
Figura 3.13 Diagrama lógico de un codificador de 4 a 2
con bit menos significativo de prioridad
58
3.4. Multiplexores y Demultiplexores.
3.4.1. Multiplexores.
También llamado selector de datos. Es un circuito combinatorio que acepta
2N entradas de datos y permite sólo a una de ellas alcanzar la salida. La
selección de una de esas 2N entradas se hace a través de N entradas,
llamadas entradas de selección.
Por ejemplo un multiplexor de 2 a 1, implica 2 entradas de datos I y 1
entrada de selección S, además de una entrada de activación E. cuando la
entrada E=0 no importa que valores tengan las entradas, las salida Z será 0.
Cuando E=1, si S=0 entonces Z=I0 en caso contrario (S=1) Z=I1. Mirar la
tabla de verdad y tabla de funciones de la figura 3.14
E
0
1
1
1
1
1
1
1
1
I1
x
0
0
0
0
1
1
1
1
I0
x
0
0
1
1
0
0
1
1
S
x
0
1
0
1
0
1
0
1
Z
0
0
0
1
0
0
1
1
1
E
0
1
1
S
X
0
1
Z
0
I0
I1
Figura 3.14 Tabla de verdad y de funciones de un
multiplexor de 2x1
De la tabla de verdad, fácilmente se puede diseñar el diagrama lógico
mostrado en la figura 3.15
Figura 3.15 Diagrama lógico de un multiplexor de 2x1
Para un multiplexor de 4 a 1, se necesitarán 4 entradas I, 2 entradas de
selección S y una entrada de activación E, lo cual suma en total 7 entradas.
Para poder mostrar la tabla de verdad se necesitaría 128 filas (7 variables),
por eso es más práctico usar una tabla de funciones para representar el
comportamiento de un multiplexor.
59
En la figura 3.16 se puede observar la tabla de funciones que muestra
como la salida Z depende de las entradas Ii y de las entradas de selección
Si. Así también se muestra el respectivo diagrama lógico.
E
0
1
1
1
1
S1
x
0
0
1
1
S0
x
0
1
0
1
Z
0
I0
I1
I2
I3
Figura 3.16 Tabla de función y diagrama lógico de un multiplexor de 4x1
Al igual que los decodificadores, también se puede obtener multiplexores
con un número mayor de entradas a partir de multiplexores menores. Por
ejemplo, se puede formar un multiplexor de 8 a 1 con 2 multiplexores de 4
a 1.
Las entradas de selección S1 y S0 se conectan a las respectivas entradas de
selección de los multiplexores. Estas serán las que seleccionen las parejas
I0-I4, I1-I5, I2-I6 o I3-I7 para que pasen a la salida Z. Pero será finalmente S2,
que está conectado a las entradas E de los multiplexores, el que determine
cual de los 2 multiplexores se activará, entonces si S1 y S0 es, por ejemplo,
10 las entradas I que podrán salir son I2 e I6. Si S2=0 entonces Z=I2 y sino
(S2=1) Z=I6. Ver figura 3.17
Figura 3.17 Multiplexor de 8x1 con multiplexores de 4x1
60
3.4.2. Demultiplexores.
Es un circuito que hace la operación inversa de un multiplexor, es decir,
toma una sola entrada de datos y la distribuye en una de 2N salidas,
utilizando para ello N entradas de selección.
El ejemplo que se va a estudiar es un demultiplexor de 1 a 4 con entrada E
de activación. Este demultiplexor tiene una entrada I, dos entradas S de
selección una entrada E y cuatro salidas Q con lo que se puede diseñar la
siguiente tabla de verdad y su tabla resumen, figura 3.18.
E
0
1
1
1
1
1
1
1
1
I
x
0
0
0
0
1
1
1
1
S1
x
0
0
1
1
0
0
1
1
S0
x
0
1
0
1
0
1
0
1
Q3
0
0
0
0
0
0
0
0
1
Q2
0
0
0
0
0
0
0
1
0
Q1
0
0
0
0
0
0
1
0
0
Q0
0
0
0
0
0
1
0
0
0
E
0
1
1
1
1
S1
x
0
0
1
1
S0
x
0
1
0
1
Q3
0
0
0
0
I
Q2
0
0
0
I
0
Q1
0
0
I
0
0
Q0
0
I
0
0
0
Figura 3.18 Tabla de verdad y tabla resumen de un demultiplexores de 1 a 4
De la tabla de verdad se obtienen las expresiones lógicas:
Q0=E I S´1 S´0
Q2=E I S1 S´0
Q1=E I S´1 S0
Q3=E I S1 S0
Y con ellas se puede diseñar el diagrama lógico de la figura 3.19
Figura 3.19 Diagrama lógico de un demultiplexores de 1 a 4
61
3.5. Ejercicios resueltos y propuestos
3.5.1. Resueltos.
a) Diseñe un contador módulo 6 (que cuente desde 0 hasta 5) usando flipflops tipo JK.
Como son 6 estados debe haber por lo menos 3 flip-flops (23=8) A, B y
C (flip-flops JK en este caso). Las 3 salidas Q de los flip-flops
constituirán los dígitos binarios. Por ejemplo, cuando los flip-flops A,
B y C tengan los valores 010 (2), respectivamente, al llegar el siguiente
pulso de reloj deberán pasar a 011 (3) y luego a 100 (4) y así
sucesivamente. Cuando el contador llegue a 101 (5) deberá pasar luego
a 000 (0) ya que es modulo 6. En la tabla siguiente se muestra la tabla
de estados de este contador.
Estado actual
Q0
A B C
0
0
0
0
0
1
0
1
0
0
1
1
1
0
0
1
0
1
1
1
0
1
1
1
Estado nuevo
Q1
A
B
C
0
0
1
0
1
0
0
1
1
1
0
0
1
0
1
1
1
0
x
x
x
x
x
x
FF-A
JA
0
0
0
1
x
x
x
x
KA
x
x
x
x
0
1
x
x
FF-B
JB
0
1
x
x
0
0
x
x
KB
x
x
0
1
x
x
x
x
FF-C
JC
1
x
1
x
1
x
x
x
KC
x
1
x
1
x
1
x
x
De la tabla anterior y usando Mapas de Karnaugh se obtienen las
siguientes expresiones:
JA = AC = QA.QC
JB = A´C = QA'.QC
JC = 1
KA = C = QC
KB = C = QC
KC = 1
Y con ellas el diagrama respectivo
Donde el bit más significativo es QA y el menos significativo QC
62
b) Analice el siguiente contador de 4 bits, el cual ha sido diseñado para no
seguir la secuencia completa de los 16 estados. Determine su
secuencia.
Analizando el diagrama podemos obtener las siguientes expresiones:
JA = KA = 1
JB = KB = QAQD
JC = KC = QAQB
JD = QAQBQC KD = QA
Aplicando Q1 = JQ´0 + K´Q0 Se completa la tabla siguiente:
Estado actual
Q0
A B
C
0
0
0
0
0
0
0
0
1
0
0
1
0
1
0
0
1
0
0
1
1
0
1
1
1
0
0
1
0
0
1
0
1
1
0
1
1
1
0
1
1
0
1
1
1
1
1
1
FF-A
D
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
JA
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
KA
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
FF-B
JB
0
0
0
0
0
0
0
0
0
1
0
1
0
1
0
1
KB
0
0
0
0
0
0
0
0
0
1
0
1
0
1
0
1
FF-C
JC
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
KC
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
FF-D
JD
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
KD
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
Estado nuevo
Q1
A B C D
1
0 0 0
1
0 0 1
1
0 1 0
1
0 1 1
1
1 0 0
1
1 0 1
1
1 1 0
1
1 1 1
0
0 0 0
0
1 0 0
0
0 1 0
0
1 1 0
0
1 1 0
0
0 1 0
0
1 0 1
0
0 0 0
Asumiendo que A es el bit más significativo y D el menos significativo
podemos concluir lo siguiente:
Si los flip-flops se inicializan con 0000 (0), con el siguiente pulso de
reloj pasaran a 1000 (8) y si vamos a la tabla veremos que de este
estado se pasará, luego, a 0000. Esto significa que sólo habrá 2 estados.
Pero si se inicializa con 0001 (1), la secuencia será la siguiente: 0001,
1001, 0100, 1100, 0110, 1110, 0101, 1101, 0010, 1010, 0010, 1010, …
Es decir que cuando entra al estado 1010 pasará a 0010, luego a 1010 y
así sucesivamente.
63
c) Construir un decodificador de 5 a 32 líneas, con cuatro decodificadores
de 3 a 8 líneas, con habilitación y un decodificador de 2 a 4 líneas.
Se debe tener en cuenta en el diagrama que la entrada inferior de cada
decodificador de 3x8 es la entrada de activación E. Las salidas S0,
S1,…, S7, para simplificar el diagrama, son representadas con un solo
conector cuando en realidad son 8, igual ocurre con el resto de salidas.
d) Diseñe el diagrama lógico de un decodificador de 2 a 4 líneas con
entrada de activación E, sólo usando compuertas NOR
Observando la tabla de verdad de la figura 3.7, se obtiene que:
S0 = EI´1I´0 = (E´+I1+I0)´ =(E´+(I1+I0)´´)´ = (E´+(I1+I0)´´)´
= E´ NOR (I1 NOR I0)´
S1 = EI´1I0 = (E´+I1+I´0)´ =(E´+(I1+I´0)´´)´ = (E´+(I1+I´0)´´)´
= E´ NOR (I1 NOR I´0)´
S2 = EI1I´0 = (E´+I´1+I0)´ =(E´+(I´1+I0)´´)´ = (E´+(I´1+I0)´´)´
= E´ NOR (I´1 NOR I0)´
S3 = EI1I0 = (E´+I´1+I´0)´ =(E´+(I´1+I´0)´´)´ = (E´+(I´1+I´0)´´)´
= E´ NOR (I´1 NOR I´0)´
No olvidar que: A´ = A NOR A
Con las expresiones anteriores se puede diseñar el diagrama del
decodificador de 2x4 tal como lo muestra la figura siguiente:
64
e) Los habitantes del planeta Xinus emplean el sistema de numeración
base 5 y usan un display de tres segmentos, tal como se muestra en la
figura, diseñe un decodificador (de binario) para controlar dicho
display.
0
1
2
3
4
Asumamos que el segmento: | es A, / es B, \ es C y N2N1N0 es un
número de 3 bits, con esto construimos la siguiente tabla de verdad:
N2
0
0
0
0
1
1
1
1
N1
0
0
1
1
0
0
1
1
N0
0
1
0
1
0
1
0
1
A
1
0
1
1
1
x
x
x
B
1
1
1
0
0
x
x
x
C
1
1
0
1
0
x
x
x
De la tabla de verdad obtenemos las siguientes expresiones lógicas
simplificadas:
A=N1 + N´0
B=N´1 N0 + N´2N´0
C=N´2 N´1 + N0
Y con las expresiones lógicas, el diagrama correspondiente:
f) Diseñar un circuito que eleve al cuadrado un número de 2 bits usando
un decodificador y compuertas NOR.
Como ya sabemos las salidas S3, S2, S1 y
S0 sólo una de ellas va a estar activa a la
vez y dependerá de las entradas I1 e I0 que
conformaran el número N de 2 bits.
Entonces lo que hay que hacer es diseñar un circuito con compuertas
NOR que tome como entradas S3, S2, S1, S0 y genere una nueva salida
D3, D2, D1, D0 que sea el cuadrado de N (I1I0)
65
Por consiguiente se tiene 4 variables S de entrada y 4 funciones D de
salida tal como se muestra en la siguiente tabla:
I1
0
0
1
1
I0
0
1
0
1
S3
0
0
0
1
S2 S1
0 0
0 1
1 0
0 0
Resto
S0
1
0
0
0
D3
0
0
0
1
x
D2
0
0
1
0
x
D1
0
0
0
0
x
D0
0
1
0
1
x
Usando mapas de Karnaugh fácilmente podemos determinar las
siguientes expresiones:
D0 = S2´S0 ´ = (S2+S0)´
D1 = 0
D2 = S2
D3 = S3
g) Construir un multiplexor de 16 a 1 línea con dos multiplexores de 8 a 1
líneas y uno de 2 a 1 línea.
I0
I1
.
.
.
I7
I8
I9
.
.
.
I15
S3 S2 S1 S0
Las 3 entradas de selección (S2, S1 y S0) de los MUX8x1 se conectan
entre si, de esta manera se selecciona la misma entrada en cada MUX,
por ejemplo la entrada I0 del primer MUX con la entrada I0 (I8) del
segundo MUX, la entrada I5 del primero con la entrada I5 (I13) del
segundo y así sucesivamente.
Las salidas de los 2 MUX8x1 se convierten en las 2 entradas del
MUX2x1 las cuales son seleccionadas con la cuarta entrada de
selección S3, finalmente lo que se obtiene es un MUX16x1 con 16
entradas I y 4 entradas de selección S.
66
h) Realizar la función F(A, B, C) = ∑ (1,3,5,6) utilizando un multiplexor
y una cantidad mínima de compuertas.
Usando solamente compuertas la solución sería:
F = ABC´ + B´C + A´C
Por lo tanto la solución a obtener debe ser más simple.
Al tener la función 3 entradas (A, B y C) será necesario como mínimo
un MUX de 2x1 por tener 3 entradas: dos I y una S.
Hay varias formas de plantear una solución, una de ellas es conectar la
entrada C a la entrada S de selección del MUX y las otras dos (A y B)
conectarlas mediante un circuito a las entradas I del MUX.
Por lo tanto, cuando C=0=S la salida Z=I0 y cuando C=1 la salida Z=I1,
tal como se muestra en las siguientes tablas.
A
0
0
1
1
B
0
1
0
1
C=0
0
0
0
0
Z=I0
0
0
0
1 (6)
A
0
0
1
1
B
0
1
0
1
C=1
1
1
1
1
Z=I1
1 (1)
1 (3)
1 (5)
0
De las tablas se obtiene que:
Cuando C=0 è I0(A,B) = AB
Cuando C=1 è I1(A,B) = A´B´ + A´B + AB´ = A´ + B´ = (AB)´
Ahora pasamos y dibujar el diagrama respectivo
i) Resolver el ejercicio anterior usando un MUX4x1.
En este caso se conectará las entradas B y C a las entradas de selección
S1 y S0 del MUX y la entrada A, mediante un circuito, a las entradas I.
Ver las siguientes tablas
A
0
1
B
0
0
C
0
0
Z=I0
0
0
Cuando BC=00 è I0(A) = 0
A
0
1
B
0
0
C
1
1
Z=I1
1 (1)
1 (5)
Cuando BC=01 è I1(A) = 1
67
A
0
1
B
1
1
C
0
0
Z=I2
0
1 (6)
Cuando BC=10 è I2(A) = A
A
0
1
B
1
1
C
1
1
Z=I3
1 (3)
0
Cuando BC=11 è I3(A)= A´
j) Diseñe un circuito que acepte como entrada un número de 4 bits (4
entradas) y tenga como salida el mismo número pero en forma serial
(Sugerencia utilice un MUX4x1 y uno o más flip-flop tipo JK).como
muestra el diagrama de bloques siguiente
1
0
1
1
CLK
1,1,0,1
Sea ABCD el número de 4 bits conectados a las entradas I0, I1, I2 e I3
del MUX4x1. Se tiene que diseñar un circuito que en forma
“secuencial” selecciones dichas entradas, es decir, que las entradas S
tomen los valores 00, 01, 10 y 11, en ese orden y como es obvio esto es
trabajo para un contador de 2 bits. Por consiguiente el diagrama
respectivo será el que se muestra en la siguiente figura:
68
3.5.2. Propuestos
a) Diseñe un contador módulo 5.
b) Analice el siguiente contador de 3 bits, el cual ha sido diseñado para no
seguir la secuencia completa de los 8 estados. Determine su secuencia.
Se debe tener en cuenta que las entradas inferiores de los flip-flops son
para resetear (poner a 0) cuando a éstas llegue un 0. Otro detalle a tener
en cuenta es que, la entrada de reloj de los flip-flops es de pendiente
negativa, es decir que la salida de flip-flops se actualizaran sólo cuando
la señal de reloj pase de 1 a 0.
c) Construir un decodificador de 3 a 8 líneas con entrada de activación,
con dos decodificadores de 2 a 4 líneas, con habilitación y un
decodificador de 1 a 2 líneas.
d) Diseñe el diagrama lógico de un decodificador de 2 a 4 líneas con
entrada de activación E, usando sólo compuertas NAND.
e) Diseñe un codificador de 8 a 3 con prioridad de bit más significativo.
f) Diseñe un circuito que sume 7 a un número de 3 bits usando un
multiplexor.
g) Resuelva el ejercicio anterior usando decodificadores
h) Realizar la función F(A, B, C) = ∑ (0,1,2,7) utilizando un MUX2x1 y
una cantidad mínima de compuertas.
i) Realizar el ejercicio anterior usando un multiplexor de 4x1.
j) Resuelva el ejercicio e) de los ejercicios resueltos pero para el sistema
base 7.
69
IV ORGANIZACIÓN Y DISEÑO BASICO DE COMPUTADORAS
4.1. ¿Qué es una computadora?
Es una combinación de dispositivos y circuitos digitales que pueden realizar una
secuencia programada de operaciones con un mínimo de intervención humana. A
la secuencia de operaciones se le denomina programa. El programa es un
conjunto de instrucciones codificadas que se almacena en la memoria interna de
la computadora con todos los datos que el programa requiere. Cuando a la
computadora se le ordena ejecutar el programa, ésta lleva a cabo las instrucciones
en el orden en que están almacenadas.
4.1.1. Organización básica
Cada computadora contiene 5 elementos o unidades esenciales:
a) Unidad aritmética lógica.- Realiza las operaciones aritmética y lógicas
como sumas, restas, multiplicaciones, Y, O y NO.
b) Unidad de memoria.- Almacena instrucciones y datos, así como los
resultados parciales y finales de un programa.
c) Unidad de control.- Interpreta las instrucciones tomadas de la memoria
una por una, luego envía las señales apropiadas a cada una de las
unidades para que la instrucción sea ejecutada.
d) Unidad de entrada.- Transmite instrucciones y datos del exterior a la
memoria.
e) Unidad de salida.- Transmite datos de la computadora al mundo
exterior.
4.1.2. Funcionamiento
Consideremos un casillero numerado desde el 0 hasta el 4095 (memoria)
en donde en cada casilla se ha puesto un sobre, el cual puede contener
instrucciones (código) o información (datos). La idea es ir abriendo los
sobres de las casillas en forma consecutiva (0, 1, 2, 3,..) y seguir las
instrucciones (programa) que se encuentran en ellos. Se empieza tomando
el sobre de la casilla 0 (pudo ser a partir de otra posición), se abre el sobre
y se lee la instrucción. Esta instrucción puede ser:
a) Una operación como sumar, restar, multiplicar, etc. y como toda
operación debe tener operandos. Dentro de la instrucción debe
indicarse donde se encuentras dichos operandos. Estos pueden estar
dentro de unas cajas especiales de fácil y rápida ubicación (Registros) o
dentro de alguna casilla. En todo caso la instrucción debe indicar el
número de la casilla (0,1,..4096) o el nombre de la caja (A, B, C o D
por ejemplo) donde se encuentran los operandos.
b) Una operación de saltar y dirigirse a otra casilla. Como se mencionó,
por defecto, la ejecución de las instrucciones se hace en forma
consecutiva, partiendo de la casilla donde se abrió el primer sobre,
pasando a la siguiente casilla, luego a la siguiente y así sucesivamente
hasta llegar a la última instrucción. Pero puede darse el caso que una
instrucción indique que debe saltarse a una determinada casilla, con lo
cual, el próximo sobre a abrir no será el de la siguiente casilla sino el
indicado en la instrucción.
Una vez leída la instrucción se procede a ejecutarla y luego se pasa a la
siguiente instrucción.
70
4.2. Los Registros
Durante la ejecución de un programa la computadora debe saber siempre en que
parte de la memoria (dirección) se encuentra la siguiente instrucción a ejecutar,
así como también cuál es la instrucción (código) que va a ejecutar o está
ejecutando.
Muchas de las instrucciones no se ejecutan en un sólo paso (ciclos de reloj) sino
que requieren de varios pasos o microinstrucciones las cuales necesitan almacenar
en algún medio los datos u operandos con los que están trabajando.
Para todos estos casos ese dispositivo de almacenamiento es el registro
4.2.1. Los registros de la computadora básica
Dada las características simples de la computadora, se requieren de sólo 8
registros cuyas funciones son las siguientes:
Registro de datos (DR).- Es un registro de 16 bits que puede contener un
operando de alguna operación aritmética - lógica.
Registro de dirección (AR).- Es un registro de 12 bits que contiene la
dirección de memoria a leer o escribir. Cada vez que la
computadora requiera leer o escribir en la memoria, este registro
debe contener la dirección a la cual se va a acceder. Como la
capacidad de la memoria de la computadora es de 4096 palabras,
bastará sólo un registro de 12 bits (212 = 4096).
Registro Acumulador (AC).- Es un registro de 16 bits que almacena los
resultados temporales y que está conectado directamente con la
unidad aritmética lógica. En otras palabras es el registro de
trabajo de la computadora.
Registro de instrucción (IR).- Es un registro de 16 bits que contiene la
instrucción en curso a ser decodificada y ejecutada.
Registro contador de programa (PC).- Es un registro de 12 bits que
contiene la dirección de memoria de la siguiente instrucción a
ejecutar.
Registro temporal (TR).- Es un registro de 16 bits que se utiliza para
almacenar datos temporales.
Registro de entrada (INPR).- Una vez realizada una entrada, este registro
de 8 bits contiene el byte que ha ingresado.
Registro de salida (OUTR).- Este registro de 8 bits contiene el byte que va
ser enviado hacia fuera.
Estos registros forman 3 grupos:
Registros de 16 bits (DR, AC, IR, TR)
Registros de 12 bits (AR, PC)
Registros de 8 bits (INPR, OUTR)
Los registros de 16 y 12 bits tienen características comunes. Sus entradas y
salidas de datos, están conectadas al bus y sus entradas de control son las
mismas:
Carga de datos (C).- Carga el registro con los datos de entrada.
Incremento (I).- Incrementa en 1 el contenido del registro.
Limpiado (L).- Borra o pone a 0 las salidas del registro
71
El diseño se hará para los registros de 16 bits siendo prácticamente lo
mismo para los de 12 bits. El registro deberá tener entradas de control que
le permitan realizar las operaciones mostradas en la tabla de la figura 4.1
L
0
0
0
1
C
0
0
1
X
I
0
1
X
X
Operación
Sin cambios
Incrementar contenido en 1
Cargar entrada de datos E
Establecer salidas S a 0
Figura 4.1 Tabla de funciones del registro
Para realizar el diseño de forma analítica, se necesitaría una tabla de 16
entradas de datos E, 3 entradas de control (L, C e I), 16 entradas de estados
inicial Q y 16 funciones de salida para J y K. Imposible de hacer!
Una alternativa es diseñar un registro de 4 bits y luego generalizarlo para
16, 32 o 64 bits. Pero aun así, se requiere 11 entradas (tabla de 2048 filas)
y 4 funciones de salida para J y K.
Una tercera opción es diseñar un registro de 4 bits con entrada L de
limpieza y entrada C de carga paralela, luego unirlo mediante otro circuito
a un contador de 4 bits con entrada de activación I (para poder incrementar
en 1).
El registro de 4 bits con carga paralela y limpieza
Según la tabla de la figura 4.1, L tiene prioridad sobre C, es decir, que si
L=1 la salida S será 0. Cuando L=0 y C=1, el dato E pasará a S y cuando
L=C=0 no habrá cambios en la salida. Por lo tanto, J y K deberán tener los
valores siguientes:
L
0
0
0
0
1
1
1
1
C
0
0
1
1
0
0
1
1
E
0
1
0
1
0
1
0
1
S=Q
Sin cambios
Sin cambios
0
1
0
0
0
0
J
0
0
0
1
0
0
0
0
K
0
0
1
0
1
1
1
1
Figura 4.2 Tabla de estados para un registro de 1 bit
La tabla muestra los valores que deben tomar J y K para obtener la salida S
(Q) correspondiente. Pero sólo es para un registro de 1 bit, hay replicar
tantas veces como bits se desea que tenga el registro. De la tabla se
obtienen las siguientes expresiones lógicas:
J = L´CE
K = CE´ + L
En términos generales par el i-ésimo bit: Ji = L´CEi Ki = CE´i + L
Más adelante a la salida J se le llamará X y a K, Y.
72
El contador de 4 bits con entrada de activación
El contador, es el diseñado en el capitulo 3, figura 3.6 (contador síncrono).
Sólo hay que cambiar el nombre de la entrada E por I, las expresiones
lógicas quedarán:
J0 = K0 = I
J1 = K1 = IQ0
J2 = K2 = IQ0Q1
J3 = K3 = IQ0Q1Q2 ; Ji = Ki pasaran a llamarse Zi
El circuito de unión
Para simplificar, sólo se va a diseñar el modulo para el i-ésimo bit.
Se supone que las entradas L y C, del registro de carga paralela y limpieza,
va a generar las salida X y Y (Circ1), que se conectarán, respectivamente,
a las entrada J y K del flip-flop. Pero la entrada I, del contador, generará la
salida Z que también se debe conectar a las entradas J y K (J=K).
Esto nos hace pensar en la necesidad de un MUX2x1 que seleccione la
entrada X o Z para dirigirla a J y otro MUX que seleccione entre Y y Z
para dirigirla hacia K. La idea es, que cuando la entrada de selección W de
los MUX sea 0, a J debe llegar X y a K, Y. Cuando W=1, a J y K debe
llegar Z. También se va a requerir un circuito (Circ2) que controle la
entrada de selección W la cual debe estar en función de las entradas L, C e
I. Ver figura 4.3
Figura 4.3 Diagrama de bloques para el registro de 1 bit
Circ1 contiene las compuertas del registro de carga paralela y limpieza y
sus salidas X (X = L´CE) y Y (Y = CE´ + L). Así también, contiene las
compuertas del contador y la salida Z (Zi = IQ0Q1…Qi-1).
Circ2 genera la señal W, la cual debe ser 0 para que los MUX seleccionen
X y Y. W=1 para seleccionar Z (incrementar en 1). Pero W debe ser 1, sólo
y únicamente cuando L=0, C=0 e I=1 (ver figura 4.1), por lo tanto:
W = L´C´I
Las expresiones lógicas equivalentes a los MUX de 2x1 son:
J = XW´ + ZW
K = YW´ + ZW
Donde J y K son las entradas del flip-flop.
73
Por consiguiente:
J = L´CE(L´C´I)´ + ZW
J = L´CE(L+C+I´) + ZW
J = L´CE + ZW
J = X + ZW
K = (CE+L)(L´C´I)´ + ZW
K = (CE+L)(L+C+I´) + ZW
K = (CE+L) + ZW
K = Y + ZW
Estas expresiones lógicas son para cualquier bit del registro, pero
recordemos que Z varía según sea el bit, entonces:
J0 = L´CE0 + L´C´I
J1 = L´CE1 + L´C´IQ0
J2 = L´CE2 + L´C´IQ0Q1
J3 = L´CE3 + L´C´IQ0Q1Q2
K0 = (CE´0+L) + L´C´I
K1 = (CE´1+L) + L´C´I Q0
K2 = (CE´2+L) + L´C´I Q0Q1
K3 = (CE´3+L) + L´C´I Q0Q1Q2
Figura 4.4 Diagrama de un registro de 4 bits con carga paralela, incremento y
limpieza
Figura 4.5 Diagramas de bloque de un registro de 4 y 16 bits con carga paralela,
incremento y limpieza
74
4.2.2. El BUS común
Para poder hacer la transferencia de datos de registro a registro o de
registro a memoria, se necesita un conjunto de trayectorias o líneas,
denominado BUS. La cantidad de líneas será excesiva si se conectan las
salidas de cada registro con las entradas de los otros registros. Un sistema
más eficiente para transferir información es usar un BUS común y una de
las maneras de construirlo es mediante multiplexores, los cuales permitirán
seleccionar el registro cuyas salidas pasaran al BUS.
Para simplificar el diseño se hará con 2 registros de 4 bits, esto quiere decir
que el bus tendrá 4 líneas.
Figura 4.6 Diagrama de un bus común de 4 bits
La figura 4.6 muestra 2 registros de 4 bits conectados a un bus común.
Cuando la entrada de selección S toma el valor de 0, las 4 salidas del
registro A pasarán a las salidas Z (líneas del bus) y cuando sea 1, será el
registro B el que pase al bus. Del diagrama se puede concluir que son
necesarios tantos MUX como bits tenga el registro y la cantidad de
entradas de los MUX dependerá de la cantidad de registros a controlar. Por
consiguiente, en el caso de la computadora básica que tiene 8 registros de
16 bits, como máximo (porque hay registros de 12 y 8 bits), se requerirá de
16 MUX de 8 entradas. La selección de un registro en particular se hará a
través de las entradas S de selección de los MUX, 3 en este caso (23=8).
Se puede convenir que para un determinado valor de S, el contenido de
uno de los registros sea transferido al bus, tal como se muestra en la figura
siguiente:
S2
S1
S0
0
0
0
1
1
1
1
0
1
1
0
0
1
1
1
0
1
0
1
0
1
Registro que
pasa al BUS
AR
PC
DR
AC
IR
TR
MEMORIA
Figura 4.7 Tabla de transferencia de registros
4.3. La memoria
75
Es un conjunto de celdas de almacenamiento junto con los circuitos asociados que
se utilizan para escribir y leer información en ellas. La memoria almacena
información binaria en grupo de bits que se denominan palabras. Esta información
puede ser números, caracteres alfanuméricos, código de una instrucción o
cualquier otra información codificada en binario.
La estructura interna de la memoria está especificada por el número de palabras
que contiene y la cantidad de bits que la conforman. A cada palabra se le asigna
un número de identificación o posición llamado dirección, que comienza de 0
hasta N (N es una potencia de 2). Dependiendo de la cantidad de palabras de la
memoria, será necesario K líneas de dirección, donde 2K=N. Si en este caso
N=4096 palabras entonces K=12, esto quiere decir que se requiere de 12 líneas
para especificar la dirección de memoria a la cual se va a acceder.
El tipo de acceso queda establecido por medio de 2 entradas, W para escribir y R
para leer. Ver figura 4.8
Figura 4.8 Diagrama de bloque de la memoria
La barra inclinada en las líneas es para indicar que no se trata de una sola línea
sino de más. El valor que aparece al costado, indica la cantidad de líneas que
representa. En el diagrama se aprecia 16 líneas de entrada (izquierda) y 16 de
salida (derecha), las 12 líneas de abajo es por donde ingresa, en binario, la
dirección o número de palabra a acceder, mientras que W y R indica si se va a leer
o escribir.
4.4. Transferencia entre el BUS, los registros y la memoria
A continuación vamos a analizar como se realiza la transferencia entre los
registros y la memoria. Primero debemos indicar que se cuenta con un BUS de 16
líneas las cuales se conectan una a una con las entradas de los registros DR, AC,
IR, TR y la memoria. En el caso de los registros AR, PC que sólo tienen 12
entradas-salidas y los registros INPR, OUTR de 8 entradas-salidas se conectaran
con las líneas de los bits menos significativos del BUS, dejando libres las otras
líneas.
Al estar conectados los registros de esta manera con el BUS, siempre estarán
presente en las entradas, de todos los registros, lo que en ese instante haya en las
líneas del BUS, pero estos valores no pasaran al registro mientras no llegue la
señal de carga C y luego la señal de reloj al registro correspondiente.
De igual manera, los valores de salida de todos los registros llegaran a los
multiplexores de selección del BUS (ver figura 4.6) pero sólo las salidas de uno de
los registros pasarán a las líneas del BUS dependiendo de las entradas de selección
S activadas (ver figura 4.7)
76
La figura siguiente muestra los registros de la computadora básica conectados a un
BUS común.
Figura 4.9 Conexión de la memoria y los registros al BUS
Supongamos que las entradas S=3 (S2S1S0=011) esto significa que las 16 salidas
del registro DR pasaran al BUS. Este valor del registro DR, llegará a cada una de
las entradas de los registros, pero no pasará a ninguno de ellos mientras no llegue
la señal C y se genere la siguiente señal de reloj CLK.
En el caso de la memoria, antes de leer o escribir en ella, el registro AR debe
contener la dirección efectiva a la cual se desea acceder. Cuando llegue a la
memoria la señal W, lo que hay en el BUS pasará a escribirse en la dirección de
memoria indicada por el registro AR. Pero si la señal fuera R, de la memoria
pasará a los multiplexores del BUS el valor respectivo. Recién al hacerse las
entradas de selección S=7 (111) la palabra de memoria pasará al BUS.
Las entradas del acumulador AC provienen de las salidas de la ALU, la cual, a su
vez, tiene como entradas las salidas del mismo acumulador y del registro DR. La
ALU tiene también como entradas, señales de control que le indican la operación
que debe realizar con las entradas de los registros AC y DR. Nótese el registro de
un bit E anexo a la ALU, como ya se menciono éste se puede considerar como el
bit número 17 del registro AC.
77
4.5. El código de instrucción
Una instrucción de computadora es un código binario que especifica una secuencia
de microinstrucciones para la computadora. Los códigos de instrucción se
almacenan en la memoria, la computadora los lee y los coloca en un registro de
control. La unidad de control interpreta el código binario y procede a ejecutarlo
mediante una secuencia de microinstrucciones. Cada computadora tiene un
conjunto de instrucciones único.
Una computadora debe tener un conjunto de instrucciones que permitan al usuario
construir programas de lenguaje de computadora con el fin de evaluar cualquier
función que se sepa que pueda computarse. Se dice que el conjunto de
instrucciones está completo si la computadora incluye la suficiente cantidad de
instrucciones en cada una de las siguientes categorías:
a)
b)
c)
d)
Aritméticas, lógicas y de corrimiento.
Mover datos hacia y desde la memoria y los registros.
Control del programa y verificación del estado del procesador.
Entrada y salida.
En la computadora básica, el código de cada instrucción tiene una longitud de 16
bits, que es la longitud de una palabra de memoria. Se define 3 tipos de
instrucciones: Las que hacen referencia a memoria, las que hacen referencia a los
registros y las de entrada y salida.
4.5.1. Instrucciones que hacen referencia a memoria
Utilizan 12 bits (de los 16) para especificar una dirección de memoria
(212=4096). De los 4 bits restantes, 1 bit se emplea para indicar el tipo de
direccionamiento, es decir, si en la dirección de memoria que aparece en el
código de instrucción es donde se encuentra el operando (direccionamiento
directo) o si ahí hay otra dirección de memoria (direccionamiento
indirecto) donde finalmente se encuentre éste (el operando). Los 3 bits
restantes se usan para codificar la operación a realizar, por ello se les
denomina código de operación. Con 3 bits (23=8) se puede codificar hasta
8 operaciones diferentes.
Se establece los 12 primeros bits del código (0-11) para especificar la
dirección de memoria, los 3 bits siguientes (12-14) para el código de
operación y el bit más significativo I (15) para el modo de
direccionamiento: I=0 directo, I=1 indirecto.
15
I
14 13 12
Código de
operación
11
0
Dirección de memoria
Las instrucciones que hacen referencia a memoria son las siguientes:
AND.- Su codop (código de operación) es 000. Realiza la operación lógica
AND entre la palabra que se encuentra en la dirección efectiva de
memoria y el acumulador AC, el resultado se almacena en AC.
Ejemplo: 03C7 es una instrucción codificada en hexadecimal de
una operación AND. Los 12 bits menos significativos 3C7
especifican la dirección de memoria donde se encuentra la palabra
78
(porque el bit I es 0, direccionamiento directo) con la que se hará la
operación AND con AC. La operación sería AC←AC ▲ M[3C7]
Ejemplo: 83C7 (I es 1, direccionamiento indirecto) entonces la
palabra que se encuentra en la dirección 3C7 es otra dirección de
memoria (no el operando) donde se encuentra la palabra a operar.
Esto se resume como AC←AC ▲ M[M[3C7]]
ADD.- Su codop es 001. Realiza una suma entre el contenido de la
dirección efectiva de memoria y el acumulador AC, el resultado se
almacena en AC. Ejemplo: 13C7, como I es 0, se trata de un
direccionamiento directo la operación es: AC←AC + M[3C7]
Ejemplo: 93C7, se trata de un direccionamiento indirecto por lo
tanto la operación es: AC←AC + M[M[3C7]]
LDA.- Su codop es 010. Carga en el registro AC la palabra que se
encuentra en la dirección efectiva de memoria.
Ejemplo: 23C7 (direccionamiento directo) entonces: AC←M[3C7]
Ejemplo:
A3C7
(direccionamiento indirecto) entonces:
AC←M[M[3C7]]
STA.- Su codop es 011. Almacena el contenido del registro AC en la
dirección efectiva de memoria.
Ejemplo: 33C7 (I=0) entonces: M[3C7]←AC
Ejemplo: B3C7 (I=1) entonces: M[M[3C7]]←AC
BUN.- Su codop es 100. Hace un salto incondicional a la dirección
efectiva de memoria, para ello modifica el valor del registro
contador de programa PC que es el que contiene la dirección de la
siguiente instrucción a ejecutar.
Ejemplo: 43C7 (I=0) entonces: PC←3C7
Ejemplo: C3C7 (I=1) entonces: PC←M[3C7]
BSA.- Su codop es 101. Salva la dirección de la siguiente instrucción a
ejecutar en la palabra de la dirección efectiva de memoria y salta a
la siguiente posición de la dirección efectiva especificada.
Ejemplo: 53C7 (I=0). En el momento que se está ejecutando una
instrucción cualquiera, el registro PC ya contiene la dirección de la
siguiente instrucción a ejecutar. En función a eso las operaciones
internas son: M[3C7]←PC, PC←3C8
Ejemplo: D3C7 (I=1). En este caso las instrucciones son:
M[M[3C7]]←PC, PC←M[M[3C7]+1]
ISZ.- Su codop es 110. Incrementa en 1 la palabra de la dirección efectiva
especificada y si el resultado es 0 se ignora la siguiente instrucción
y se pasa a ejecutar la subsiguiente.
Ejemplo: 63C7 (I=0). M[3C7]←M[3C7]+1
Si M[3C7] = 0 entonces PC←PC+1
Ejemplo: E3C7 (I=1). M[M[3C7]]←M[M[3C7]]+1
Si M[M[3C7]] = 0 entonces PC←PC+1
79
Nótese que no hay una instrucción con codop 111, esto significa que
ninguna instrucción que hace referencia a memoria su código empezará
con 7 o F.
4.5.2. Instrucciones que hacen referencia a registro
Utilizan los 12 bits menos significativos (0-11) para especificar la
operación o prueba que se va a ejecutar sobre un registro, en este caso,
únicamente sobre el registro de trabajo, o sea AC. En teoría esto significa
que se puede codificar hasta 4096 operaciones sobre el registro AC pero,
una vez más, para simplificar el diseño del decodificador sólo se codificará
potencias de 2 (12 operaciones). Los 4 bits restantes se les asigna el valor
de 0111 (7) que es lo que identifica una instrucción de referencia a
registro.
15
14 13 12
0
1
1
1
11
0
Operación de registro
Estas instrucciones son:
CLA.- Su código de instrucción es 7800. Borra el registro acumulador:
AC←0
CLE.- Su código de instrucción es 7400. Borra el registro E: E←0. E es un
registro de un bit y es una extensión del acumulador, en otras
palabras se puede considerar como un bit más del registro
acumulador. E puede ser usado, por ejemplo, para almacenar el
acarreo de salida de una operación ADD.
CMA.- Su código de instrucción es 7200. Complementa los bits del
registro acumulador: AC←AC´
CME.- Su código de instrucción es 7100. Complementa el registro E:
E←E´
CIR.- Su código de instrucción es 7080. Realiza una rotación de bits hacia
la derecha del acumulador AC, pasando el bit menos significativo
al registro E y lo que había en E al bit más significativo de AC.
Ejemplo: Si E=1 y AC = 0110110100101000 = 6D28, después de
ejecutar esta instrucción AC quedará como 1011011010010100 =
B694 y E=0. Nótese que los bits del AC se han desplazado una
posición a la derecha, que el bit menos significativo de AC paso a
E y el valor de E ahora es el bit más significativo de AC.
Ejemplo: Si E=0 y AC = 0110110100101000 = 6D28, luego de
ejecutar CIR AC será igual que 0011011010010100 = 3694 y E=0.
CIL.- Su código de instrucción es 7040. Realiza una rotación de bits hacia
la izquierda del acumulador AC, pasando el bit más significativo al
registro E y lo que había en E al bit menos significativo de AC.
80
INC.- Su código de instrucción es 7020. Incrementa en 1 el acumulador:
AC←AC+1
SPA.- Su código de instrucción es 7010. Ignora la siguiente instrucción y
pasa a la instrucción subsiguiente, si el valor del acumulador es
positivo:
Si AC > 0 entonces PC←PC+1.
SNA.- Su código de instrucción es 7008. Ignora la siguiente instrucción y
pasa a la instrucción subsiguiente, si el valor del acumulador es
negativo:
Si AC < 0 entonces PC←PC+1.
SZA.- Su código de instrucción es 7004. Ignora la siguiente instrucción y
pasa a la instrucción subsiguiente, si el valor del acumulador es
cero:
Si AC = 0 entonces PC←PC+1.
SZE.- Su código de instrucción es 7002. Ignora la siguiente instrucción y
pasa a la instrucción subsiguiente, si el valor del registro E es cero:
Si E = 0 entonces PC←PC+1.
HLT.- Su código de instrucción es 7001. Detiene la computadora
4.5.3. Instrucciones de entrada y salida
Utilizan los 4 bits más significativos para identificarse tomando el valor de
1111 (15=Fh) y los primeros 12 bits para indicar el tipo de operación de
entrada-salida o la prueba ejecutada.
15
14 13 12
1
1
1
1
11
0
Operación de I/O
Las instrucciones de entrada y salida son:
INP.- Su código es F800. Transfiere el contenido del registro de entrada
INPR a los 8 bits menos significativos del registro acumulador AC
cada vez que el registro bandera de un bit FGI es 1. Luego de esta
operación el registro FGI debe ser puesto a 0.
Si FGI=1 entonces AC[7-0]←INPR; FGI←0
OUTP.- Su código es F400. Transfiere los 8 bits menos significativos del
registro acumulador AC al registro de salida OUTR cada vez que el
registro bandera de un bit FGO es 1. Luego de esta operación el
registro FGO debe ser puesto a 0.
Si FGO=1 entonces OUTR←AC[7-0]; FGO←0
SKI.- Su código es F200. Ignora la siguiente instrucción y ejecuta la
subsiguiente si FGI = 1.
Si FGI = 1 entonces PC←PC+1.
81
SKO.- Su código es F100. Ignora la siguiente instrucción y ejecuta la
subsiguiente si FGO = 1.
Si FGO = 1 entonces PC←PC+1.
ION.- Su código es F080. Establece a 1 el registro de interrupción de un
bit IEN, el cual activa las interrupciones de la computadora.
IOF.- Su código es F040. Desactiva las interrupciones estableciendo IEN a
0.
4.6. La unidad de control
Una vez leída de la memoria la instrucción a ejecutar, se procede a decodificarla
para luego generar las señales de control necesarias que permitan ejecutar las
microinstrucciones que, en su conjunto, conforman la instrucción.
Por ejemplo, la mayoría de instrucciones para ejecutarse necesitan hacer
transferencias entre registros y/o memoria. Entonces, la unidad de control debe
generar las señales apropiadas en las entradas de selección S del BUS que permita
transferir los datos de un registro o la memoria al BUS y las señales de carga C de
los registros o la señales de lectura/escritura R/W de la memoria. Cada una de
estas señales necesita, a su vez, de una señal de temporización T que le indiquen el
momento en el que deben generarse. Así pues, si una instrucción está conformada
por las microinstrucciones 0, 1, 2, 3, ..., N, entonces al generarse la señal T0 se
llevará a cabo la microinstrucción 0, la señal T1 ejecutará la microinstrucción 1 y
así sucesivamente. Finalmente después de ejecutarse la última microinstrucción N,
el generador de señales T debe reiniciarse para poder iniciar la ejecución de la
siguiente instrucción. Si bien es cierto las señales T indican la microinstrucción
que deben de ejecutarse, son las señales I, Di y Bi las que definen las instrucciones
a ejecutar, ver figura 4.10
Registro de instrucción IR
15
14
13
12
11 - 0
Bi
Decodificador 3x8
7 6 5 4 3 2 1 0
D0
I
Compuertas
Lógicas de
control
D7
Salidas de
control
T15
T0
15 14 13
…
2 1 0
Decodificador
4x16
Contador de
4 bits (SC)
Incrementar
Borrar
CLK
Figura 4.10 Unidad de control de la computadora básica
82
Una vez puesta el código de la instrucción en el registro IR se procede a identificar
la instrucción correspondiente. Al estar conectados los bits 14, 13 y 12 a un
decodificador de 3x8, activará sólo una de las 8 salidas Di a la vez. Por
consiguiente, cuando D0=1 significará que se trata de la instrucción AND,
cuando D1=1 de ADD, cuando D2=1 de LDA y así sucesivamente. Por su parte I
indicará si es un direccionamiento directo o indirecto. Pero cuando D7=1 (los bits
14, 13 y 12 son unos) implicará que la instrucción no es de referencia a memoria y
dependiendo de I se podrá concluir si es una instrucción de referencia a registro
(I=0) o una instrucción de entrada-salida (I=1). En estos casos serán los bits Bi los
que definan la instrucción a ejecutar.
Una vez identificada la instrucción, ésta se tiene que realizar en uno o más pasos,
ejecutando en cada uno de ellos la microinstrucción correspondiente. Un contador
de 4 bits SC (el cual aumenta en cada pulso de reloj) lleva la cuenta del número de
paso que se encuentra la unidad de control. Este valor es decodificado mediante un
decodificador de 4x16 obteniendo 16 señales de temporización llamadas Ti. Estas
señales son generadas en forma secuencial (T0, T1, T2, …T15) por eso sólo una
de ellas puede estar activada a la vez.
Finalmente, son las señales I, Di, Ti y Bi las que, unidas mediante compuertas
lógicas, producirán las salidas de control que, a su vez, llegaran a las entradas de
control de los registros, entradas de selección del BUS, entradas W/R de la
memoria y las entradas de la ALU para que éstos realicen las operaciones
correspondientes.
4.7. Ciclo de instrucción
Es la secuencia u orden que se ejecutan las microinstrucciones de una instrucción.
Un ciclo de instrucción se divide en 4 fases:
a) Buscar una instrucción en la memoria.
b) Decodificar la instrucción.
c) Leer la dirección efectiva de la memoria, si la instrucción tiene una
dirección indirecta.
d) Ejecutar la instrucción
Este ciclo de instrucción se repite tantas veces como instrucciones tenga el
programa.
4.7.1. Búsqueda
Se parte del hecho de que el registro PC contiene la dirección de la primera
instrucción a ejecutar. Por lo tanto para lograr transferir la instrucción que
se encuentra en la dirección de memoria contenida por PC, primero se debe
cargar AR con la dirección de memoria a leer, es decir transferir PC a AR;
luego transferir la instrucción al registro IR y aumentar en 1 PC para que
en el siguiente ciclo de instrucción se ejecute la siguiente instrucción. Todo
esto se puede especificar de la siguiente forma:
T0: AR←PC
T1: IR←M[AR],
PC←PC+1
Esto significa que cuando se genere la señal T0, PC se debe transferir a
AR. Para lograr ello, las entradas de selección S del BUS deben ser igual a
83
2 (010) para que el registro PC pase al BUS (ver figura 4.7) y activar, a la
vez, la entrada C del registro AR para que éste se cargue con lo que hay en
el BUS en ese instante.
Al generarse la señal T1 (con el siguiente pulso de reloj) las entradas S del
BUS deben ser igual a 7 (111) y se debe activar la entrada R (leer) de la
memoria para transferir la palabra de la dirección de memoria AR al BUS.
También se debe activar, a la vez, la entrada C del registro IR para que se
cargue con lo hay en ese instante en el BUS y, por ultimo, activar la
entrada A (aumentar en 1) del registro PC.
4.7.2. Decodificación
Una vez puesto el código de la instrucción en IR, con el siguiente pulso de
reloj (el cual generará la señal de temporización T2) se procederá a
decodificar la instrucción y a transferir los 12 bits menos significativos de
IR al registro de dirección AR como se indica a continuación:
T2: D0,…,D7←Decodificar IR[14-12], AR←IR, I←IR[15]
La decodificación la hace automáticamente el decodificador de 3x8,
generando una de las 8 salidas Di. Para transferir IR a AR, se debe hacer
igual a 5 (101) las entradas S del BUS y activar la entrada C del registro
AR. La señal I no es otra cosa que el bit más significativo del registro IR.
La figura 4.11 muestra las compuertas necesarias para que, en función de
las señales Ti, se realicen las transferencias entre los registros y la memoria
en la fase de búsqueda y decodificación.
Figura 4.11 Compuertas de la Unidad de Control para la fase búsqueda y
decodificación
84
En el diagrama se puede apreciar como la señal T0, T1 y T2 llegan a las
compuertas OR conectadas a las entradas S del BUS para establecer el
valor correspondiente que permita realizar las transferencias de los
registros al BUS. Así también, estas señales T llegan a las entradas C, A de
los registros y R de la memoria.
Al finalizar la señal de temporización T2, el registro PC contiene la
dirección de memoria de la siguiente instrucción a ejecutar, IR el código de
la instrucción que se está ejecutando y AR los 12 bits menos significativos
de IR que viene a ser la dirección de memoria a acceder en el caso de
tratarse de una instrucción de referencia a memoria. También se habrán
generado las señales Di, Bi e I.
4.7.3. El tipo de instrucción
Al iniciarse la señal de temporización T3 se debe determinar el tipo de
instrucción, si es de referencia a memoria (directa o indirecta), de
referencia a registro o de entrada-salida.
Mientras D7 no esté activa (D´7) significa que se trata de una instrucción
de referencia a memoria y la señal I será la que nos indique, si se trata de
un direccionamiento directo o indirecto. De ser un direccionamiento
directo se optará por hacer nada y de ser indirecto se cargará el registro AR
con la palabra de la dirección de memoria AR, es decir:
T3I´D´7 :
NADA
T3ID´7 :
AR←M[AR]
Será con la señal T4 que se inicie la ejecución de la instrucción de
referencia a memoria
En el caso de estar activa D7, I=0 indicará que se trata de una instrucción
de referencia a registro en caso contrario (I=1) será una instrucción de
entrada-salida. En ambos casos, es durante la señal T3 que se ejecutan.
4.7.4. Ejecutar instrucción
Hay que analizar las instrucciones por grupos:
Instrucciones de referencia a memoria
Como ya se mencionó este tipo de instrucciones se ejecutaran durante la
señal de temporización T4.
AND.- Esta instrucción realiza una operación AND entre el registro AC y
la palabra de la dirección de memoria AR. Esta instrucción no se puede
ejecutar directamente porque son los registros AC y DR los que deben
contener los valores a operar para cualquier operación aritmética o lógica,
debido a que son los únicos registros que están conectados a la ALU. Por
consiguiente se necesitará una señal de temporización adicional para
ejecutar esta instrucción. Con la señal T4 se transferirá la palabra de
memoria a DR y con la siguiente señal se ejecutará la operación en sí y se
reiniciará el contador SC.
T4D0 : DR←M[AR]
T5D0 : AC←AC▲DR;
SC←0
85
La señal T5D0 es una de las tantas señales que llegarán a las entradas de
control que tiene la ALU para indicarle la operación que debe realizar, en
este caso hacer un AND entre los bits de los registros AC y DR.
El contador de secuencia SC tiene 3 entradas de control y una de ellas es
“Borrar”. Cuando esta entrada es puesta en 1, reinicia el contador lo que
significa que vuelve a generar señales de temporización a partir de T0 y se
inicia la fase de búsqueda y decodificación. Esto se representa mediante la
microinstrucción SC←0
ADD.- Esta instrucción realiza una suma entre el registro AC y la palabra
de la dirección de memoria AR. Igual que en el caso anterior, esta
operación la realiza la ALU y se requiere 2 señales de temporización.
T4D1 : DR←M[AR]
T5D1 : AC←AC+DR;
SC←0
LDA.- Esta instrucción realiza una transferencia de la dirección de
memoria AR al registro AC. Pero si se mira la figura 4.9 se observará que
las entradas de AC no están conectadas al BUS, por consiguiente para
ejecutar esta instrucción primero hay que transferir la palabra de memoria
al registro DR y luego, mediante una operación de transferencia de la
ALU, al registro AC.
T4D2 : DR←M[AR]
T5D2 : AC←DR;
SC←0
STA.- Esta instrucción realiza la operación inversa a la anterior. Transfiere
el registro AC a la dirección de memoria AR, pero en una sola señal de
temporización.
T4D3 : M[AR]←AC; SC←0
BUN.- Esta instrucción transfiere el control del programa a la dirección
especificada por AR (AR contiene la dirección efectiva). Por ello sólo
bastará con hacer una transferencia de AR a PC.
T4D4 : PC←AR;
SC←0
BSA.- Esta instrucción se usa para ejecutar una subrutina o procedimiento.
Un procedimiento no es otra cosa que un conjunto de instrucciones
ubicadas en alguna parte de la memoria. Se debe tener en cuenta que
cuando se termine de ejecutar la subrutina la computadora debe de saber
cuál es la siguiente instrucción a ejecutar. Por ello una de las primeras
cosas a hacer es guardar la dirección de memoria de la instrucción que está
a continuación de la instrucción BSA. Ahora la pregunta es en dónde se
guarda?. En las computadoras comerciales hay un área de memoria
llamada “pila” en donde se guarda estas direcciones, en el caso de la
computadora básica se hará en la primera palabra del área de memoria
donde se encuentra la subrutina, por lo tanto es en la siguiente o segunda
palabra donde se encuentra la primera instrucción de la subrutina.
Una instrucción BUN con direccionamiento indirecto será la última
instrucción de la subrutina que le indique a la computadora que debe
retornar a la siguiente instrucción desde donde fue invocada la subrutina.
86
Las señales de temporizacion y microinstrucciones son las siguientes:
T4D5 : M[AR] ←PC;
AR←AR+1
T5D5 : PC←AR;
SC←0
Supongamos que un instante cualquiera PC=037 e IR=57F1 (ambos
valores en hexadecimal). Esto significa que el código de la instrucción que
se está ejecutando es 57F1, 5 es el codop de la instrucción BSA con
direccionamiento directo y 7F1 (12 bits menos significativos de IR y que
se encuentra también en el registro AR) la dirección del área de memoria
donde se encuentra la subrutina que se desea ejecutar. Otro detalle
importante es que la instrucción que se está ejecutando se encuentra en la
dirección 036 (y no en 037) ya que en la etapa de búsqueda PC fue
aumentado en 1 para que apunte a la siguiente instrucción. Por lo tanto, es
en la dirección 7F1 donde se almacenará la dirección de retorno (en este
caso 037) y en 7F2 la dirección donde se debe escribir la primera
instrucción de la subrutina. Finalmente es una instrucción BUN indirecta
con código C7F1 la que haga retornar la computadora a la dirección 037,
para que continué con la ejecución del resto del programa.
ISZ.- En esencia esta instrucción hace un salto condicional hacia otra
dirección de memoria. Es decir, que pasa el control del programa a otra
dirección de memoria dependiendo que se cumpla una condición. La
palabra ubicada en la posición de memoria especificada por la dirección
efectiva en el registro AR (M[AR]) será aumentada en 1 y si el resultado es
0 se saltará la palabra (instrucción) siguiente, procediendo a ejecutar la
subsiguiente instrucción, en caso contrario se ejecuta en forma normal el
programa. Esta característica permite definir en los programas estructuras
de control repetitivas con contador de salida ya que una vez que la palabra
en cuestión o contador llegue a FFFF al incrementarla en 1 pasará a ser
0000 lo que permitirá realizar la bifurcación respectiva.
Para poder incrementar en 1 el valor de M[AR], éste debe pasarse primero
al registro DR, activar su entrada de control A (para realizar el incremento)
y luego almacenar el resultado en la dirección AR.
Al encontrase el valor del contador en el registro DR, se debe inspeccionar
que todos los bits de DR sean 0, esto se puede lograr uniendo los 16 bits de
DR a una o varias compuertas lógicas OR (que forman parte de la unidad
de control), si el resultado de estas es 0 significará que DR es 0 y si es 1
entonces DR es diferente de 0.
Para ejecutar esta instrucción se necesitará 3 señales de temporización:
T4D6 : DR←M[AR]
T5D6 : DR←DR+1
T6D6 : M[AR]←DR; si DR=0 entonces PC←PC+1 ; SC←0
Por ejemplo, se desea ejecutar 5 veces el grupo de instrucciones
comprendidas entre las direcciones de memoria 7B6 y 7C4. Se va a usar la
dirección de memoria A00 como variable contador.
Para determinar el valor del contador restamos 5 a 10000 y se obtiene
FFFB, este es el valor que se debe almacenar en la dirección de memoria
87
A00 el cual será aumentado en 1 cada vez que se ejecute la instrucción
6A00 que se encuentra en la dirección de memoria 7B3. Mientras esta
palabra o contador no sea 0000 se ejecutará la instrucción 47B6 (dirección
7B4) la cual hará un salto incondicional a la dirección 7B6 (primera
instrucción del cuerpo del bucle) y continuará con la ejecución hasta llegar
a la instrucción 47B3 (dirección 7C4) la cual hará retornar a la dirección
7B3 donde nuevamente se evaluará el contador.
Dirección
de memoria
7B3
7B4
7B5
7B6
…
7C4
7C5
Código
Instrucción
6A00
47B6
47BA
…
…
47B3
…
0 ISZ A00
0 BUN 7B6
0 BUN 7C5
…
…
0 BUN 7B3
…
Figura 4.12 Código para una estructura repetitiva
Pero cuando el contador tome el valor de 0000, la computadora saltará la
instrucción 47B6 (dirección 7B4) y ejecutará la 47BA (dirección 7B5) que
a su vez hará un salto incondicional a la dirección 7C5 que se encuentra
fuera de la estructura repetitiva con lo que se da fin al lazo.
Instrucciones de referencia a registro
Este tipo de instrucciones se ejecutaran durante la señal de temporización
T3. Además debe estar activa la señal D7 e I debe ser igual a 0, por lo que
será Bi la que identifique la instrucción.
CLA.- Para ejecutar esta instrucción se debe activar la entrada L (limpieza
o borrado) del registro AC.
T3D7I´B11 : AC←0;
SC←0
CLE.- Para ejecutar esta instrucción se debe activar la entrada L (limpieza)
del flip-flop E.
T3D7I´B10 : E←0;
SC←0
CMA.- Esta instrucción la ejecuta la ALU, para ello se debe activar las
entradas de control que realizan la complementación del registro AC.
T3D7I´B9 :
AC←(AC)´; SC←0
CME.- Para ejecutar esta instrucción se debe activar la entrada K
(complementar) del flip-flop E.
T3D7I´B8 :
E←E´;
SC←0
CIR.- Esta instrucción la ejecuta la ALU para ello se debe activar las
entradas de control que realizan el desplazamiento hacia la derecha del
registro AC.
T3D7I´B7 :
AC←DesDer(AC); AC[15]←E;
E←AC[0];
SC←0
88
CIL.- Esta instrucción la ejecuta la ALU para ello se debe activar las
señales de control que realizan el desplazamiento hacia la izquierda del
registro AC.
T3D7I´B6 :
AC←DesIzq(AC); AC[0]←E;
E←AC[15];
SC←0
INC.- Para ejecutar esta instrucción se debe activar la entrada A (aumentar
en 1) del registro AC.
T3D7I´B5 :
AC←AC+1;
SC←0
SPA.- Como AC contiene números de 16 bits pueden representarse 65536
valores diferentes. Si sólo se trabaja con números positivos estos valores
pueden variar desde 0 (0000) hasta 65535 (FFFF). Pero, si también se van
a representar números negativos con complemento a 2, el rango de valores
será desde 0 (0000) a 32767 (7FFF) para los positivos y desde -32768
(8000) a -1 (FFFF) para los negativos. Como se puede observar todas las
representaciones binarias para los números negativos con complemento a 2
tiene el bit más significativo igual a 1.
Entonces, para comprobar si AC contiene un valor negativo o positivo sólo
bastara evaluar el bit 15 del registro AC.
T3D7I´B4 :
si AC[15]=0 entonces PC←PC+1; SC←0
SNA.- Igual que el caso anterior con la diferencia que AC debe ser
negativo.
T3D7I´B3 :
si AC[15]=1 entonces PC←PC+1; SC←0
SZA.- Para ejecutar esta instrucción se debe evaluar el valor de AC y
determinar si es cero. Igual que para la instrucción ISZ, que comprueba el
valor de DR, se hace para el registro AC.
T3D7I´B2 :
si AC=0;
PC←PC+1; SC←0
SZE.- En este caso se evalúa el valor del flip-flop E.
T3D7I´B1 :
si E=0 entonces PC←PC+1; SC←0
HLT.- Si observamos la figura 4.10, el contador SC tiene una entrada
“Incrementar”. Mientras esta entrada esté activa el contador incrementará
en 1 en cada pulso del reloj pero si se desactiva el contador se detendrá.
Esta entrada está conectada a un flip-flop H que proporcionará a SC la
señal respectiva. Una vez desactivado SC, solo se podrá activar de manera
manual a través del flip-flop H.
T3D7I´B0 :
H←0;
SC←0
Instrucciones de entrada-salida
La computadora básica ha sido diseñada para poderse comunicar con el
mundo exterior a través de un teclado (entrada) y una impresora (salida).
Utiliza un flip-flop FGI para indicar el estado del registro de entrada INPR
y un flip-flop FGO para el registro de salida OUTR.
Inicialmente el flip-flop FGI es puesto a 0. Cuando se presiona una tecla se
transfiere un código de 8 bits al registro INPR e inmediatamente el flip89
flop FGI es puesto a 1 y permanece así mientras no se transfiera el registro
INPR al registro acumulador AC. Esto también implica que mientras FGI
sea 1, aunque se presionen más teclas, los códigos respectivos no serán
transferidos al registro INPR. Recién cuando llegue la señal a la ALU que
ordene transferir del registro INPR al registro AC es que se pondrá el flipflop FGI a 0, con lo que quedará listo para recibir el código de la siguiente
tecla que se presione.
En el caso del flip-flop FGO, éste es inicializado en 1 para indicar que el
registro OUTR esta libre. Tan pronto se transfiera un byte a OUTR, FGO
es puesto a 1 para indicar que OUTR está ocupado y mientras este así no
se trasferirá AC a OUTR.
Las instrucciones de instrucciones de entrada-salida se ejecutaran durante
la señal de temporización T3. Además debe estar activa la señal D7 e I debe
ser igual a 1. Bi será la señal que identifique la instrucción.
INP.- Para ejecutar esta instrucción se deben generar las señales T3D7IB11
y si FGI=1 entonces se ejecutaran las siguientes microinstrucciones:
AC[7-0]←INPR;
FGI←0;
SC←0
OUT.- Para ejecutar esta instrucción se deben generar las señales T3D7IB10
y si FGO=1 entonces se ejecutaran las siguientes microinstrucciones:
OUTR←AC[7-0];
FGO←0;
SC←0
SKI.- Esta instrucción se utiliza para comprobar si hay un carácter
disponible en el registro INPR y, de ser así, realizar una bifurcación para
proceder a leerlo mediante la instrucción INP.
T3D7IB9 :
si FGI=1 entonces PC←PC+1;
SC←0
SKO.- Esta instrucción comprueba si esta libre el registro OUTR, es decir,
si la impresora ya leyó el carácter enviado y así, mediante una bifurcación
poder, enviar otro con la instrucción OUT.
T3D7IB8 :
si FGO=1 entonces PC←PC+1;
SC←0
ION.- Al generarse las señales T3D7IB7 se establece el flip_flop IEN a 1.
Este flip-flop es el que controla las interrupciones.
IOF.- Al generarse las señales T3D7IB6 se establece el flip_flop IEN a 0
4.7.5. Interrupciones
Cada vez que se desee enviar un caracter a la impresora, se debe
comprobar primero si el registro OUPR está libre o no. Si se tiene que
enviar un conjunto de caracteres, esta prueba se debe de hacer para cada
uno de ellos. Esto implica que la computadora tiene que esperar que la
impresora lea el carácter enviado para poder enviar el siguiente carácter.
Por lo general la velocidad de procesamiento de la impresora es mucho
menor que el de la computadora lo que implica que cada vez que la
computadora compruebe que aun esta ocupado el registro OUTR, entre en
90
un bucle esperando que éste se desocupe lo cual genera un tiempo muerto
para la computadora que puede ser empleado en otras tareas.
La rutina que imprime un conjunto de caracteres se representa en la
siguiente figura:
Dirección
de memoria
7B3
7B4
7B5
7B6
…
7C4
7C5
Código
Instrucción
6A00
47B3
F400
…
…
47B3
…
SKO
0 BUN 7B3
OUT
…
…
0 BUN 7B3
…
Figura 4.13 Código para imprimir una cadena
La instrucción SKO comprueba si está libre el registro OUTR (FGO=1) de
ser así, salta a la dirección de memoria 7B5 donde se encuentra la
instrucción OUT que transfiere los 8 bits menos significativos de AC al
registro OUTR. Pero si FGO=0, entonces se ejecuta la siguiente
instrucción (dirección 7B4) la cual hace un salto incondicional a 7B3 y
estará así (ejecutando las instrucciones 7B3 y 7B4) hasta que OUTR esté
libre. Se asume que entre las direcciones 7B6 y 7C3 se encuentran las
instrucciones que se requieren para obtener y transferir el siguiente
carácter a imprimir al registro AC. Finalmente la instrucción 47B3
(dirección 7C4) hace un salto incondicional hacia la dirección 7B3 para
imprimir el siguiente carácter.
Existe una forma más eficiente de realizar la tarea anterior eliminando el
tiempo muerto que genera: interrupciones. Una interrupción es una señal
que detiene la ejecución de una tarea o rutina para pasar a ejecutar otra y
luego de terminada ésta última continuar con la tarea inicial.
La computadora básica tiene la instrucción ION que permite activar las
interrupciones y la instrucción IOF para desactivarlas. Cuando las
interrupciones están activadas IEN=1, en forma paralela a la fase de
ejecución de instrucciones (es decir en cualquier transición del reloj
excepto cuando las señales de temporización T0, T1 y T2 estén activas), se
verifica si los flip-flops FGI o FGO son 1 de ser así, se pone en 1 un flipflop llamado R, el cual es chequeado constantemente antes de iniciar la
fase de búsqueda. Cuando R es 0, se ejecuta un ciclo de instrucción
(búsqueda, decodificación y ejecución de instrucciones) y cuando es 1, se
ejecutan las microinstrucciones que luego van a permitir ejecutar las
instrucciones que conforman la rutina que procesará la interrupción. A esto
se le denomina ciclo de interrupción.
Por lo tanto si se han activado las interrupciones y se ha enviado un
caracter al registro OUTR, ya no será necesario estar constantemente
comprobando mediante código si el registro OUTR está libre, en vez de
ello, la computadora puede realizar cualquier otra tarea y esperar que R sea
1 para bifurcar a un ciclo de interrupción.
91
La condición para activar R puede expresarse de la siguiente manera:
T0´T1 ´T2(IEN)(FGI+FGO) :
R←1
En el ciclo de interrupción se tiene que cambiar el control del programa
para que en el siguiente ciclo de instrucción se ejecuten las instrucciones
que conforman la rutina de la interrupción, así como salvar la dirección de
la siguiente instrucción que se debe ejecutar cuando se termine de ejecutar
la rutina de la interrupción.
En la dirección de memoria 000 se almacenará la dirección de la siguiente
instrucción a ejecutar y en la dirección 001 una instrucción BUN para que
realice un salto incondicional a la rutina de la interrupción. De esta forma
sólo se tiene que modificar el valor del registro PC a 001 para que ejecute
esta instrucción y se inicie la ejecución de la interrupción. Esto se consigue
con la siguiente secuencia de microinstrucciones:
RT0 : AR←0;
TR←PC
RT1 : M[AR]←TR; PC←0
RT2 : PC←PC+1;
IEN←0 ; R← 0; SC←0
Durante el ciclo de interrupción se desactiva las señales IEN para que no se
genere otra interrupción mientras se esta ejecutando la actual y R se hace 0
para pasar a ejecutar las instrucciones de la interrupción como cualquier
instrucción. Al finalizar la interrupción, PC apunta a la dirección 001
donde se encuentra un salto incondicional a la rutina de la interrupción.
La rutina de la interrupción de entrada-salida hace las comprobaciones
necesarias sobre los flip-flops FGI y FGO para saber que fue lo genero la
interrupción: la llegada de un nuevo carácter a INPR o que la impresora ya
leyó e imprimió el carácter que se encontraba en el registro OUTR.
La rutina de interrupción debe volver a establecer a 1 el registro IEN (que
fue desactivado durante el ciclo de interrupción) para habilitar
interrupciones posteriores. La última instrucción que debe contener la
rutina de la interrupción es una instrucción BUN indirecta a 000, donde se
encuentra la dirección a retornar. Ver figura 4.14
Dirección
de memoria
000
001
…
7B3
7B4
7B5
…
F49
F4A
…
F57
F58
Código
Instrucción
07B5 (dirección a retornar)
4F49
0 BUN F49
…
…
Programa en ejecución
Instrucción en ejecución
…
…
…
…
Rutina de la interrupción
de entrada-salida
..
…
C000 1 BUN 000
…
…
Figura 4.14 ciclo de interrupción
92
4.8. La ALU
En el item 4.7.4 se listan las secuencias de microinstrucciones requeridas para
ejecutar una instrucción. Se observará que varias de ellas mencionan que la
operación en sí, la realiza la ALU. Además se podrá apreciar las señales necesarias
para su ejecución. Estas instrucciones son:
Instrucción
AND
ADD
LDA
CMA
Señales
T5D0
T5D1
T5D2
T3D7I´B9
CIR
T3D7I´B7
CIL
T3D7I´B5
INP
T3D7IB11
Microinstrucción
AC←AC▲DR
AC←AC+DR
AC←DR
AC←AC´
AC←DesDer(AC)
AC[15]←E
AC←DesIzq(AC)
AC[0]←E
AC[7-0]←INPR
Figura 4.15 Microinstrucciones ejecutadas por la ALU
Esto significa que el diseño de la ALU debe ser de tal manera que ésta realice las
operaciones cuando se activen las señales de control respectivas. El diagrama de
bloque de la ALU es el siguiente:
Figura 4.16 diagrama de bloque de la ALU
Como se observa, el circuito de la ALU tiene 16 entradas que provienen de las
salidas del registro DR, 16 entradas que provienen de las salidas del registro AC, 8
entradas que provienen de las salidas del registro INPR y 7 entradas de control
para indicarle cual de las 7 operaciones debe de realizar. Además de 16 salidas que
se convierten en las entradas del registro AC y una salida que va al flip-flop E.
Mostrar todo el circuito de la ALU sería demasiado confuso de explicar, por ello
sólo se va a mostrar una etapa (figura 4.17) junto con las compuertas de la unidad
de control necesarias para generar las señales de control de la ALU.
Debido que las señales de control tales como T5D0, T5D1, T3D7I´B9, etc. Son
mutuamente excluyentes (sólo una de ellas puede ser 1 a la vez) bastará con filtrar
mediante compuertas AND de dos entradas, el resultado que desea pasar a la
salida S[i] y este a su vez serán el iésimo bit (AC[i]) del registro AC.
Por ejemplo, la etapa 5 tiene como entradas el bit 5 del registro DR (DR[5]) y el bit
5 del registro AC (AC[5]). Así como también los bits 4 y 6 de AC. Cualquier
operación que se realice generará la salida S[5] que luego se convertirá (cuando se
genere la señal de carga C de AC) en el bit 5 del registro AC
93
Si llegara la señal T5D1 a la ALU (T5D1=1, sumar) sólo la compuerta ADD dejará
pasar hacia la compuerta OR el valor de su otra entrada que, en este caso, es la
suma de los bits AC[5] y DR[5]. El resto de compuertas AND están prácticamente
desactivadas porque las señales de control que llegan a la ALU son 0.
Figura 4.17 Circuito de una etapa de la ALU
Ahora, si la señal que llegara a la ALU fuera T3D7I´B5, entonces la única
compuerta que se activaría es la CIL y por consiguiente su otra entrada (AC[4]) es
la que pasaría a la compuerta OR, luego a la salida S[5] y finalmente a AC[5]. Es
decir AC[5] pasara a ser AC[4] y si esto se aplica al resto de las 16 etapas lo que se
logrará es un desplazamiento de bits hacia la izquierda. Para la etapa 0 (i=0), el bit
AC[-1] es la salida del flip-flop E y para la etapa 15, AC[15] pasa a la entrada del
flip-flop E.
Así también se observa que cada etapa tiene una entrada C[i-1] que es el acarreo de
salida de la etapa (i-1) y una salida C[i] que es el acarreo de salida de la etapa i. En
la etapa 0 C[-1] es igual a E y en la etapa 15, C[15] pasa a E.
En la parte izquierda de la figura 4.17 se encuentran las compuertas lógicas que en
función de las señales Bi, Di y de temporización generan las señales de control que
llega a cada una de las 16 etapas de la ALU. Estas compuertas son parte de la
unidad de control.
94
4.9. Diseño Lógico de la computadora básica
La figura 4.18 muestra el diagrama de flujo del ciclo de instrucción, incluyendo un
ciclo de interrupción para la computadora básica.
Se parte con la puesta a 0 del contador SC para que las señales de temporización
inicien con T0, también se inicializa a 0 el flip-flop IEN para inhibir la
interrupciones, es decir, aunque llegue un carácter de teclado al registro INPR o se
ponga un carácter en el registro OUTR para enviarlo a la impresora, el flip-flop R
permanecerá con el valor que fue inicializado, en este caso 0.
SC←0; IEN←0; R←0
0 = Ciclo de instrucción
1 = Ciclo de interrupción
R
R´T0
RT0
AR←PC
AR←0; TR←PC
R´T1
RT1
M[AR] ←TR; PC←0
IR←M[AR]; PC←PC+1
R´T2
RT2
AR←IR[11-0]; I←IR[15]
D7…D0←Decodificar IR[14-12]
PC←PC+1; IEN←0
R←0; SC←0
0 = Referencia a memoria
1 = Registro oE/S
D7
0 = Directo
1 = Indirecto
0 = Registro
I
1 = E/S
I
D´7I´T3
D´7IT3
AR←M[AR]
D´7IT4
D7I´T3
Ejecutar
instrucción de
referencia a
registro
D7IT3
Ejecutar
instrucción de
entrada-salida
Ejecutar
instrucción de
referencia a
memoria
Figura 4.18 Diagrama de flujo para la operación de una computadora
Cuando el flip-flop de interrupción R es 0, la computadora procede a buscar,
decodificar y ejecutar una instrucción y cuando es 1 inicia un ciclo de interrupción
95
cuya función es salvar la dirección de retorno de la interrupción y dar el control a
la rutina que se encargará de procesar la interrupción.
El flip-flop R puede establecerse a 1 en cualquier momento durante las fases
posteriores a la fase de búsqueda y decodificación, es decir después de la señal de
temporización T2. Por ello, para que se active deben estar desactivadas T0, T1 y T2
(T´0T´1T´2)
El análisis y diseño de este flip-flop se verá más adelante en el item 4.10.2 flipflops de apoyo.
Las microinstrucción que se muestran en el diseño lógico deben ser
implementadas con compuertas lógicas que generen las señales respectivas que
controlen los diferentes dispositivos. Por ejemplo la instrucción DR←M[AR]
implica que primero se debe generar la señal lectura de memoria y las señales S de
selección del BUS para que la palabra de dirección AR sea transferida al BUS. En
forma simultánea también debe de activarse la señal de carga C del registro DR,
con ello se logra que en el siguiente pulso del Reloj, lo que está en memoria pase
al BUS y luego al registro DR.
T0
T3
AND
T4D0
ADD
T4D1
DR←M[AR]
T5D0
T4D4
M[AR] ← AC
SC←0
AC←DR
SC←0
BSA
T4D5
PC←AR
SC←0
T4D3
DR←M[AR]
T5D2
AC←AC+AC
E←C15
SC←0
BUN
STA
T4D2
DR←M[AR]
T5D1
AC←AC▲AC
SC←0
LDA
M[AR] ← PC
AR←AR+1
ISZ
T4D6
DR←M[AR]
T5D6
T5D5
PC ← AR
SC←0
DR←DR+1
T6D6
M[AR] ← DR
Si DR=0 → PC ← PC+1
SC←0
Figura 4.19 Diagrama de flujo para instrucciones de referencia a memoria
96
La figura 4.20 muestra el diagrama de flujo de las instrucciones de referencia a
registro. Todas las instrucciones necesitan de sólo una señal de temporización y se
inician con la señal de temporización T3.
T0
T2
CLA
CLE
T3D7I´B11
AC←0
SC←0
CMA
T3D7I´B10
E←0
SC←0
INC
CME
T3D7I´B9
SPA
T3D7I´B5
AC←AC+1
SC←0
T3D7I´B8
E ← E´
SC←0
AC←AC´
SC←0
CIR
Si AC[15]=0
PC←PC+1
SC←0
T3D7I´B7
AC←DesDer AC
AC[15]←E
E← AC[0]
SC←0
SNA
T3D7I´B4
CIL
T3D7I´B6
AC←DesIzq AC
AC[0]←E
E← AC[15]
SC←0
SZA
T3D7I´B3
Si AC[15]=1
PC←PC+1
SC←0
SZE
T3D7I´B2
Si AC=0
PC←PC+1
SC←0
HLT
T3D7I´B1
H←0
Si E=0
PC←PC+1
SC←0
Figura 4.20 Diagrama de flujo para instrucciones de referencia a registro
La figura 4.21 muestra el diagrama de flujo de las instrucciones de entrada-salida.
Algunas de estas instrucciones necesitan de una señal de control adicional. Por
ejemplo la instrucción SKI requiere de las señales T3D7IB9, pero para que se
ejecute la microinstrucción PC←PC+1, la señal de salida del flip-flop FGI debe
ser 1 por consiguiente PC←PC+1 se ejecutará sólo si T3D7IB9(FGI) es 1. La
microinstrucción SC←0 se ejecutará independientemente de FGI.
T0
T2
INP
T3D7IB11
AC[7-0]←INPR
FGI←0
SC←0
OUT
T3D7IB10
OUTR←AC[7-0]
FGO←0
SC←0
SKI
T3D7IB9
Si FGI=1
PC←PC+1
SC←0
SKO
T3D7IB8
Si FGO=1
PC←PC+1
SC←0
ION
T3D7IB7
IEN←1
SC←0
IOF
T3D7IB6
IEN←0
SC←0
Figura 4.21 Diagrama de flujo para instrucciones de entrada-salida
Todas las instrucciones contienen como microinstrucción final SC←0 que resetea
el contador SC haciendo que la computadora básica pase a un nuevo ciclo de
instrucción si R=0 o interrupción en el caso de que R=1.
97
4.10. Diseño Físico de la computadora básica
La tabla siguiente muestra las señales de control y las microinstrucciones de la
computadora básica.
Instrucción
Lee carácter la impresora
o llega caracter del teclado
Interrupción
Recuperar
Decodificar
AND
ADD
LDA
STA
BUN
BSA
Señales
Microinstrucción
T´0T´1T´2(IEN)(FGI+FGO)
R←1
RT0
RT1
RT2
R´T0
R´T1
AR←0; TR←PC
M[AR] ←TR; PC←0
PC←PC+1; IEN←0; R←0; SC←0
AR←PC
IR←M[AR]; PC←PC+1
D7…D0←Decodificar IR[14-12]
AR←IR[11-0]; I←IR[15]
DR←M[AR]
AC←AC▲DR; SC←0
DR←M[AR]
AC←AC+DR; SC←0
DR←M[AR]
AC←DR; SC←0
M[AR]←AC; SC←0
PC←AR; SC←0
M[AR]←PC; AR←AR+1
PC←AR; SC←0
DR←M[AR]
DR←DR+1
M[AR]←DR
Si DR=0 →PC←PC+1; SC←0
AC←0; SC←0
E←0; SC←0
AC←AC´; SC←0
E←E´; SC←0
AC←DesDer(AC); AC[15]←E
E←AC[0]; SC←0
AC←DesIzq(AC); AC[0]←E
E←AC[15]; SC←0
AC←AC+1; SC←0
Si AC[15]=0 → PC←PC+1; SC←0
Si AC[15]=1 → PC←PC+1; SC←0
Si AC=0 → PC←PC+1; SC←0
Si E=1 → PC←PC+1; SC←0
H←0; SC←0
AC[7-0]←INPR; FGI←0; SC←0
OUTR←AC[7-0]; FGO←0; SC←0
Si FGI=1 → PC←PC+1; SC←0
Si FGO=1 → PC←PC+1; SC←0
IEN←1; SC←0
IEN←0; SC←0
R´T2
T4D0
T5D0
T4D1
T5D1
T4D2
T5D2
T4D3
T4D4
T4D5
T5D5
ISZ
T4D6
T5D6
T5D6
CLA
CLE
CMA
CME
D7I´T3B11
D7I´T3B10
D7I´T3B9
D7I´T3B8
CIR
D7I´T3B7
CIL
D7I´T3B6
INC
SPA
SNA
SZA
SZE
HLT
INP
OUT
SKI
SKO
ION
IOF
D7I´T3B5
D7I´T3B4
D7I´T3B3
D7I´T3B2
D7I´T3B1
D7I´T3B0
D7IT3B11
D7IT3B10
D7IT3B9
D7IT3B8
D7IT3B7
D7IT3B6
Figura 4.22 Tabla con las funciones de control y microinstrucciones
A partir de estas señales y microinstrucciones se hace el diseño de los circuitos
que permiten controlar los registros, memoria, bus y los flip-flops de apoyo. Por
ejemplo, si se desea diseñar el circuito que controla el registro AR (carga, limpieza
e incremento), primero se hace un listado de todas las microinstrucciones donde
aparece el registro AR a lado izquierdo, luego se forman tres grupos: uno que
contenga todas aquellas microinstrucciones donde AR es incrementado en 1 (señal
98
A), otro donde AR es puesto a 0 (señal L) y un tercero donde a AR se le transfiere
algún valor (señal C). Si revisamos la tabla anterior estas instrucciones son:
Entrada A
T4D5: AR←AR+1
Entrada L
T0R: AR←0
Entrada C
T0R´: AR←PC
T2R´: AR←IR[11-0]
T3ID´7 : AR←M[AR]
Entonces para que el registro AR incremente en 1, las señales T4 y D5 deben ser 1
y llegar a la entrada de control A de AR. De igual manera ocurre para las entradas
L y C de AR. Ver figura 4.19
Figura 4.23 Compuertas de control del registro AR
A continuación se verá la lógica que hace la transferencia de los registros al BUS.
Se asume que cuando se genere la señal x1 se debe transferir el contenido de AR al
BUS, eso implica que las entradas de selección S (S2S1S0) del BUS (según la
figura 4.7) deben ser 001. Cuando se genere la señal x2 se transferirá PC y por
tanto las entradas de selección del BUS serán 010, cuando se genere x3 DR y así
sucesivamente. Al completar la tabla con las características mencionadas, se tiene:
x7
0
0
0
0
0
0
0
1
x6
0
0
0
0
0
0
1
0
Entradas
x5 x4 x3
0 0 0
0 0 0
0 0 0
0 0 1
0 1 0
1 0 0
0 0 0
0 0 0
x2
0
0
1
0
0
0
0
0
x1
0
1
0
0
0
0
0
0
S2
0
0
0
0
1
1
1
1
Salidas
S1 S0
0 0
0 1
1 0
1 1
0 0
0 1
1 0
1 1
Registro que
pasará al BUS
Ninguno
AR
PC
DR
AC
IR
TR
M
Figura 4.24 Codificador para entradas de selección del BUS
Si se observa con detenimiento la tabla de la figura anterior se concluirá que se
trata de un codificador
99
De la tabla anterior se obtiene:
S0 = x1 + x3 + x5 + x7
S1 = x2 + x3 + x6 + x7
S2 = x4 + x5 + x6 + x7
Para determinar la función lógica de x1, se busca en la tabla de la figura 4.22 todas
las microinstrucciones que requieren que el contenido de AR sea transferido al
BUS. Estas microinstrucciones son:
T4D4: PC←AR
T5D5: PC←AR
Por lo tanto: x1 = T4D4 + T5D5
De igual forma se hace para x2, x3, x4, x5, x6 y x7 obteniéndose lo siguiente:
x2 = T0R´ + T0R + T5D4
x3 = T5D2 + T6D6
x4 = T4D3 + T3D7I
x5 = T2R´
x6 = T1R
x7 = T1R´ + T3D´7I + T4D0 + T4D1 + T4D2 + T4D6
Sustituyendo éstos valores en S0, S1 y S2 se obtienen las funciones lógicas con las
que se puede realizar el diseño del codificador para las entradas de selección S del
BUS común.
4.10.1. Los flip-flops de apoyo.
Son registros de un bit que se utilizan para almacenar uno de los estados en
los que se puede encontrar la computadora básica, como por ejemplo si la
instrucción de referencia a memoria en curso es directa o indirecta (flipflop I); si se ha producido acarreo luego de haber realizado una suma
aritmetica (flip-flop E); si se han activado las interrupciones (flip-flop
IEN), se ha llegado un carácter de teclado (flip-flop FGI); si se ha cargado
el registro OUTR con un carácter para la impresora (flip-flop FGO); si hay
una interrupción pendiente (flip-flop R) o si se ha detenido la computadora
(flip-flop H).
Estos flip-flops deben poderse iniciar (establecer a 1) o resetear (establecer
a 0) y en algunos casos, como el flip-flop E, poder complementar. Las
salidas de los flip-flops de apoyo unidas, mediante compuertas lógicas, a
otras señales sirven para generar las entradas de control de registros y otros
dispositivos.
Igual como se analizó para los registros, se seleccionan todas las
microinstrucciones donde se modifique el valor del flip-flop en cuestión.
Por ejemplo para el flip-flop IEN, las microinstrucciones son:
(A) T3D7IB6 :
IEN←0
(B) T2R
:
IEN←0
(C) T3D7IB7 :
IEN←1
100
Asumiendo que el flip-flop a usar es del tipo JK se tiene la tabla siguiente:
A
0
0
0
1
B
0
0
1
0
Resto
C
0
1
0
0
Q
Sin cambio
1
0
0
X
J
0
1
0
0
X
K
0
0
1
1
X
En el caso que A=B=C=0 (las tres señales desactivadas) el estado del flipflop debe permanecer sin cambios. El resto de casos nunca se van a dar
debido a que las señales son mutuamente excluyentes.
Simplificando las funciones lógicas J y K se tiene:
J = C = T3D7IB7
K = A + B = T3D7IB6 + T2R
Con las funciones lógicas J y K se procede a diseñar el diagrama siguiente:
Figura 4.25 Señales de control para el flip-flop IEN
Para el flip-flop R, las microinstrucciones son:
(A) T´2T´1T´0(IEN)(FGI+FGO) :
R←1
(B) T2R
:
R←0
Como A y B son mutuamente excluyentes nunca se dará que A=B=1
entonces para ese caso J y K pueden tomar cualquier valor. Así también
cuando A=B=0 el slip-flop R debe permanecer sin cambios.
Simplificando las funciones lógicas se tiene que:
J = A = T´2T´1T´0(IEN)(FGI+FGO) = (T2+T1+T0)´(IEN)(FGI+FGO)
K = B = T2R
Figura 4.26 Señales de control para el flip-flop R
101
Al unir los flip-flops IEN y R se tiene el diagrama de la figura 4.27 que es
prácticamente la implementación del hardware necesario para activar y
generar las interrupciones
Figura 4.27 Señales de control para el flip-flops IEN y R
Finalmente se analizará el flip-flop E. Este flip-flop es modificado con las
siguientes microinstrucciones:
(A) T3D7I´B10 :
E←0
(B) T3D7I´B8 :
E←E´
(C) T3D7I´B7 :
E←AC[0]
(D) T3D7I´B6 :
E←AC[15]
(E) T5D1
:
E←C[15]
En este caso también se da que las entradas son mutuamente excluyentes
Con la entrada A, J y K deben ser 0 y 1 respectivamente para que E=0;
Con la entrada B, J y K deben ser 1 y 1 para que E sea complementado.
Pero las entradas C, D y E van a necesitar los valores de AC[0], AC[15] y
C[15] respectivamente para establecer los valores J y K apropiados y
obtener la salida Q deseada. Por ello se tomara AC[0] (F), AC[15] (G) y C[15]
(H) como entradas adicionales. Teniendo en cuenta que A, B, C, D y E son
mutuamente excluyentes se construye la siguiente tabla:
A
0
0
0
0
0
0
0
0
1
B
0
0
0
0
0
0
0
1
0
C
0
0
0
0
0
1
1
0
0
D E
0 0
0 1
0 1
1 0
1 0
0 0
0 0
0 0
0 0
RESTO
F
X
X
X
X
X
0
1
X
X
G
X
X
X
0
1
X
X
X
X
H
X
0
1
X
X
X
X
X
X
Q
S-C
0
1
0
1
0
1
Q´
0
X
J
0
0
1
0
1
0
1
1
0
X
K
0
1
0
1
0
1
0
1
1
X
102
Donde: AC[0] es el bit 0 de AC, AC[15] es el bit 15 de AC y C[15] es el bit 15
de acarreo que se genera en la ALU.
Simplificando las funciones lógicas J y K se obtiene:
J = EH + DG + CF + B
J = T5D1C[15] + T3D7I´B6AC[15] + T3D7I´B7AC[0] + T3D7I´B8
K = EH´ + DG´ + CF´ + A + B
K = T5D1C´[15] + T3D7I´B6AC´[15] + T3D7I´B7AC´[0] + T3D7I´B10 + T3D7I´B8
Con lo que se diseña el diagrama siguiente:
Figura 4.28 Señales de control para el flip-flop E
4.10.2. El Acumulador.
Igual como se hizo con el registro AR se hace con el registro AC. Se
recopila todas las microinstrucciones de la tabla de la figura 4.22 donde
AC aparezca a la izquierda de la microinstrucción para luego formar 3
grupos:
Entrada A
T3D7I´B5:
AC←AC+1
Entrada L
T3D7I´B11:
AC←0
Entrada C
T5D0:
T5D1:
T5D2:
T3D7IB11 :
T3D7I´B9:
T3D7I´B7:
T3D7I´B6:
AC←AC▲DR
AC← AC+DR
AC←DR
AC[7-0]←INPR
AC←AC´
AC←DesDer AC,
AC←DesIzq AC,
AC[15]←E
AC[0]←E
103
Con las señales obtenidas se diseña el diagrama siguiente:
Figura 4.29 Compuertas de control del registro AC
Las instrucciones CIR y CIL realizan transferencias entre los bits 0 y 15
del acumulador con el flip-flop E. En el caso de las transferencias
E←AC[0] y E←AC[15] ya se vieron cuando se analizó el flip-flop E (ver
figura 2.28) sólo queda evaluar las transferencias AC[0] ← E y AC[15] ← E
las cuales se realizan únicamente cuando T3D7I´B6 y T3D7I´B7,
respectivamente son 1. En cualquier otro caso las señales de entrada del
acumulador deben ser las que provienen de la ALU.
La figura 4.30 muestra como interactúan el registro acumulador AC, el
flip-flop E y las señales de control.
Figura 4.30 El registro AC y el flip-flop E
104
4.11. Ejercicios resueltos y propuestos
4.11.1. Resueltos.
a) Una computadora utiliza una unidad de memoria de 256K palabras
de 32 bits cada una. Un código de instrucción binario se almacena en
una palabra de memoria. La instrucción tiene cuatro partes: un bit
indirecto, un código de operación, una parte de código de registro
para especificar uno de 64 registros y una parte de dirección. Dibuje
y represente el formato del código de instrucción binario
Como el código de instrucción se almacena en una palabra de
memoria y cada palabra es de 32 bits, entonces el código es de 32
bits.
Para poder representar 64 valores diferentes (un valor por cada
registro) será necesario 6 bits (26 = 64)
Para referenciar una de las 256K palabras será necesario 18 bits (218=
262144 = 256K)
Por lo que quedará: 32-1-6-18 = 7 bits para el código de operación.
El formato será el siguiente:
31
30
I
24
CodOp
23
18
CodReg
17
0
Dirección
b) Las siguientes entradas de control están activas en el sistema de BUS
común. Para cada caso, especifique la transferencia de registro que se
ejecutará durante la siguiente transición de reloj.
i)
ii)
iii)
iv)
S2
1
1
1
0
S1
1
1
0
0
S0
1
0
0
0
C de registro
IR
PC
DR
AC
Memoria
Leer
-Escribir
--
ALU
---Sumar
i) Si S = 111(2 = 7 (memoria) y se activa la entrada Leer de la
memoria, el contenido de memoria M[AR] pasa al BUS. Como
simultáneamente se activa la entrada C del registro IR entonces lo
del BUS pasa a IR. La transferencia será: IR←M[AR]
ii) Si S = 110(2 = 6 (TR) , el contenido de TR pasa al BUS y como
simultáneamente se activa la entrada C del registro PC entonces
lo del BUS pasa a PC. La transferencia será: PC←TR
iii) Si S = 100(2 = 4 (AC) , el contenido de AC pasa al BUS. Como
simultáneamente se activa la entrada C del registro DR y la
entrada escribir de la memoria, entonces lo del BUS pasa a DR y
también la palabra de dirección AR de la memoria. La instrucción
será: DR←AC; M[AR]←AC
iv) Si S = 000(2 = 0 (ningún registro), Al activarse la señal sumar de
la ALU se efectúa la suma de AC y DR. Al activarse tambiénn la
entrada C de AC, el resultado de la aLU es transferido a AC. La
transferencia será: AC←AC+DR.
105
c) Las siguientes transferencias se van a ejecutar en el sistema de BUS
común.
i.
AR←PC
ii.
IR←M[AR]
iii.
M[AR]←TR
iv.
AC←DR; DR←AC (en forma simultánea)
Para cada transferencia especifique: 1) el valor binario que debe
aplicarse a las entradas de selección del BUS; 2) el registro cuyas
entradas C debe estar activa (si es que hay alguna); 3) una operación
de lectura escritura (si se necesita) y 4) la operación en la ALU (si
hay alguna)
i)
ii)
iii)
iv)
S2
0
1
1
1
S1
1
1
1
0
S0
0
1
0
0
C de registro
AR
IR
DR-AC
Memoria
-Leer
Escribir
--
ALU
---Transf DR
d) Explique por qué no puede ejecutarse cada una de las siguientes
microinstrucciones durante un sólo pulso de reloj. Especifique una
secuencia de microinstrucciones que ejecuten la operación.
i.
IR←M[PC]
ii.
AC←AC+TR
iii.
DR←DR+AC
i.
ii.
iii.
Porque cuando se lee de memoria, es el registro AR el que
contiene la dirección a acceder. La secuencia sería:
AR←PC; IR←M[AR]
Porque para cualquier operación aritmética o lógica los
operandos deben ser colocados en los registros AC y DR. La
secuencia sería:
DR←TR; AC←AC+DR
Porque los resultados de una operación suma se almacena en
el registro acumulador AC. La secuencia sería:
AC←AC+DR; DR←AC
e) Para cada una de las siguientes instrucciones proporcione el código
hexadecimal y explique cual instrucción representa.
i.
0001 0000 0010 0100
ii.
1011 0001 0010 0100
iii.
0111 0000 0010 0000
i.
ii.
iii.
1024 (0 ADD 024) Suma el registro AC con la palabra que se
encuentra en la dirección memoria 024, el resultado se
almacena en AC.
B124 (1 STA 124 ) Toma la palabra de la dirección de
memoria 124 y en ese valor (dirección) almacena el contenido
de AC.
7020 (INC) Suma 1 al registro acumulador AC
106
f) El contenido de AC es A937 y el de PC 021. Determine el contenido
de AC, PC, AR e IR después de ejecutar la instrucción CLA.
Se supone que PC apunta a la instrucción en curso (CLA = 7800).
Siguiendo el flujo de la figura 4.18 se completa la tabla siguiente:
T
T0
T1
T2
T3
AC
A937
A937
A937
A937
0000
PC
021
021
022
022
022
AR
?
021
021
800
800
IR
?
?
7800
7800
7800
Es con la señal de temporización T3 que se ejecuta CLA y los valores
que aparecen en la última fila son los valores finales de AC, PC, AR
e IR
g) Escriba un programa que multiplique dos valores enteros ubicados en
la memoria y el resultado lo almacene en memoria. (utilizar el
método de sumas sucesivas)
Se asume que el programa empieza en la dirección de memoria 100 y
los valores a multiplicar se encuentran en las direcciones de memoria
200 y 201 respectivamente. El resultado se almacenará en 202.
DIR
COD
ASM
SEUDOCODIGO
100
2200
LDA 200
AC←M[200]
101
102
103
104
105
7200
7020
3203
7800
1201
CMA
INC
STA 203
CLA
ADD 201
AC←AC´
AC←AC+1
M[203] ←AC
AC←0
AC←AC+M[201]
106
6203
ISZ
M[203]←M[203]+1
107
4105
BUN 105
IR a 105
108
3202
STA 202
M[202]←AC
109
7001
HTL
203
DESCRIPCION
Carga el acumulador con el
primer factor
Complementa e incrementa en
1 (complemento a 2)
Salva AC en la dirección 203
Inicializa AC con 0
Suma a AC el segundo factor
Incrementa en 1 la palabra de
la dirección 203. Si esta
palabra es 0 salta a la
dirección 108 en caso
contrario continua con la
instrucción 107
Salta a la dirección 105
Salva en la dirección 202 el
resultado
Detiene la computadora
h) Las operaciones que van a ejecutarse con un flip-flop F se
especifican mediante los siguientes enunciados de transferencia de
registro:
XT3:
YT1:
ZT2:
WT5:
F←1
F←0
F←F´
F←G
Activar F a 1
Borrar F a 0
Complementar F
Transferir el valor de G a F
107
De otra manera, el contenido de F no debe cambiar. Dibujar el
diagrama lógico que muestre las conexiones de las compuertas que
forman las funciones de control y las entradas del flip-flop F.
La señal de temporización T hace que las señales sean mutuamente
excluyentes y por consiguiente nunca van estar activas más de una a
la vez, pero lo que si puede ocurrir es que las 4 señales estén
desactivadas a la vez. Ahí F no debe cambiar
Reemplazar XT3 por A, YT1 por B, ZT2 por C y WT5 por D. Pero la
transferencia del valor de G a F depende del valor de G. Con esto se
completa la tabla siguiente:
A
0
0
0
0
0
1
B
0
0
0
0
1
0
C D
0 0
0 1
0 1
1 0
0 0
0 0
Resto
G
X
0
1
X
X
X
J
0
0
1
1
0
1
X
K
0
1
0
1
1
0
X
Usando mapas de Karnaugh para simplificar las funciones lógicas se
tiene:
A´B´
A´B
AB
AB´
C´D´G´
0
0
X
1
C´D´G
0
0
X
1
C´DG
1
X
X
X
C´DG´
0
X
X
X
CDG´
X
X
X
X
CDG
X
X
X
X
CD´G
1
X
X
X
CD´G´
1
X
X
X
J=A + C + DG = XT3 + ZT2 + WT5G
A´B´
A´B
AB
AB´
C´D´G´
0
1
X
0
C´D´G
0
1
X
0
C´DG
0
X
X
X
C´DG´
1
X
X
X
CDG´
X
X
X
X
CDG
X
X
X
X
CD´G
1
X
X
X
CD´G´
1
X
X
X
K = B + C +DG´ = YT1 + ZT2 + WT5G´
El diagrama lógico con las conexiones de las compuertas que forman
las funciones es el siguiente:
108
i) Un programa de salida reside en la memoria comenzando en la
dirección 8FC. se ejecuta después de que la compuerta reconoce una
interrupción cuando FGO se convierte en 1 (mientras IEN=1).
i. ¿Qué instrucción debe colocarse en la dirección 1?
ii. ¿Cuáles deben ser las dos últimas instrucciones del programa de
salida?
i. Debe colocarse un salto incondicional con direccionamiento
directo a la dirección de memoria 8FC (0 BUN 8FC) cuyo código
de instrucción sería 48FC.
ii. La penúltima instrucción debe ser ION (F080) para activar
nuevamente las interrupciones ya que éstas fueron desactivadas
durante el ciclo de interrupción. La última instrucción es un salto
incondicional a la dirección de la instrucción que se iba a ejecutar
cuando se produjo la interrupción. Esta dirección es almacenada
en la dirección 000 de la memoria, por ello para retornar de la
interrupción se debe hacer un salto incondicional indirecto (1
BUN 000) cuyo código de instrucción sería C000.
j) Derive las puertas de control para la entrada de lectura-escritura de la
memoria.
Seleccionar todas las microinstrucciones de la tabla de la figura 4.22
y formar 2 grupos: las que aparece M[AR] a la izquierda (escritura) y
las que aparece a la derecha (lectura) de la microinstrucción.
Escritura
T1R:
M[AR]←TR
T4D3: M[AR]←AC
T4D5: M[AR]←PC
T6D6: M[AR]←DR
Lectura
T1R´:
T3D´7I:
T4D0:
T4D1:
T4D2:
T4D6:
IR←M[AR]
AR←M[AR]
DR←M[AR]
DR←M[AR]
DR←M[AR]
DR←M[AR]
R=T1R + T4(D3+D4) + T6D6 y W=T1R´ + T3D´7I + T4(D0+D1+D2+D6)
El diagrama sería el siguiente:
109
4.11.2. Propuestos
a) ¿Cuántos bits debe tener el registro AR si la memoria de la
computadora básica fuera de 65536 palabras de 16 bits?
b) Especifique la transferencia de registro que se ejecutarán si las
siguientes entradas de control están activas.
i)
ii)
iii)
S2
1
1
0
S1
1
1
1
S0
1
1
1
C de registro
AC
AC
TR
Memoria
Leer
Escribir
--
ALU
----
c) Las siguientes transferencias se van a ejecutar en el sistema de BUS
común:
i.
DR←TR
ii.
AC←M[AR]
iii.
M[AR]←DR.
Indique las señales control de los registros, memoria y ALU que se
requieren en cada una de ellas.
d) Para cada una de las siguientes instrucciones proporcione el código
hexadecimal y explique cual instrucción representa.
i.
1110 0100 1010 0111
ii.
0011 0001 0110 0101
iii.
0111 0000 0000 0100
e) El contenido de AC es 70C9 y el de PC 0A9. Determine el contenido
de AC, PC, AR e IR después de ejecutar la instrucción SNA
f) Si AC es el registro acumulador, P=M[160], S=M[161] y T=M[162],
C=M[163], determine los valores finales de AC, P, S, T, C después
de ejecutar el siguiente código de máquina que se encuentra en la
dirección de memoria 155h
215F, 1160, 3161, 2160, 315F, 2161, 3160, 6162, 4155, 7001, 0001,
0000, 7020, FFF8
g) Escriba un programa que divida dos valores enteros ubicados en la
memoria y el resultado lo almacene en memoria. (utilizar el método
de restas sucesivas)
h) Los enunciados de transferencia de un registro CS son los siguientes:
T1X3:
CS←DR
T2X5:
CS←M[AR]
T3X0:
TR←CS
Derive las puertas de control asociadas con el registro CS
i) Diseñe el circuito lógico que permita determinar si AC=0 (tome
como entradas del circuito las 16 salidas –bits- de AC)
j) Derive las puertas de control asociadas con el registro DR
110
BIBLIOGRAFIA
MORRIS MANO M.
“Arquitectura de Computadoras” – 3ra Edición Prentice
Hall - 1994.
Mc CALLA, T.R
“Lógica Digital y Diseño de Computadoras” –
Megabyte/ Noriega Editores - 1994.
STALLING, William
“Organización y Arquitectura de Computadoras” – 4ta
Edición Prentice Hall - 1998.
TANENBAUM, A.
“Organización de Computadoras, un enfoque
estructurado” – 3ra Edición Prentice Hall - 1992.
TOCCI, Ronald
“Sistemas Digitales, Principios y Aplicaciones” – 8va
Edición.
WAKERLY, John F.
“Diseño Digital Principios y Practicas” - 1ra Edición
Prentice Hall - 1990
INTERNET
http://pdf.rincondelvago.com/arquitectura-de-computadoras_2.html
http://akimpech.izt.uam.mx/Web_jr/ami1.htm
http://medusa.unimet.edu.ve/sistemas/bpis03/lab0.htm
http://iteso.mx/~miguelbaz/cursos/arqcomp-2005-01/index.html
111