ETS

ICCP

Fundamentos de Informática
Grado en Ingeniería Electrónica Industrial

PRÁCTICA 3: FUNCIONAMIENTO A BAJO NIVEL DE UN ORDENADOR: CODE-2

Objetivos
I. Comprender la utilidad de un programa ensamblador.
II. Familiarizarse con el entorno de programación de CODE-2.
III. Ser capaz de escribir un programa de CODE-2 y depurarlo.

Contenido
1. Introducción ................................................................................................................................................................. 2
2. El panel frontal de CODE-2 ..................................................................................................................................... 2
3. El entorno integrado de CODE-2 (simulador, editor y ensamblador) .................................................. 3
4. Ejemplos de uso del simulador ............................................................................................................................. 4
5. Actividades a realizar ............................................................................................................................................... 7
6. Otras actividades recomendadas ......................................................................................................................... 8
7. Referencias.................................................................................................................................................................... 9
Fundamentos de Informática Página 2

1. Introducción

CODE-2 es una máquina de tipo von Neumann que contiene todas las unidades típicas de este
modelo: entradas, salidas, unidad de control, unidad de procesamiento y memoria de datos e
instrucciones. CODE-2 es de 16 bits de longitud de palabra y tiene tan sólo 16 instrucciones máquina.
A través del lenguaje máquina de CODE-2 tenemos acceso a los siguientes elementos:
• Banco de registros: compuesto por 16 registros (r0 .. rF). Todos son de propósito general,
aunque el registro rE se suele utilizar como puntero de pila y rD como registro de dirección.
• Unidad aritmético-lógica (ALU): podremos hacer sumas y restas en complemento a 2, la
operación NAND y desplazamientos.
• Biestables indicadores: cero (Z), signo (S), acarreo (C) y desbordamiento (V), según la
operación realizada en la ALU.
• Memoria principal: compuesta por 64Kpalabras de 16 bits (128KB).
• Puertos de entrada: se pueden usar hasta 256 puertos de entrada (desde el IP00 a IPFF).
• Puertos de salida: se pueden usar hasta 256 puertos de salida (desde el OP00 a OPFF).

El repertorio de instrucciones completo se encuentra en la lección 3.4, en el capítulo 8 del libro de

referencia [1] y en el capítulo 4 del libro de problemas [2]. En dicho material se pueden encontrar
diversos trucos de programación y ejemplos de programas.

2. El panel frontal de CODE-2

La figura anterior muestra el panel frontal de CODE-2, en el que podemos ver los botones de
encendido y ejecución paso a paso, el teclado hexadecimal con el puerto de entrada IP1 conectado a
éste, los dos puertos de salida OP1 y OP2, el registro de instrucción IR, el contador de programa PC,
los biestables de la ALU y las teclas/botones de control.

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2

Fundamentos de Informática Página 3

3. El entorno integrado de CODE-2 (simulador, editor y ensamblador)

El entorno integrado que nos facilitará el manejo de CODE-2 se puede encontrar en el fichero
CODE2.zip en SWAD.

La figura muestra la pantalla completa del entorno integrado de CODE-2 (entorno_code2.exe),

cuando está seleccionada la pestaña Simulador. Como se puede ver, el módulo superior derecho
coincide con el panel frontal de CODE-2. El simulador permite la visualización de cualquier registro,
puerto de E/S y contenido de memoria de forma mucho más sencilla que a través del panel frontal.
Adicionalmente, esta aplicación admite que los programas escritos para CODE-2 sean cargados
directamente a partir de un fichero “.EHC” ó “.HEX” evitando que el usuario tenga que teclear
directamente cada instrucción.

También se puede ejecutar dicho entorno integrado desde Linux a través de Wine
(http://www.winehq.org/), aplicación de código abierto que implementa el API de Windows sobre
entornos X, OpenGL y Linux. Para ello tecleamos: wine entorno_code2.exe

Primeras pruebas con el panel frontal:

• Seleccionar una posición de memoria: tecleamos la dirección cuyo contenido queremos
ver y pulsamos la tecla DIRECCIÓN. En OP1 aparece la dirección tecleada y en OP2 su

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2

Fundamentos de Informática Página 4

contenido. Si ahora pulsamos CONTINUAR, iremos viendo las siguientes posiciones de

memoria.
• Cargar una información en una posición de memoria: tras seleccionar una posición de
memoria, podemos introducir una información por el teclado y pulsar CARGAR para
guardar en esa posición de memoria esa información. Automáticamente se incrementa la
posición de memoria, de forma que se puede cargar un programa o tabla de datos sin más
que ir introduciendo el dato y pulsando en CARGAR.
• Seleccionar los registros: pulsando en REGISTROS aparece en OP1 el código del registro 0,
y en OP2 el contenido. Pulsando a continuación en CONTINUAR podemos ver el resto de
registros.
• Cargar un valor en un registro: una vez que hemos seleccionado un registro, introducimos
el valor por el teclado y pulsamos CARGAR. Se memoriza dicho valor en el registro y se
pasa a visualizar el siguiente registro.
• Ejecutar un programa: introducimos por el teclado la dirección de comienzo del programa
y pulsamos EJECUTAR. En el caso de estar en modo Paso a Paso, una vez ejecutada la
primera instrucción del programa, se irán ejecutando las siguientes instrucciones del
mismo cada vez que pulsemos CONTINUAR.

4. Ejemplo de uso del simulador

Vamos a hacer paso a paso el siguiente ejemplo:

Escriba un programa para CODE-2 que se cargue a partir de la dirección H’000A de memoria cuyo
cometido sea sumar el contenido de las posiciones H’0000 y H’0001 de memoria y almacenar el
resultado en la posición de memoria H’0002, es decir,
M[H’0002] ← M[H’0000]+M[H’0001].
Asimismo, el resultado deberá visualizarse por el puerto de salida OP2.

Ejemplo:
Si M[H’0000] = H’0B59 y M[H’0001] = H’0004, tras la ejecución del programa M[H’0002] debe contener el
valor H’0B5D (ya que H’0B59 + H’0004 = H’0B5D)

A) Primer paso: Escritura del programa en lenguaje ensamblador.

El entorno integrado de CODE-2 incluye un Editor de textos donde podemos escribir, ensamblar y
depurar los errores tipográficos de nuestro programa. Para ello, seleccionamos la pestaña Editor y
escribimos nuestro programa en lenguaje ensamblador de CODE-2. Aparte de las instrucciones
propias del lenguaje ensamblador de CODE-2, el programa ensamblador ensam.exe (que es el
ejecutable al que llama el entorno integrado cuando pulsamos el botón Ensamblar del menú del
Editor) incorpora dos directivas especiales:
• ORG Dirección: le indica al ensamblador a partir de qué dirección de memoria se van a
escribir las instrucciones que se especifican a continuación de dicha directiva, y
• END: especifica el final del programa.
Además, el programa ensam.exe admite que se añadan comentarios en el propio programa
utilizando el carácter “;”. Nada de lo que se escriba en una línea tras el “;” será tenido en cuenta por
el programa ensamblador.

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2

Fundamentos de Informática Página 5

Para este ejemplo, el programa que debemos escribir debería quedar aproximadamente como se
muestra en la siguiente figura, suponiendo que hemos guardado nuestro programa con el nombre
prueba1.asm.

B) Segundo paso: Ensamblado del programa.

El cometido del programa ensamblador (ensam.exe) es traducir un programa escrito en lenguaje
ensamblador de CODE-2 a lenguaje máquina de CODE-2. El entorno integrado de CODE-2 busca el
fichero ensam.exe en el mismo directorio donde se encuentra el propio entorno integrado. Si se da
esta condición, para ensamblar nuestro programa de ejemplo bastará seleccionar el botón Ensamblar
de la barra de botones del propio editor.
Si no hay errores, nos aparecerá un mensaje indicándonos que el fichero en código máquina de
CODE-2 (en nuestro caso de ejemplo prueba1.ehc) ha sido generado. En el caso de haber errores,
aparecerá una sub-ventana debajo de nuestro programa enumerando los distintos errores
encontrados. Haciendo doble clic en cada mensaje de error, el programa nos posiciona en la línea del
programa ensamblador que ha generado dicho error.

Los errores más frecuentes que nos podemos encontrar son:

Tipográficos:
ADS r2,r0,r1 en lugar de ADDS r2,r0,r1
CALL en lugar de CALLR
Sintácticos:
OUT r4,H’01 en lugar de OUT H’01,r4
LD [rD+H’01],r2 en lugar de LD r2,[rD+H’01]

Y, sobretodo, no se debe olvidar que conviene siempre especificar al menos una sentencia ORG para
indicar al ensamblador a partir de qué dirección de memoria vamos a cargar el programa y recordar
que todos los programas deben acabar con la directiva END. Por defecto, si no se especifica ninguna
sentencia ORG se comienza a partir de la dirección H’0000 de memoria.

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2

Fundamentos de Informática Página 6

Como ya se ha indicado, si el proceso de ensamblado se realiza con éxito, se habrá generado un

fichero con el mismo nombre pero con extensión “.ehc” (y su equivalente con extensión .hex) que
contiene el conjunto de instrucciones en lenguaje máquina. En nuestro caso, el fichero sería
prueba1.ehc.

C) Tercer paso: Simulación del programa.

Para poder simular el programa que hemos escrito, seleccionamos la pestaña Simulador del entorno
integrado de CODE-2 (que es la que aparece por defecto al ejecutar el programa por primera vez).
Una vez hecho esto, para simular nuestro programa debemos:
a) Encender CODE-2: Botón On/Off del panel frontal.
b) Cargar el programa: Menú Archivo → Cargar programa objeto, y seleccionamos como
fichero de entrada u:\prueba1.ehc.
c) Introducimos la dirección de inicio por el teclado de CODE-2 (a través del panel frontal) y
pulsamos Ejecutar. Con esto, ya habremos ejecutado la primera instrucción del programa.
El aspecto en este punto de la simulación es el que se indica en la figura de la página 5.
d) Si nos encontramos en Modo Paso a Paso (que por defecto está activado), se ejecutarán
las siguientes instrucciones del programa cada vez que pulsemos el botón Continuar.

Ejemplo de uso de etiquetas en el lenguaje ensamblador de CODE-2

Para facilitar el uso de saltos (condicionales o no) en un programa de CODE-2, el programa
ensamblador permite el uso de etiquetas. Para definir una etiqueta basta escribir al principio de una
línea el nombre que le queramos poner a dicha etiqueta y acabar dicho nombre con el carácter “:”.
Cuando queramos realizar un salto a la instrucción inmediatamente posterior a la localización de
dicha etiqueta, tendremos que cargar en RD la dirección de dicho salto. Con el uso de etiquetas,
bastará escribir las instrucciones:
LLI RD, lo(nombre_etiqueta)
LHI RD, hi(nombre_etiqueta)
y el programa ensamblador reemplazará durante el proceso de ensamblado “lo(nombre_etiqueta)”
por los 8 bits menos significativos de la dirección de salto y “hi(nombre_etiqueta)” por los 8 bits más
significativos. Gracias a las directivas “lo” y “hi”, la persona que escribe el programa no tiene que
estar recalculando las direcciones de salto cada vez que se inserte una nueva instrucción en el código.
A modo de ejemplo, los dos programas siguientes producen exactamente el mismo código CODE-2
cuando se ensamblan:

;Usando etiquetas ; Sin usar etiquetas

ORG H'0100 ORG H'0100

LLI r1,H'01 LLI r1,H'01

LLI r3,H'F7 LLI r3,H'F7
LHI r3,H'24 LHI r3,H'24
salto: OUT OP1,r3
OUT OP1,r3 ADDS r3,r3,r1
ADDS r3,r3,r1 LLI rD,H'03
LLI rD,lo(salto) LHI rD,H'01
LHI rD,hi(salto) BR
BR
END
END

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2

Fundamentos de Informática Página 7

Ejemplo de uso de la directiva DATA para la introducción de datos en un programa

Normalmente, un programa en CODE-2 actúa sobre ciertos datos guardados en la memoria principal
del computador. Con la directiva DATA del lenguaje ensamblador podemos inicializar dichas
posiciones de la memoria principal con los valores que queramos. De este modo, cuando carguemos
un fichero en el simulador de CODE-2, además de cargar nuestro programa en una determinada zona
de la memoria de CODE-2, también podemos inicializar la zona donde están los datos sobre los que
vamos a actuar. A modo de ejemplo, el siguiente programa de CODE-2 es idéntico al que usamos en
el ejemplo de esta práctica (el de la suma del contenido de las dos primeras posiciones de la
memoria), salvo que además inicializamos las posiciones de memoria M(H’0000) y M(H’0001) con los
valores H’0B59 y H’0004, respectivamente. De esta forma, al ejecutar el programa ya sabemos que si
ha funcionado bien, la posición de memoria H’0002 debería valer H’0B5D (H’0B59 + H’0004 =
H’0B5D), y no tenemos que añadir nosotros manualmente los datos cada vez que carguemos el
programa.

Ejercicio : Algunas cuestiones sobre el programa del ejemplo anterior

Realice las siguientes cuestiones en referencia al programa prueba1.asm:
a) ¿Qué instrucciones de las que se emplean en dicho programa pueden modificar los valores de
los indicadores de estado? Cambiar los valores almacenados en las posiciones de memoria
H’0000 y H’0001 por H’F000 y H’50BD, respectivamente, y ejecutar el programa. ¿Cuál es el
valor del indicador C después de ejecutar la instrucción ADDS R2, R0, R1? ¿Y después de que
finalice la ejecución del programa?
b) ¿Cómo cambiaría el programa para que se sumasen los contenidos de las posiciones de
memoria H'0005 y H'0006, y que el resultado se almacenase en la posición de memoria
H'0007?¿Tendría sentido que modificásemos el programa para que el resultado de la suma se
almacenase en la dirección H'000A?

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2

 Fundamentos de Informática Página 8

5. Actividades a realizar

1. Considere el siguiente programa en ensamblador para

CODE-2. Suponga que dicho programa se está ejecutando
ORG H'0000
en el entorno de simulación, y responda las siguientes LLI R0, H'00
cuestiones: LLI R1, H'01
LLI R4, H'00
a) Se desea que en los registros R2 y R3 se carguen los LLI RD, H'25
valores H’0010 y H’0003, respectivamente, al LHI RD, H'01
ejecutarse las instrucciones de carga LD en el LD R2, [RD+H'00]
LD R3, [RD+H'01]
programa. En ese caso, ¿qué posiciones de memoria BUCLE: SUBS R2, R2, R3
habría que inicializar con dichos valores? LLI RD, lo(FIN)
LHI RD, hi(FIN)
b)¿Cuál sería el valor de los registros R2 y R4 después de BC
ejecutar la instrucción HALT con los valores referidos ADDS R4,R4,R1
LLI RD, lo(BUCLE)
en el apartado anterior? LHI RD, hi(BUCLE)
c) En ese mismo momento, ¿cuál sería el valor de los BR
indicadores de la ALU? ¿Por qué? FIN: ADDS R2,R2,R3
HALT
END

2. Tenemos en memoria un conjunto con H’0F datos (una tabla). El primer dato (inicio de la tabla) se
encuentra en la posición H’00C0. Hacer un programa que vaya leyendo los datos de la tabla y
cuente cuántos números positivos, negativos y ceros hay en el conjunto. Cuando llegue al final,
debe mostrar por OP1, primero cuántos números negativos había, a continuación cuántos ceros, y
por último cuántos positivos había. Cargar el programa a partir de la posición H’0010.

6. Otras actividades recomendadas

En este apartado se propone, con carácter opcional, practicar diversos aspectos en relación con los
lenguajes máquina y ensamblador de Code-2, mediante diferentes ejemplos y ejercicios resueltos
que se presentan en el material docente de la asignatura:

1. Realizar un programa en CODE-2 que sume uno a uno los elementos de dos tablas (vectores),
T1 y T2, y deje los resultados en otra tabla T3, es decir: T3(i) = T1(i) + T2(i); i= 0, 1, …., 31.
Suponer que: T1 comienza en d1=0040, T2 en d2=0080, y T3 en d3=00C0. La longitud de las
tablas es de 32 elementos, nT=H’20. (Resuelto en lección L3.5).

2. A partir de la posición A730 de la memoria de CODE-2 se tiene un texto (cadena de

caracteres) Unicode, que finaliza con el carácter de control ETX (fin de texto). Hacer un
programa que sustituya los caracteres punto y coma (;) por coma (,) y proporcione por el
puerto de salida OP2 el número de sustituciones que se efectúen. (Resuelto en lección L3.7).

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2

Fundamentos de Informática Página 9

7. Referencias

[1] A. Prieto, A.Lloris, J.C.Torres, Introducción a la Informática, 4ª Ed., McGraw-Hill, 2006.

[2] A. Prieto, B. Prieto, Conceptos de Informática, Problemas, Serie Schaum, McGraw-Hill, 2005

Práctica 3: Funcionamiento a Bajo Nivel de un Ordenador: CODE-2