Resumen de intrucciones

CONJUNTO DE INSTRUCCIONES DE CS1

La palabra de instrucción tiene un tamaño de doce bits , de los cuales los cuatro bits más significativos componen la parte de operación, mientras que la parte de dirección estará formada por los ocho bits restantes. Esto nos lleva a disponer de dieciseis (24) operaciones posibles, y a tener que utilizar una memoria RAM de 256 (28) direcciones de emoria, cada una de ellas con un ancho de 12 bits.

Las dieciseis instrucciones elegidas son las recogidas en la Tab. 1. Seguidamente se desarrolla cada una de ellas.
De forma global puede observarse que a pesar de ser sólo 16 instrucciones, las hay de transferencia de datos, aritméticas, lógicas, de salto (incondicional y condicional), de control de estado y de subrutinas. Asímismo se incluyen los modos de direccionamiento siguientes:

inmediato (IMmediate) en LAIM.
directo en LDA, STA,ADD, SUB, JMP, BCS, DBZ y JSR.
indirecto en ADDI.
implícito en ROR, ROL, CLC, SEC, STOP y RTS.

En el desarrollo de cada instrucción que se presenta a continuación se indica:

Descripción en mnemónico, como operación RT y código máquina
Realización mediante secuencia de microoperaciones
Una breve explicación verbal.

Tabla 1: Relación de instrucciones de CS1

Código	Mnemónico	Operación	Descripción
0	LAIM	AC<-AA	Transf.: carga AC con el dato AA
1	LDA	AC<-M	Transf.: cargar en AC
2	STA	M<-AC	Transf.: almacenar en M
3	ADD	AC<-AC+M	Arit.: suma
4	SUB	AC<-AC-M	Arit: diferencia
5	ADDI	AC<-AC+M($[M]_7-0)	Arit: suma indirecta
6	ROR	SHR(C,AC),C<-AC₀	Log.: desp. a derecha (con carry)
7	ROL	SHL(AC,C),C<-AC₁₁	Log.: desp. a izquierda(con carry)
8	JMP	GOTO $AA	Salto: salto incondicional
9	BCS	C=0 : GOTO N+1 C=1 : GOTO $AA	Salto: salto condicional si C=1 salta a $AA
A	DBZ	M<-M-1 Z=1 : GOTO N+1 Z=0 : GOTO N+2	Salto: decrementa y salta si cero
B	CLC	C<-0	Estado: Pone carry a 0
C	SEC	C<-1	Estado: Pone carry a 1
D	STOP		Control: Parada
E	JSR	SP<-SP-1 M(SP) <-PC GOTO $AA.	Salto: salto a subrutina
F	RTS	PC<-[M(SP)] SP <- SP + 1	Salto: retorno de subrutina

NOTAS:

AA, 8 bits que estan en el campo de direcciones.
M es la palabra de memoria cuya dirección se indica en la instrucción.
C es el bit de acarreo (Carry).
N es la dirección donde se encuentra la instrucción.
Z es el bit de valor cero (Zero).

OPERACIÓN 0

Cargar acumulador (modo inmediato)
(Load Accumulator IMmediate)

LAIM : AC <- AA	0000 A₇-A₀
1. RT <- 0_11-8 IR_7-0;AC<-0;	R₈,CIM,WT,ZA
2. AC <- AC + RT	RT,A,WA

El valor AA suministrado en el campo de direcciones de la instrucción se almacena en el acumulador. Se usa para almacenar datos conocidos por el programador. Durante su ejecución se pierde el contenido previo del registro RT y del biestable BC.

OPERACIÓN 1

Cargar acumulador (modo directo)
(LoaD Accumulator)

LDA($AA) : AC <- M	0001 A₇-A₀
1. MAR <- IR	TIR
2. RT <- RAM ; AC <- 0	ZA,WT,R
3. AC <- AC + RT	RT,A,WA

Se trata de una operación de transferencia entre registros. Se transvasa el contenido de la memoria RAM, en la dirección que indica la instrucción, al registro acumulador.

OPERACIÓN 2

Almacenar el acumulador en la memoria (modo directo)
(STore Accumulator)

STA($AA) : M <- AC	0010 A₇-A₀
1. MAR <- IR	TIR
2. RAM <- AC	RA, W

Es una operación de transferencia entre registros. El contenido del registro acumulador se transvasa a la memoria RAM del sistema, en la dirección que indica la instrucción.

OPERACIÓN 3

Suma (modo directo)
(ADDition)

ADD($AA) : AC <- AC + M	0011 A₇-A₀
1. AR <- IR	TIR
2. RT <- RAM	WT,R
3. AC <- AC + RT	RT,A,WA

Es una operación aritmética. Se trata de sumar el contenido del registro acumulador con el dato almacenado en la memoria RAM del sistema, en la dirección que indica la instrucción. El resultado se almacena en el registro acumulador.

OPERACIÓN 4

Resta (modo directo)
(SUBstraction)

SUB($AA) : AC <- AC - M	0100 A₇-A₀
1. AR <- IR	TIR
2. RT <- RAM	WT,R
3. AC <- AC - RT	RT,S,WA

Operación aritmética. Al contenido del registro acumulador se le resta el contenido de la memoria RAM en la dirección que le indica la instrucción. El resultado se almacena en el registro acumulador.

OPERACIÓN 5

Suma indirecta (modo indirecto)
(ADDition Indirect)

ADDI($AA) : AC <- AC + M[$[M]_7-0]	0101 A₇-A₀
1. AR <- IR	TIR
2. IR_7-0<- RAM_7-0	R, W8
3. AR <- IR	TIR
4. RT <- RAM	R, WT
5. AC <- AC + RT	RT, A, WA

Operación aritmética. En ella se suma, al contenido del registro acumulador el dato cuya dirección de memoria, se encuentra almacenada en la dirección de memoria que se indica en la instrucción. El resultado de esta operación se almacena en el registro acumulador.

OPERACIÓN 6

Rotación a derecha del acumulador (modo implícito)
(ROtate Right)

ROR : AC <- SHR(AC,C)	0110 ---- ----
1. AC <- SHR(AC, C); BC <- AC₀	RR

Operación de tipo lógico. Se trata del desplazamiento circular a la derecha del contenido del registro acumulador junto con el del biestable de acarreo. Por ello, el bit menos significativo AC₀ se almacena en el biestable BC, mientras que la entrada serie en el acumulador es el bit C.

OPERACIÓN 7

Rotación a izquierda del acumulador (modo implícito)
(ROtate Left)

ROL : AC <- SHL(AC,C)	0111 ---- ----
1. AC <- SHL(AC, C); BC <- AC₁₁	RL

Operación de tipo lógico. Similar a la anterior salvo que el desplazamiento circular es a la izquierda.

OPERACiÓN 8

Salto incondicional (modo directo)
(JuMP)

JMP($AA): GOTO $AA	1000 A₇-A₀
1. PC <- IR_7-0	R8, WPC

Operación "de salto". En este caso se trata de que la próxima instrucción a ejecutar es la de la dirección de memoria indicada por la instrucción.

OPERACIÓN 9

Salta si el acarreo es 1 (modo directo)
(Branch if Carry Set)

BCS($AA): C: GOTO $AA	1001 A₇-A₀
1. C: PC <- IR_7-0	R8, WPC

Es una operación "de salto". Es similar a la anterior salvo que es salto condicional, es decir, depende del estado en que se encuentre el biestable BC: si está a "0", no se producirá el salto y seguirá con la instrucción siguiente (N+1); si está a "1" se produce el salto a la instrucción almacenada en $AA.

OPERACIÓN A

Decrementa y salta si es cero (modo directo)
(Decrement and Branch if Zero)

DBZ($AA) : IF(M-1!=0) THEN GOTO N+2......1010 A7-A0

ADDI($AA) : AC <- AC + M[$[M]_7-0]	0101 A₇-A₀
1. MAR <- IR	TIR
2. RT <- RAM	R, WT
3. RT <- RT - 1	DT
4. RAM <- RT; Z: PC <- PC + 1	RT, W IPC

Operación "de salto". Esta operación decrementa en una unidad el contenido de la dirección de memoria determinada por la instrucción y, dependiendo del resultado, ejecuta la instrucción siguiente (N+1) si es nulo, o salta a la que sigue (N+2), si no es nulo. En todo caso, el resultado obtenido tras decrementar, se vuelve a almacenar en la misma posición de memoria. La variable Z, llamada variable CERO,nos indica si el contenido del registro del cual se toma es cero (Z=1), o no (Z=0).

OPERACIÓN B

Borrar acarreo (modo implicito)
(CLear Carry)

CLC: C <- 0	1100 ---- ----
1. BC <- 0	CC

Operación "de estado". Coloca a "0" el biestable BC.

OPERACIÓN C

Poner a "1" el acarreo (modo implícito)
(SEt Carry)

SEC: C <- 1	1101 ---- ----
1. BC <- 1	SC

Operación "de estado". Coloca a "1" el biestable BC.

OPERACIÓN D

Parada (modo implícito)
(STOP)

STOP:	1101 ---- ----
---	S0

Operación de control. Se trata de la operación de parada y es la última del programa. Como se ve no hay que realizar ninguna operación; sólo hay que colocar al sistema en el estado de espera S0, del cual saldrá cuando se active la señal de comienzo XS.

OPERACIÓN E

Llamada a subrutina (modo directo)
(Jump SubRoutine)

JSR($AA) : PUSH[PC], GOTO $AA	1110 A₇-A₀
1. SP <- SP - 1	DS
2. AR <- SP	TSP
3. RAM <- PC	RPC, W
4. PC <- IR_7-0	R8, WPC

Operación "de salto". Es el salto a subrutina. Para ello se almacenará la dirección de retorno en la pila (PUSH [PC]) y,después, se cargará el contador de programa PC con la dirección de comienzo de la subrutina ($AA, dada en la instruccion). La operación de pila en nuestro caso, PUSH [PC] requiere las transferencias:

SP <- SP - 1
M(SP) <- PC.

OPERACIÓN F

Retorno de subrutina (modo implícito)
(ReTurn of Subroutine)

RTS : PC <- PULL (pila)	1111 ---- ----
1. AR <- SP	TSP
2. PC <- RAM ; SP <- SP + 1	R,WPC,IS

Operación "de salto". Se trata del retorno de una subrutina. La instrucción RTS es la última de cualquier subrutina. Su ejecución hace que el contador de programa se cargue con el dato extraído de la pila (PC <- PULL (pila)). En nuestro caso, PC <- PULL (pila) requiere las transferencias:

PC <- M(SP)
SP <- SP + 1.