sumador secuencial - QueGrande

INTRODUCCIÓN
Existen sistemas secuenciales demasiado complejos para
poder implementarlos con las técnicas vistas hasta
ahora, por ejemplo, el procesador MIPS posee 32 registros
de 32 bits, lo que lleva a un total de 2 1024 estados.
En este tema veremos nuevas metodologías para implementar
algoritmos o computaciones sobre conjuntos de
datos (vectores de n bits). En general constan de operaciones
combinacionales más sencillas que se realizan
secuencialmente.
Ejemplos de dichos algoritmos son un sumador secuencial
con un único FA o un multiplicador a partir de un
sumador paralelo.
Esta metodología es la que se emplea para la implementación
de los computadores digitales de propósito general.
También se utiliza para implementar hardware específico
para la computacóon de algoritmos concretos, sobre
todo en campos tales como el tratamiento de señales,
procesamiento de imágenes, etc.
1

CONCEPTOS BÁSICOS
La especificación algorítmica de sistemas secuenciales implementa
eficientemente algoritmos o computaciones que se realizan sobre
vectores de datos de n bits. Son los llamados algoritmos RT (’Register
Transfer’).
Una computación es un conjunto de operaciones más simples que
consiste en la transferencia de vectores entre registros. Durante las
transferencias se realizan las operaciones de suma, desplazamiento,
comparación, etc.
Esta nueva metodología divide la implementación en dos bloques
básicos:
• Camino de datos, el conjunto de elementos que implementa
el almacenamiento de datos y las funciones de transformación
de los mismos.
• Sección de control, el sistema secuencial o autómata que
controla la transferencia y transformaciones de los datos así
como el secuenciamiento y la operación de todo el sistema.
El esquema general se puede ver en la siguiente figura:
2

CONCEPTOS BÁSICOS
El camino de datos recibe los datos del exterior (entradas
o “Data Input”) y devuelve los resultados obtenidos
(salidas o “Data Output”).
La sección de control recibe órdenes e información del
exterior (“Control Input”, por ejemplo, reset, begin, stop,
modo de operación...) y envía información u órdenes al
exterior (“Control Output”, por ejemplo, end, done, overflow...).
Las condiciones son generadas por el camino de datos
y sirven para que la sección de control pueda tomar decisiones
y realizar un control dependiente de los datos.
Ejemplos de condiciones son el signo de un operando, el
acarreo en una operación, un desbordamiento, el valor
de un bit o una comparación, etc.
Los puntos de control son las señales necesarias para
realizar las transformaciones de los datos. Son generadas
por la sección de control e indican al camino de datos
el modo de operación de todos y cada uno de sus
elementos.
Ejemplos de puntos de control son la carga de un registro,
los bits de control de un MUX o de DEMUX, el tipo
de operación de una ALU, el incremento de un contador,
el desplazamiento de un registro, el sentido del desplazamiento,
la lectura o escritura en una memoria, etc.
3

CONCEPTOS BÁSICOS
El resultado de aplicar o activar cada uno de los puntos
de control se denomina microoperación.
El conjunto de microoperaciones que se pueden realizar
de forma concurrente (en paralelo) se denomina microinstrucción.
Cada microinstrucción determina o equivale
a un estado del autómata de la sección de control.
Cada estado debe indicar que puntos de control hay que
activar en ese momento y cual es su estado (microinstrucción)
siguiente, que en general dependerá de las condiciones
actuales del camino de datos.
El conjunto o secuencia de todas las microinstrucciones
constituye un microprograma y su objetivo es implementar
el algoritmo o computación requerido.
4

CAMINO DE DATOS
Se encarga de almacenar y transformar los datos.
Consta de:
• Elementos de almacenamiento.
• Operadores.
• Buses.
Elementos de almacenamiento: almacenan la información.
El componente básico es el registro de N bits.
• Registro de N bits con LOAD y CLEAR.
Operación: if LOAD then y←x
if CLEAR then y←0
5

CAMINO DE DATOS
RAM = conjunto de 2 k registros de N bits que sólo pueden
accederse de uno en uno.
Operación: if READ then y←M[ϑ(A)] else y←0
if WRITE then M[ϑ(A)]←x
siendo ϑ(A) = k−1
i=0 Ai · 2 i
Fichero de registros.
Operación: if READ then y←R[ϑ(A)] else y←0
if WRITE then R[ϑ(A)]←x
6

CAMINO DE DATOS
Otros elementos de almacenamiento: FIFO y LIFO
Operadores: se encargan de transformar los datos.
donde OP: ADD, SUB, MAX, MIN, ...
AND, OR, NOR, EXOR, ...
SHIFT, ...
OP también puede representar una función más compleja implementada
con sistemas secuenciales (multiplicadores, divisores, ...).
Los operadores generan algunas condiciones: >,

CAMINO DE DATOS
Buses: son las conexiones, junto con los switches necesarios, que
comunican los distintos elementos del camino de datos (registros y
operadores).
Se clasifican en:
• Paralelos/Serie
• Unidireccionales/Bidireccionales
• Dedicados/Compartidos
• Directos/Indirectos
8

CAMINO DE DATOS
Switches: establecen o cortan el acceso al bus.
• Unidireccionales
• Bidireccionales
9

CAMINO DE DATOS
Selector: selecciona una de entre varias fuentes de datos
(MUX).
Distribuidor: selecciona uno de entre varios destinos de
datos (DEMUX).
10

Ejemplos de buses:
• Crossbar
• Bus compartido
◦ Usando un selector.
CAMINO DE DATOS
◦ Usando registros con salida triestado.
11

SECCIÓN DE CONTROL
Es el sistema secuencial o autómata que al activar los puntos de
control en el orden adecuado controla las transferencias y transformaciones
de los datos que tienen lugar en el camino de datos y que
implementan un algoritmo específico.
Cada estado o microinstrucción de la sección de control indica qué
puntos de control se activan en cada momento (salidas del autómata)
y, en función de las condiciones (entradas del autómata), cual es
el estado o microinstrucción siguiente.
La sección de control también se puede representar mediante un
diagrama de flujo.
Existen diversos métodos para implementar una sección de control:
1. Tablas de estado.
2. Elementos de retardo.
3. Microprogramación.
Tablas de Estado
• Es la metodología que ya se ha explicado.
• Es compleja, dificil de depurar, no es modular ni flexible y es
dificil realizar modificaciones (no hai una relación evidente entre
la implementación y el algoritmo).
• Su uso es poco frecuente.
• Se denomina “Lógica Aleatoria”.
12

Elementos de retardo
SECCIÓN DE CONTROL
• Implementación sencilla y directa.
• Alta velocidad pero con un alto coste hardware.
• Se utiliza en sistemas relativamente pequeños.
• Cada estado se implementa con un biestable tipo D.
• Exiten equivalencias entre un autómata, un diagrama de flujo y
la implementación mediante elementos de retardo.
⇔ ⇔
⇔ ⇔
13

SECCIÓN DE CONTROL
Los puntos de control que se activan en cada estado se sacan de la
salida del biestable correspondiente.
Para activar un punto de control en dos o más estados:
14

SECCIÓN DE CONTROL
Ejemplo: implementación con elementos de retardo
Autómata Diagrama de Flujo
15

SECCIÓN DE CONTROL
Ejemplo (cont.): implem. con elementos de retardo
16

SECCIÓN DE CONTROL
Ejemplo (cont.): implem. con elementos de retardo
17

SECCIÓN DE CONTROL
Microprogramación
• La implementación es sencilla y estándar.
• El hardware es casi independiente de la implementación.
• Es muy flexible y versátil.
• Fácil de depurar, modificar y ampliar.
• Su funcionamiento es relativamente lento debido a
los accesos a la memoria de control.
• Apta para sistemas grandes y/o complejos.
18

SECCIÓN DE CONTROL
Microprogramación
• Una de las implementaciones más sencillas:
19

SECCIÓN DE CONTROL
Memoria de control
• Almacena la información de control necesaria para
ejecutar el algoritmo.
• Su tamaño viene dado por el número de microinstrucciones
(2 k ) del microprograma por el número de
bits por microinstrucción (m).
• Se puede implementar con una ROM, PROM o RAM.
Contador de microprograma (µP C)
• Direcciona la memoria de control para seleccionar la
siguiente microinstrucción (µI).
20

SECCIÓN DE CONTROL
Registro de microinstrucciones (MIR)
• Almacena la µI que se está ejecutando actualmente.
• Ejemplo de formato doble para codificar las µI:
1. Para instrucciones de salto:
◦ El bit más significativo a cero.
◦ El campo condición indica la condición a verificar.
◦ El campo dirección de salto codifica la dirección de la
siguiente µI a ejecutar si la condición es cierta.
2. Para puntos de control:
◦ El bit más significativo a uno.
◦ Los puntos de control pueden estar codificados (microprogramación
vertical) o no (microprogramación horizontal).
21

SECCIÓN DE CONTROL
El funcionamiento o secuenciamiento puede realizarse de diferentes
formas. Una de las más sencillas:
• a: generación de la dirección siguiente = el µP C se incrementa
(ejecución de la siguiente µI) o se carga una nueva dirección
(salto).
• b: se direcciona la memoria de control = lectura de la µI correspondiente.
• c: carga de la µI direccionada en el MIR.
• d: ejecución de la µI, dos posibilidades:
1. Activación de los puntos de control y desactivación del MUX
de condiciones ⇒ El µP C se incrementa.
2. Selección en el MUX de la condición a verificar. Si se cumple
la salida del MUX = 1 ⇒ el µP C se carga con la dirección
especificada en la µI.
22

SECCIÓN DE CONTROL
Ejemplo de sección de control microprogramada
23

SECCIÓN DE CONTROL
Ejemplo de sección de control microprogramada (cont.)
24

SUMADOR SECUENCIAL
Algoritmo 0 (alto nivel): realiza la operación pero no tiene
en cuenta la sincronización con el exterior.
Cargar A
Cargar B
Borrar C
for I=1 to n
{
}
Di ← Ai ⊕ Bi ⊕ C
C ← Ai · Bi + (Ai ⊕ Bi) · C
25

SUMADOR SECUENCIAL
Algoritmo 1: introduce la sincronización con el exterior mediante
dos señales:
1. Control Input: start, indica cuando comenzar la operación.
2. Control Output: done, indica cuando ha finalizado. Mientras esta
señal esté a cero no puede comenzarse una nueva operación.
También se identifican las entradas y salidas utilizadas:
1. Data Inputs: A, B
2. Data Outputs: D
WAIT: do
done ← 1
while (start)
done ← 0
------------------------------
Cargar A
Cargar B
Borrar C
for I=1 to n
{
Di ← Ai ⊕ Bi ⊕ C
C ← Ai · Bi + (Ai ⊕ Bi) · C
}
-----------------------------goto
WAIT
26

SUMADOR SECUENCIAL
Una vez identificadas las líneas de conexión con el exterior
empezaremos por diseñar un camino de datos capaz
de realizar el algoritmo:
1. Se identifican las unidades de almacenamiento y operadores
necesarios:
• A, B y D: registros de n bits.
• C, done: biestables (registros de 1 bit).
• 1 FA.
• 1 Contador + 1 Comparador.
2. Se establecen las conexiones entre los elementos
del camino de datos identificados y se determinan
los puntos de control necesarios (existen diferentes
alternativas).
27

SUMADOR SECUENCIAL
Camino de datos (alternativa 1)
28

SUMADOR SECUENCIAL
Algoritmo 2: introduce los puntos de control (microoperaciones)
WAIT: do
Preset
while (start)
Clear
LOADA
LOADB
CLEARC
for I=1 to n
{
SHIF TD
LOADC
SHIF T A
SHIF T B
}
goto WAIT
Existen microoperaciones que pueden realizarse simultaneamente
(p.e. LOADA y CLEARC), por lo que ambos puntos de control
pueden activarse simultaneamente y formar una microinstrucción.
Por el contrario hay puntos que no se pueden activar simultaneamente
(p.e. LOADA y LOADB), por lo que formaran microinstrucciones
diferentes.
29

SUMADOR SECUENCIAL
Algoritmo 3: se identifican las operaciones simultaneas
(se reduce el número de microinstrucciones necesarias).
WAIT: do
Preset
while (start)
Clear || LOADA|| CLEARC
LOADB
for I=1 to n
SHIF TD || LOADC|| SHIF T A|| SHIF T B
goto WAIT
30

SUMADOR SECUENCIAL
El último paso consiste en eliminar las estructuras de control complejas
(bucles WHILE, FOR, etc.) remplazándolas por saltos condicionales
(if ) o incondicionales (goto).
do
operación
while (x)
pasaría a ser:
LOOP: operación
if (x) then goto LOOP
for I=1 to n
operación
pasaría a ser:
CLEARI
LOOP: operación || INCI
if (I

SUMADOR SECUENCIAL
Algoritmo 4: se substituyen las estructuras complejas por sus microinstrucciones
equivalentes activando en paralelo los puntos de
control que lo permitan.
WAIT: S0: Preset
if (start) then goto WAIT
S1: Clear || LOADA|| CLEARC|| CLEARI
S2 : LOADB
LOOP: S3: SHIF TD || LOADC|| SHIF T A|| SHIF T B||INCI
if (I

SUMADOR SECUENCIAL
El algoritmo puede expresarse también mediante un autómata
o diagrama de flujo.
33

SUMADOR SECUENCIAL
El camino de datos que implementa una computación no
es único. Otra posibilidad:
34

SUMADOR SECUENCIAL
Algoritmo 4 bis: sólo cambian los puntos de control que se activan
en S3
WAIT: S0: Preset
if (start) then goto WAIT
S1: Clear || LOADA|| CLEARC|| CLEARI
S2 : LOADB
LOOP: S3: SHIF TD || LOADC|| INCI
if (I

SUMADOR SECUENCIAL
Implementación de la sección de control: elementos de
retardo.
36

SUMADOR SECUENCIAL
Implementación de la sección de control: elementos de
retardo.
37

SUMADOR SECUENCIAL
Implementación de la sección de control: microprogramación.
38

SUMADOR SECUENCIAL
Implementación de la sección de control: microprogramación.
39

ÂÊÁÁÇË
×ÖÐÑÖÓÓÓÐÑÑÓÖÊÇÅÐ×ÓÒÓÒØÖÓÐÙÒ××ØÑ ÕÙÖÐÞÐÐÓÖØÑÓÕÙ×ÜÔÓÒÓÒØÒÙÓÒÒÒÓÐÓ×ÚÐÓÖ×Ð× ÒØÖ×ÐÑÙÐØÔÐÜÓÖ×ÐÓÒ×ÐØÓ
ÁÆÁÁÇØÚÖÈÊËÌ ÌËÌÞÞ ÑÔÞÓØÓÁÆÁÁÇ ØÚÖÄÇÊÝÄÊ
ÍÄØÚÖÁÆÊÅÆÌ Ð×ØÚÖËÈÄÊ Ð×ÞÞÓØÓÍÄ ØÚÖÊËÌÝÄÇ ÓØÓÇÊÊÁÇÆ
ÇÊÊÁÇÆØÚÖËÍÅÝÄÇÊ ÁÒÓØÓÍÄ ÓØÓÁÆÁÁÇ ÓØÓÌËÌ
ÓÐÙØÓÑØЬÙÖ×Ò×ÙÓÖÖ×ÔÓÒÒØÙÒÓÒØÖÓÐÑÖÓ ÔÖÓÑÓÑÔÐØ
z
I>n
c
S 0
S 1
S 2
S 3
S 4
S 5
start
z
c
I

ÌÅËÈÁÁÁÇÆÄÇÊÁÌÅÁËÁËÌÅËËÍÆÁÄË Ä×ÙÒجÙÖÖÔÖ×ÒØÙÒÙÒÓÒØÖÓÐÑÔÐÑÒØÓÒÐÑÒØÓ× ÖØÖÓÜØÖ×ÙÙØÓÑØÓÒØÖÓÐÑÔÐÑÒØÐÓÑÒØÐØÒ ÓÒØÖÓÐÑÖÓÔÖÓÖÑÓ D
CLK
0
Q 0
DEMUX
1 a 2
1 0
D1
Q1
D2
Q
2
DEMUX
1 a 2
0 1
Preset
start
I>n
D
Q 3
3
D
Q 4
4
DEMUX
1 a 4
D
Q 5
C2,C7
×ÒÙÒÙÒÓÒØÖÓÐÑÖÓÔÖÓÖÑÓÑÔÐØÓÖÖ×ÔÓÒÒØÐÐÓ
X
ÖØÑÓ×ÙÒØÕÙÖÐÞÐÑÙÐØÔÐÓÒÒØÖÓ×ÒÙÑÖÓ×ÒØÙÖÐ×
00 01 10 11
Y
×ÙÒØ×ØÓ×ØÑÔÓ×ØÐÞÓÒÐÓ×Ö×ØÖÓ×ÝÓÒØÓÖ× ÙØÖÓØ×ØÒÒÓÒÙÒØÐÑÒÓØÓ×ЬÙÖÐÙÐØÑÒ ÙÐ×ÐÑÓÖ×ÒÐÖÐÓÔÖ×ÒÖÓÒÞÖÐ××ØÑØÒÒÓÒÙÒØÐÓ×
5
Ò×ØÑÔÓ
C5
ÖØÖÓÒÐ×ÙÑÓÖØ× ÐÓ×ÑÙÐØÔÐÜÓÖ× Ò×ØÑÔÓ×ÓÐÑÑÓÖÒ× Ò×ØÑÔÓÖØÖÓÒÐÓÑÔÖÓÖÝÒ
ÓÖØÓ Ö Ö ÔÐÙ×
BUS DE ENTRADA
4
4 4
LOAD LX LOAD LY COUNT CON
RELOXO
Rexistro X
Rexistro Y
CONT CLEAR CC
4bits
0
4 4
4
4
4
C SUM
out
C
SUM
in
C
out
C
A B
in
bits
4 bits 0
COMP
AB
4
0
Ò 4
Clear
4
LOAD
Rexistro ACH CLEAR
4
4
C0
C1
C3
C4,C6
LOAD
Rexistro ACL
CLEAR
4
LAC
CAC
BUS DE SAÍDA
Rexistro S
8
LOAD
AB
LS
FIN
D
Q

9.5. Obter o autómata de control e deseñar a unidade de control microprogramada completa que
implemente o algoritmo seguinte:
INICIO: activar READY
IF start goto INICIO
BUCLE: activar OK, STARTING
IF end goto ESPERAR
ELSE
activar OK, SELECT
IF input = 00
activar PROCESSING
ELSE IF input = 01
activar INITIATING
activar PROCESSING
activar DONE
ELSE goto RECUPERAR
END IF
goto BUCLE
ESPERAR: activar WAIT, CHECK
IF ready goto ESPERAR
goto INICIO
RECUPERAR: activar FAULT
IF ready
activar WAIT, RESTORING
goto ESPERAR
END IF
goto BUCLE

9.5. Autómata de Control:
INICIO:
BUCLE:
ESPERAR:
RECUPERAR:
Temos:
ready
i 1 i 0 =00
S 3
start
S 0
end
i 1 i 0 =01
S 1
S 2
S 4
S 5
S 6
start
11 puntos de control
10 microinstruccións de activación
5 condicións no MUX
12 instruccións de salto
end
i 1 i 0 =10
OR
i 1 i 0 =11
(i 1 =1)
ready
S 8
S 9
S 7
ready
ready
{READY}
{OK, STARTING}
{OK, SELECT}
{PROCESSING}
{INITIATING}
{PROCESSING}
{DONE}
{WAIT, CHECK}
{FAULT}
{WAIT, RESTORING}

9.5. Diagrama de Fluxo:
S 3
S 4
S 5
S 6
S 8
ready
no
si
si
si
S 0
start
S 1
no
end
S 2
no
i 1i 0=00
no
i 1 i 0 =01
S 9
no
si
si
si
S 7
ready
no
{READY}
{OK, STARTING}
{OK, SELECT}
{PROCESSING}
{INITIATING}
{PROCESSING}
{DONE}
{WAIT, CHECK}
{FAULT}
{WAIT, RESTORING}

9.5. Implementación con Elementos de Retardo:
PRESET
CLOCK
START
CLEAR
END
i 1i 0 = 00
i 1i 0 = 01
READY
Cl
S 8
Cl
Cl
S 9
Cl
Pr
S 2
S 1
S 0
DEMUX
1 a 2
0 1
DEMUX
1 a 2
0 1
DEMUX
1 a 2
0 1
DEMUX
1 a 2
0 1
DEMUX
1 a 2
0 1
Cl
Cl
Cl
Cl
S 3
S 4
S 5
S 6
Cl
S 7
DEMUX
1 a 2
0 1
READY
STARTING
OK
SELECT
PROCESSING
FAULT
INITIATING
DONE
RESTORING
WAIT
CHECK

9.5. Unidade de Control Microprogramada:
1
start
end
ready
i1i0 = 00
i1i0 = 01
MUX
8 a 1
3
INICIO:
BUCLE:
ESPERAR:
RECUPERAR:
STROBE
00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
INCR
LOAD
CONTADOR MICROPROGRAMA
5
5
ROM
(32 x 12)
12
REG. MICROINSTRUCCIONES
RESTORING
FAULT
CHECK
WAIT
DONE
INITIATING
PROCESSING
SELECT
STARTING
OK
READY
CLK
1 1 0 0 0 0 0 0 0 0 0 0
0 0 0 1 x x x 0 0 0 0 0
1 0 1 1 0 0 0 0 0 0 0 0
0 0 1 0 x x x 0 1 1 1 0
1 0 1 0 1 0 0 0 0 0 0 0
0 1 0 0 x x x 0 1 0 0 0
0 1 0 1 x x x 0 1 0 1 0
0 0 0 0 x x x 1 0 0 0 1
1 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 x x x 0 0 0 1 0
1 0 0 0 0 0 1 0 0 0 0 0
1 0 0 0 0 1 0 0 0 0 0 0
1 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 x x x 0 0 0 1 0
1 0 0 0 0 0 0 0 1 1 0 0
0 0 1 1 x x x 0 1 1 1 0
0 0 0 0 x x x 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0 1 0
0 0 1 1 x x x 1 0 1 0 0
0 0 0 0 x x x 0 0 0 1 0
1 0 0 0 0 0 0 0 1 0 0 1
0 0 0 0 x x x 0 1 1 1 0
. . .
activar READY
IF start goto INICIO
activar OK, STARTING
IF end goto ESPERAR
activar OK, SELECT
IF i 1 i 0 = 00 goto 8
IF i 1 i 0 = 01 goto 10
goto RECUPERAR
activar PROCESSING
goto BUCLE
activar INITIATING
activar PROCESSING
activar DONE
goto BUCLE
activar WAIT, CHECK
IF ready goto ESPERAR
goto INICIO
activar FAULT
IF ready goto 20
goto BUCLE
activar WAIT, RESTORING
goto ESPERAR

[Examen TC Septiembre'2005]
Deseñar a unidade de control microprogramada completa do seguiente algoritmo:
INICIO: activar PREPARADO
IF empezar GOTO INICIO
activar INICIALIZANDO
BUCLE_TIEMPO: activar CALCULAR_INSTANTE
activar INICIALIZAR1, INICIALIZAR2, INICIALIZAR3
IF x 1 x 0 = 11
activar PROCESAR1
ELSE IF x 1 x 0 = 01
activar PROCESAR2
activar DONE
ELSE
IF parar
activar FINALIZAR
GOTO INICIO
END IF
END IF
GOTO TEST
GOTO BUCLE_TIEMPO
TEST: activar PONER_A_CERO
BUCLE_TEST: activar ACUMULAR
IF parar
activar FINALIZAR
GOTO INICIO
END IF
activar COMPARAR
IF converge
GOTO BUCLE_TEST
GOTO BUCLE_TIEMPO

[Examen TC Septiembre'2005]
Autómata de Control:
INICIO:
BUCLE_TIEMPO:
TEST:
BUCLE_TEST:
Temos:
S 4
converge
X 1 X 0 =11
converge
empezar
X 1 X 0 =01
13 puntos de control
12 microinstruccións de activación
5 condicións no MUX
7 instruccións de salto
S 0
S 1
S 2
S 3
S 5
S 6
S 8
S 9
S 11
empezar
parar
(X 1 X 0 =00 AND parar)
OR
(X 1 X 0 =10 AND parar)
(X 0 =0 AND parar)
parar
S 10
S 7
{PREPARADO}
{INICIALIZANDO}
{CALCULAR_INSTANTE}
{INICIALIZAR1,
INICIALIZAR2,
INICIALIZAR3 }
{PROCESAR1}
{PROCESAR2}
{DONE}
{FINALIZAR}
{PONER_A_CERO}
{ACUMULAR}
{FINALIZAR}
{COMPARAR}

[Examen TC Septiembre'2005]
Unidade de control micropogramada:
1
empezar
parar
converge
x1x0 = 11
x1x0 = 01
INICIO:
BUCLE_TIEMPO:
TEST:
BUCLE_TEST:
MUX
8 a 1
00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
3
STROBE
INCR
LOAD
CONTADOR MICROPROGRAMA
5
5
ROM
(32 x 14)
14
REG. MICROINSTRUCCIONES
PONER_A_CERO
FINALIZAR
DONE
PROCESAR2
PROCESAR1
INICIALIAR3
INICIALIZAR2
INICIALIZAR1
CALCULAR_INSTANTE
INICIALIZANDO
PREPARADO
. . .
COMPARAR
ACUMULAR
CLK
1 1 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 x x x x x 0 0 0 0 0
1 0 1 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 1 1 0 0 0 0 0 0 0
0 1 0 0 x x x x x 0 1 0 0 1
0 1 0 1 x x x x x 0 1 0 1 1
0 0 1 0 x x x x x 0 1 1 1 0
0 0 0 0 x x x x x 1 0 0 0 0
1 0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 x x x x x 1 0 0 0 0
1 0 0 0 0 0 0 0 1 0 0 0 0 0
1 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 x x x x x 1 0 0 0 0
1 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 x x x x x 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0 0 1 0 0
1 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 1 0 x x x x x 0 1 1 1 0
1 0 0 0 0 0 0 0 0 0 0 0 0 01
0 0 1 1 x x x x x 1 0 0 0 1
0 0 0 0 x x x x x 0 0 0 1 1
activar PREPARADO
IF empezar goto INICIO
activar INICIALIZANDO
activar CALCULAR_INSTANTE
activar INIC1, INIC2, INIC3
IF x 1 x 0 = 11 goto 9
IF x 1 x 0 = 01 goto 11
IF parar goto 14
goto TEST
activar PROCESAR1
goto TEST
activar PROCESAR2
activar DONE
goto TEST
activar FINALIZAR
goto INICIO
activar PONER_A_CERO
activar ACUMULAR
IF parar goto 14
activar COMPARAR
IF converge goto BUCLE_TEST
goto BUCLE_TIEMPO