Este documento describe la arquitectura de una unidad de datos (CS1) que incluye registros, una ALU y una memoria RAM. Explica cómo la CS1 ejecuta instrucciones de forma autónoma al almacenarlas en memoria e ir cargando sucesivamente las instrucciones en un registro de instrucción. Detalla las fases de búsqueda y ejecución de instrucciones, usando como ejemplo la instrucción ADD. Finalmente, muestra un pequeño programa de ejemplo y su representación en memoria RAM.

1. CS1: Unidad de datos
RT
AC
ALU
8
6
R W
AB
DB
RAM 26x8
• Aumentar la cantidad de datos a
manejar:
• incrementar el número de registros
• incluir una memoria RAM
• Ejecutar las instrucciones de forma
autónoma:
• Almacenar las instrucciones en una
memoria:
• en la memoria donde se almacenan los
datos: arquitectura Von Neumann
• en otra memoria, específica para
instrucciones: arquitectura Harvard
• La instrucción a ejecutar se extrae de
la memoria y se almacena
temporalmente en el registro de
instrucción (IR, Instruction Register)
CS1
CS1
Datos e
instrucciones
WT
ZAC
RAC
s
r
WAC

2. CS1: Unidad de datos (2)
• En el CS1, las instrucciones
incluyen un campo de dirección de
operando (CD) donde se indica la
dirección de la RAM donde se
encuentra el operando
Cada instrucción tiene dos partes:
• Código de operación (CO): tipo de
operación a realizar
• Operandos: datos con los que la
instrucción va a trabajar:
• A veces la instrucción no necesita
operandos; otras veces, los
operandos están implícitos y no hay
que incluirlos en la instrucción
CS1
R W
AB
DB
RAM 26x8
6
OpCD
CONTROLXs
CO
IR
TB
2
6[8]
8
CS1 • |IR|=8bits; |CD|=6bits ⇒
|CO|=2bits ⇒ 4 tipos de instrucciones

3. CS1: Unidad de datos (3)
• Una vez ejecutada la instrucción actual, hay que extraer la
siguiente desde memoria y almacenarla en IR
• Para ello es necesario un registro puntero de instrucciones
(PC, Program Counter):
• almacena la dirección de memoria donde se encuentra la
siguiente instrucción
• una vez transferida la nueva instrucción a IR, hay que
incrementar PC (IPC) para apuntar a la siguiente
• inicialmente, PC vale 0 (CLPC), por lo que la primera instrucción
siempre estará en la dirección 0 de la RAM
PC
6
IPC
CLPC

4. CS1: Unidad de datos (4)
ALU
RT
AC
AB
DB
RAM 26x8
CONTROL
IR[8]
CO CD
2
6
TB
MAR
TIR
TPC
PC
6
IPC
CLPC PC
6
CD
6
El bus de
direcciones de la
RAM debe ser
accedido por:
R W
6
• El campo CD
del registro IR:
para poder
acceder al
operando en
memoria
8
WT
• El registro PC:
para poder
indicar la
dirección de la
siguiente
instrucción
s
r
Xs
WAC
ZAC
RAC
• Se incluye el registro de direcciones de memoria (MAR, Memory
Address Register) para almacenar temporalmente la dirección de la
instrucción (TPC) o del dato (TIR)

5. CS1: Instrucciones
1. Fase de búsqueda (fetch): la unidad de
control se encarga de emitir las
microoperaciones que permiten cargar en IR la
instrucción apuntada por PC;
2. Fase de ejecución (exec): la unidad de
control se encarga de emitir las
microoperaciones necesarias (entre otras,
acceder a los operandos) en función del código
de operación de la instrucción.
1
0
Xs
PC ← 0
CARTA ASM DE
BUSQUEDA
01, 10, 11
(ADD, SUB,
STA)
00
(STOP)
CO
CARTAASM
DEEJECUCIÓN
Las instrucciones del CS1 son:
CO (IR7-6) Registro IR Mnemónico Descripción nivel RT
00 0 0 x x x x x x STOP (Fin ejecución)
01 0 1 A5 A4 A3 A2 A1 A0 ADD A5-0 AC ← AC + RAM(A5-0)
10 1 0 A5 A4 A3 A2 A1 A0 SUB A5-0 AC ← AC - RAM(A5-0)
11 1 1 A5 A4 A3 A2 A1 A0 STA A5-0 RAM(A5-0) ← AC

6. CS1: Instrucciones. Fase de búsqueda (1)
En el CS1, para
cargar la
siguiente
instrucción en IR,
necesitamos dos
ciclos de reloj:
6
AB
DB
RAM 26x8
MAR
TIR
TPC
PC
6
IPC
CLPC
Dir_Instr (dirección de la instrucción)
R W
ALU
RT
AC
CONTROL
CO CD
2
IR[8]
1. MAR ← PC
6
8
TB
WT
2. IR ← RAM;
PC ← PC + 1
s
r
Xs
WAC
ZAC
RAC

7. CS1: Instrucciones. Fase de búsqueda (2)
6
AB
DB
RAM 26x8
MAR
TIR
TPC
PC
6
IPC
CLPC
Dir_Instr
Dir_Instr
Dir_Instr
R W
Dir_Instr Instrucción
ALU
RT
AC
8
CONTROL
CO CD
2
Instrucción
IR[8]
1. MAR ← PC
6
TB
WT
2. IR ← RAM;
PC ← PC + 1
s
r
Xs
WAC
ZAC
RAC

8. CS1: Instrucciones. Fase de búsqueda (fin)
Tras la fase de
búsqueda:
• la instrucción
a ejecutar está
almacenada en
IR
• PC contiene la
dirección de la
siguiente
instrucción
6
AB
DB
RAM 26x8
MAR
TIR
TPC
PC
6
IPC
CLPC
Dir_Instr
Dir_Instr
Dir_Instr +1
R W
ALU
RT
AC
CONTROL
IR[8]
CO CD
2
6
Instrucción
8
TB
WT
s
r
Xs
WAC
ZAC
RAC

9. CS1: Instrucciones. Fase de ejecución [ADD] (1)
RT
AC
ALU
8
6
AB
DB
RAM 26x8
CONTROL
IR[8]
Dir_dato
2
6
TB
MAR
TIR
TPC
PC
6
IPC
CLPC
01
(ADD)
La fase de
ejecución
comienza donde
terminó la fase de
búsqueda.
ADD:
AC ← AC + RAM(Dir_dato)
1º Extraer el dato
(2 clk):
AC0
Dir_Instr +1
Dir_Instr
Dir_Instr
R W
WT
1. MAR ← IR s
2. RT ← RAM
r
Xs
2º Realizar la suma
(1 clk):
WAC
ZAC
RAC
3. AC ← AC + RT
Nota: antes de comenzar, AC = AC0

10. CS1: Instrucciones. Fase de ejecución (2)
6
AB
DB
RAM 26x8
MAR
TIR
TPC
PC
6
IPC
CLPC
Dir_dato
Dir_dato
Dir_Instr +1
R W
Dir_dato Dato
LU
RT
WT
AC AC0
WAC
ZAC
RAC
s
r A
8
CONTROL
IR[8]
Dir_dato
2
6
01
(ADD)
Xs
TB
ADD:
AC ← AC + RAM(Dir_dato)
1º Extraer el dato
(2 clk):
Dato
1. MAR ← IR
2. RT ← RAM
2º Realizar la suma
(1 clk):
3. AC ← AC + RT

11. CS1: Instrucciones. Fase de ejecución (3)
6
AB
DB
RAM 26x8
MAR
TIR
TPC
PC
6
IPC
CLPC
Dir_dato
Dir_dato
Dir_Instr +1
R W
AC
LU
AC0
AC+Dato
RT
Dato
WT
WAC
ZAC
RAC
s
r A
8
CONTROL
IR[8]
Dir_dato
2
6
01
(ADD)TB
ADD:
AC ← AC + RAM(Dir_dato)
1º Extraer el dato
(2 clk):
1. MAR ← IR
2. RT ← RAM Xs
2º Realizar la suma
(1 clk):
3. AC ← AC + RT

12. CS1: Instrucciones. Fase de ejecución (fin)
Al terminar la
fase de
ejecución de
ADD, el registro
AC queda
actualizado con
el resultado de
la suma.
El sistema está
listo para buscar
y ejecutar la
siguiente
instrucción
(apuntada por
PC).
6
AB
DB
RAM 26x8
MAR
TIR
TPC
PC
6
IPC
CLPC
Dir_dato
Dir_dato
Dir_Instr +1
R W
LU
RT
Dato
WT
AC
WAC
ZAC
RAC
AC0+Dato
s
r A
CONTROL
IR[8]
Dir_dato
2
6
01
(ADD)
8
TB
Xs

13. MAR ← PC
(TPC)
S1
IR ← RAM
PC ← PC + 1
(R, TB, IPC)
S2
RT ← RAM
(R, WT)
11 01, 10
IR7,6
S4
RAM←AC
(RAC, W)
01, 10, 11
00
IR7,6
S3
01 10
IR7,6
AC ← AC+RT
(s, WAC)
AC ← AC-RT
(r, WAC)
S5
MAR ← IR
(TIR)
Espera Xs,
PC ← 0 (CLPC)
CS1: Controlador. Carta ASM
Ejecución
IR ← RAM; PC ← PC + 1
(R, TB, IPC)
MAR ← PC (TPC)1
2
Búsqueda
-AC ← AC - RT
(r, WAC)
AC ← AC + RT
(s, WAC)
-5
RAM ← AC
(RAC, W)
RT ← RAM
(R, WT)
-4
MAR ← IR (TIR)NOP3
STA A
IR7,6=11
SUB A
IR7,6=10
ADD A
IR7,6=01
STOP
IR7,6=00

14. MAR ← PC
(TPC)
S1
IR ← RAM
PC ← PC + 1
(R, TB, IPC)
S2
RT ← RAM
(R, WT)
11 01, 10
IR7,6
S4
RAM←AC
(RAC, W)
01, 10, 11
00
IR7,6
S3
01 10
IR7,6
AC ← AC+RT
(s, WAC)
AC ← AC-RT
(r, WAC)
S5
MAR ← IR
(TIR)
Espera Xs,
PC ← 0 (CLPC)
CS1: Controlador. Implementación 1 b/e
0
1
D q
1
≥1
0
1
2
3
0
1
DEC2:4
D q
2
D q
3
D q
4
D q
5
0
1
0
1
CLPC
Xs
IR7
TPC R1, TB, IPC
TIR
RAC,
W
R2, WT WAC
sr
IR6
(ADD)
(STOP)
(STA)
≥1
R1
R2
R

15. CS1: Ejemplo de programa
DIR CONTENIDO RAM RT
00 1 1 1 0 0 0 0 0 STA $20 RAM($20) ← AC
01 1 0 1 0 0 0 0 0 SUB $20 AC ← AC – RAM($20)
02 0 1 1 1 1 1 1 0 ADD $3E AC ← AC + RAM($3E)
03 0 1 1 1 1 1 0 1 ADD $3D AC ← AC + RAM($3D)
04 1 0 1 1 1 1 0 0 SUB $3C AC ← AC – RAM($3C)
05 1 1 1 1 1 1 1 1 STA $3F RAM($3F) ← AC
06 0 0 0 0 0 0 0 0 STOP
... ... ...
20 Uso transitorio
... ... ...
3C Sustraendo: R
3D Sumando 2: S2
3E Sumando 1: S1
3F Resultado
CO (IR7-6) Registro IR Mnemónico Descripción nivel RT
00 0 0 x x x x x x STOP (Fin ejecución)
01 0 1 A5 A4 A3 A2 A1 A0 ADD A5-0 AC ← AC + RAM(A5-0)
10 1 0 A5 A4 A3 A2 A1 A0 SUB A5-0 AC ← AC - RAM(A5-0)
11 1 1 A5 A4 A3 A2 A1 A0 STA A5-0 RAM(A5-0) ← AC
AC = 0
AC = S1
AC = S1 + S2
AC = S1 + S2 – R
Resultado = S1 + S2 - R