Este documento proporciona instrucciones sobre programación en CODE 2. Explica la operación lógica NAND, el uso de subrutinas mediante las instrucciones CALL y RET, y cómo manipular arreglos (tablas) mediante punteros y direcciones de memoria. Muestra ejemplos de código para intercambiar registros, llamar a subrutinas y recorrer arreglos.

1. Guía 5(3): programación en CODE 2
1

2. GUÍA DIDÁCTICA 5 (3):CODE 2
 NAND
 Subrutinas
 Arreglos
2

3. VEREMOS ALGUNAS DE LAS INSTRUCCIONES
NAND: (operación lógica NAND)
Instrucción: operación lógica NAND (bit a bit) del
contenido 2 registros.
Código de operación: 1000 (8 en hexadecimal)
Tipo de formato: F4
Instrucción en nemónico: NAND rx,rs,ra
Descripción de función a realizar: rx ← (𝒓𝒔. 𝒓𝒂)
3
EJEMPLO
NAND r1, rD, rE
1000 0001 1101 1110; 80DE
(codop) rx rs ra
a b (𝒂. 𝒃)
0 0 1
0 1 1
1 0 1
1 1 0

4. VEREMOS ALGUNAS DE LAS INSTRUCCIONES:
NAND
4
Ejemplo
NAND r1, rD, rE
1000 0001 1101 1110; 81DE
0000
0001
003D
003E
003F
FFFE
FFFF
Direcciones de memoria
ALU
NAND
BFEF
0001
4C54
E03B
BFEF
93E7
RF
RE
RD
R1
R0
MEMORIA
Instrucción
E03B 4C54
Registros
81DE
37BA
4C54
70DE
732C
BC39
IR 81DE
PC 003F

5. EJEMPLO DE PROGRAMA
Hacer un programa que empiece en la dirección de memoria H’0100
que coloque en el registro r6 el resultado de la operación lógica AND
entre los registros r4 y r5.
Aplicando algunas leyes lógicas tenemos que:
X AND Y = X NAND Y
Por otro lado, sabemos que X = X NAND X, así que el programa
queda:
ORG H’0100
NAND r6, r4, r5 ; r6 ← r4 NAND r5
NAND r6, r6, r6 ; r6 ← NOT(r6), implementada con NAND
HALT
END 5

6. EJERCICIO: SWAPPING
 Intercambiar el contenido de dos registros:
 Pasos del algoritmo:
6
7 1
r0 r1
1 7
r0 r1
7 1
r0 r1
7
r2
r2  r0
r0  r1
r1  r2
1 7
Swapping entre r0 (A) y
r1(B). El auxiliar será el
r2:
LLI r3,00
ADDS r2,r0,r3
ADSS r0,r1,r3
ADDS r1,r2,r3

7. SUBRUTINAS
 Las subrutinas (o procedimientos o
subprogramas) son secciones
especiales de un programa con el
objetivo específico de realizar una tarea
concreta.
 Generalmente, las subrutinas contienen
el código de la resolución de problemas
comunes y de uso repetitivo.
 Ejemplos de problemas: búsqueda del
mayor de un grupo de datos, cantidad de
números positivos, ordenar un grupo de
números, etc.
 En CODE2 las subrutinas son
manipuladas con CALL (instrucción de
llamada desde el programa a la
subrutina) y RET (instrucción de retorno
desde la subrutina al programa). 7

8. PILA DE LLAMADAS (CALL STACK)
 En Ciencias de la Computación, una pila de llamadas (en inglés call
stack) es una estructura dinámica de datos LIFO, (una pila), que
almacena la información sobre el seguimiento de las subrutinas
activas de un programa de computadora. Una pila se almacena en una
área determinada de memoria.
 La principal razón de su uso, es seguir el curso del punto al cual cada
subrutina activa debe retornar el control cuando termine de ejecutar.
 Las subrutinas activas son las que se han llamado pero todavía no
han completado su ejecución ni retornado al lugar siguiente desde
donde han sido llamadas.
8

9. PILA DE LLAMADAS (CALL STACK)Y PUNTERO DE
PILA (STACK POINTER)
 La pila de llamadas se organiza como una pila, el programa que llama
(a la subrutina) empuja (push o apila) la dirección de retorno en la pila
(la dirección en la que el programa continuará después de volver de la
subrutina), y la subrutina llamada, cuando finaliza, retira (pop o
desapila) la dirección de retorno de la pila de llamadas y transfiere el
control a esa dirección.
 El puntero de pila (Stack Pointer o SP) es un registro usado para
indicar el último lugar apilado en la pila. Cuando se apila, el SP es
decrementado antes de colocar el item en la pila. Cuando se
desapila,el SP es incrementado después de retirar un item de la pila.
 En CODE2, el registro rE es el puntero de pila.
9

10. SUBRUTINAS
10
Apilar en la pila Dirección retorno Subrutina A
Dirección retorno Subrutina B
Stack (pila)
• Llamada a la subrutina desde el programa
SP (rE)
Dirección retorno Subrutina S
Se apila de abajo hacia arriba y las
direcciones crecen hacia abajo, por lo
tanto, cuando se apila, el SP de la
subrutina apilada se consigue
restando 1. Queda rErE-1

11. SUBRUTINAS
11
Desapilar en la pila
Dirección retorno Subrutina A
Dirección retorno Subrutina B
Stack (pila)
• Retorno desde la subrutina al programa
SP (rE)
Dirección retorno Subrutina S
Como se desapila (desaparece la
cabeza de la pila), el SP pasa a
la dirección de abajo, esto es,se
le suma 1. Queda rErE+1

12. CALL: SUBRUTINAS EN CODE2
CALL-(llamada a subrutina desde programa)
Instrucción: llamada a subrutina
Código de operación: 1101 (D en hexadecimal)
Tipo de formato: F2
Instrucción en nemónico:
CALLR (llamada incondicional)
CALLZ (llamada si Z=1)
CALLS (llamada si S=1)
CALLC (llamada si C=1)
CALLV (llamada si V=1)
Descripción de función a realizar: Si cnd es incondicional o si se cumple la
condición según un biestable, se cumple: rE←rE-1, M(rE)←PC, PC←rD. Esto es,
decrementa el puntero de llamada (rE), el contenido del PC es almacenado en la
dirección que indica rE y finalmente el contenido de rD es almacenado en el PC.El
rD lo define el programador. 12

13. 0043
CALLZ
13
Ejemplo
Llamada a C03B si Z=1
LLI rD,3B 2D3B ; se puede usar LO
LHI rD,C0 3DC0; se puede usar HI
CALLZ D100 (1101 0001 0000 0000)
Registros
0000
0001
0042
C03B
F7FC
F7FD
F7FE
F7FF
FFFE
FFFF
Direcciones de memoria
0001
F7FC
C03B
FFEF
4C19
RF
RE
RD
R1
R0
MEMORIA
Instrucción
37BA
4C54
D100
0043
007C
37AB
IR D100
PC C03B
1
2
732C
BC79
43C2
pila
Puntero de pila
rE←rE-1
M(rE)←PC
PC←rD
1
Subrutina
Guarda la dirección para
cuando termine la ejecución
de subrutina
C03B
Hay que cargar
en rE la
dirección de la
cabecera de
pila
rErE-1

14. RET
RET (retorno de subrutina)
Instrucción: retorno desde la subrutina al programa que la llamó,
exactamente, vuelve a la instrucción siguiente después del CALL que
la llamó.
Código de operación: 1110 (E en hexadecimal)
Tipo de formato: F0
Instrucción en nemónico: RET
Descripción de función a realizar: PC←M(rE); rE←rE+1. Debe
cambiarse el contenido del PC por el valor de la cabecera de pila de
llamadas y aumentar en 1 el puntero de pila (rE).
Observación: RET es la última instrucción del cuerpo de la subrutina.
14

15. 0043
RET
15
Ejemplo
RET
1110 1111 1111 1111 EFFF
Registros
0000
0001
C0F7
C03B
F7FC
F7FD
F7FE
F7FF
FFFE
FFFF
Direcciones de memoria
0001
F7FC
C03B
FFEF
4C19
RF
RE
RD
R1
R0
MEMORIA
Instrucción
37BA
4C54
EFFF
0043
007C
37AB
IR EFFF
PC
732C
BC79
43C2
pila
Puntero de pila
PC←M(rE)
rE←rE+1

16. ORG H'01000 ; Comienzo de programa ========
LLI rd, 00 ; rd = H’0000
LLI r7,00 ; r7=H'0000
LD r0,[0A] ; carga desde memoria
LD r1,[0B]
LLI rd, LO(subr)
LHI rd, HI(subr)
CALLR ; Llamo a la subrutina incondicional
LLI rd, 00 ; rd = H’0000
LD r0,[0C]
LD r1,[0D]
LLI rd, LO(subr)
LHI rd, HI(subr)
CALLR ; Llamo a la subrutina incondicional
HALT ; Termino
ORG H'0200 ; Comienza la subrutina
Subr: OUT OP1,r0
OUT OP2,r1
ADDS r2,r0,r7
ADDS r0,r1,r7
ADDS r1,r2,r7
OUT OP1,r0
OUT OP2,r1
RET ;fin de subrutina. Retorno al PP
END ; fin de programa
16
Subrutina2015a
Intercambiar el
contenido (swapping)
entre dos palabras de
memoria usando el
swapping de
registros. Llamar a la
subrutina dos veces
con valores distintos.

17. ORG H'0100 ; Comienza programa principal ==========
IN r1, 02 ; r1 = IP1 leo dato
IN r2, 03 ; r2 = IP2 leo dato
LLI rd,LO(subrut)
LHI rd,HI(subrut)
CALLR ; Llamo a la subrutina incondicional
HALT ; Espera en PP ( programa principal)
ORG H'0200 ;Comienza subrutina ================
subrut: SUBS r3, r1, r2 ; r3 = r1 – r2
LLI RD,LO(menorr1) ; preparo salto
LHI RD,HI(menorr1) ; preparo salto
BC ; salto si r2>r1
OUT 01, r2 ; OP1 = r2 (el menr)
OUT 02, r1 ; OP2 = r1 (el mayor)
RET ; retorno al prog. princ.
menorr1:OUT 01, r1 ; OP1 = r1 (el menor)
OUT 02, r2 ; OP2 = r2 (el menor)
RET ; Fin de subrutina. Retorno al prog. princ.
END ;Fin de programa principal
17
EJEMPLO DE
SUBRUTINA
Hacer un programa que empiece en la dirección H’0100 que pida dos
números por el teclado, que los coloque en los registros r1 y r2, y que llame
a una subrutina que empiece en la dirección 0200 que muestre por el puerto
OP1 el menor y por el puerto OP2 el mayor

18. TABLAS (ARREGLOS)
 Las tablas o arreglos (Arrays) son estructuras de datos, esto es, un
tipo de dato construido a partir de otros tipos de datos. Ejemplo; un
número complejo formado por dos números reales.
 Un arreglo es una estructura de datos forma por una cantidad fija de
datos de un mismo tipo (componentes), cada uno de los cuales tiene
asociado uno o mas índices que determinan de forma unívoca la
posición del dato dentro del arreglo.
 Ejemplo de arreglo lineal (un índice):
 Componentes: 4,78,1,0,112,-7,2,23,-2
 Índices correspondientes: 1,2,3,4,5,6,7,8 y 9. 18
4 78 1 0 112 -7 2 23 -2
1 2 3 4 5 6 7 8 9

19. TABLAS (ARREGLOS) EN CODE2
Una tabla almacenada en la memoria de CODE2 se vería así:
19
En rA está la dirección
del primer elemento
del arreglo
En rB está la dirección del
último elemento del arreglo
Elementos del
arreglo

20. TABLAS (ARREGLOS) EN CODE2
20
• Para operar los arreglos lineales en CODE2 se debe
recorrer la estructura de datos. Vamos a mostrar las
instrucciones para acceder a los elementos.
• Supongamos que el arreglo se encuentra en memoria y
sabemos que en rA se encuentra la dirección donde
comienza el arreglo y en rB la dirección donde termina.
• Usaremos a r2 como puntero al arreglo y r3 para operar
con el elemento:

21. TABLAS (ARREGLOS) EN CODE2
LLI r0,00
LLI r1,01
ADDS r2,rA,r0 ; valor inicial del puntero
SIGUE: LLI rD, LO(FIN) ; dirección del final del programa (Inst. que está en la
LHI rD,HI(FIN) ; dirección XXXX)
SUBS rF,rB,r2 ; ver si el puntero sobrepasa la dirección de final de la tabla
BS ; si sobrepasa el final del arreglo, salta al final del programa
ADDS rD,r2,r0 ; lleva el puntero al registro de dirección
LD r3,[00] ; cargar el elemento del arreglo en r3
------------------------ ; operar con el elemento
ADDS r2,r2,r1 ; incrementa el puntero del arreglo
LLI rD, LO(SIGUE) ; salta a la instrucción SIGUE
LHI rD,HI(SIGUE)
BR ; salto incondicional
FIN: HALT
21
H07 H08 H09 H0A H0B H0C H0D H0E H0F H10
rAH07
rBH10

22. TABLAS (ARREGLOS) EN CODE2:
Ejemplo: Duplicar el valor de cada elemento de un arreglo lineal.
ORG H'001A
LLI r0,00
LLI r1,01
ADDS r2,rA,r0 ; valor inicial del puntero
CONTINUA: LLI rD, LO(FIN) ; dirección del final del programa
LHI rD,HI(FIN)
SUBS rF,rB,r2 ; ver si el puntero sobrepasa la dirección de final
BS ; si sobrepasa el final del arreglo, salta al final del programa
ADDS rD,r2,r0 ; lleva el puntero al registro de dirección
LD r3,[00] ; cargar el elemento del arreglo en r3
OUT 01,r3 ;
ADDS r3,r3,r3 ; multiplica por 2
OUT 02,r3
ADDS r2,r2,r1 ; incrementa el puntero del arreglo
LLI rD, LO(CONTINUA) ; salta a la instrucción CONTINUA
LHI rD,HI(CONTINUA)
BR ; salto incondicional
FIN: HALT
END
22
0007 0001 0020 0004 0008 0009 0003
000A 000B 000C 000D 000E 000F 0010
Arreglo lineal
original
000E 0002 0040 0008 0010 0012 0006
000A 000B 000C 000D 000E 000F 0010
Arreglo lineal
final

23. PIRÁMIDE DE CONSTRUCCIÓN DE PROGRAMAS
23

24. EJERCICIOS
1. De la posición PINI=H’1000 a la posición PFIN = H’1002 de la memoria de
CODE2 se encuentran tres datos. Hacer un programa que proporcione por el
puerto de salida 2 (OP2) el valor mayor de los datos y por el puerto de salida 1
(OP1) la dirección donde se encuentra.
2. Idem para el menor
3. Con los mismos tres datos del ejercicio 1, realizar una salida con los tres datos
ordenados de menor a mayor en las direcciones H´2000 al H´2002.
4. Programar la serie de Fibonacci. Se debe detener la serie cuando la cantidad
de términos llegue a un valor ingresado en una palabra de memoria. P.e.:
En decimal: 0 1 1 2 3 5 8 13 21 34
En hexadecimal: 00 0 1 01 02 03 05 08 0D 15 22
En este caso se deben generaron 10 términos de la serie y mostrarlos en el puerto
OP2.
24