5.8 Interrupciones

El procesador admite interrupciones por hardware y por software, que pueden ser emitidas por el PIC o por la instrucción INT respectivamente. Para ejecutar interrupciones por hardware, el procesador debe estar habilitado para recibir interrupciones. Esto es, IF=1 (la flag de interrupciones activada).

Ambas interrupciones deben propocionar un número de interrupción. En el caso de las interrupciones por software, esta es dada por el operando de la instrucción INT. En el caso de las interrupciones por hardware, esta es dada por el PIC. El número de interrupción debe ser un número entre 0 y 7.

Una vez interrumpido, el procesador ejecutará la rutina de interrupción asociada a ese número de interrupción. La dirección de comienzo de esta rutina estará almacenada en el vector de interrupciones. Este vector ocupa las celdas 00h hasta 07h de la memoria principal, y cada elemento del vector tiene 1 byte de largo – el primer elemento se encuentra en 0h, el segundo en 1h, el tercero en 2h, y así. Cada elemento corresponde con la dirección de inicio de la rutina de interrupción.

Específicamente, el procesador:

1. obtiene el número de la interrupción (0-7),
2. apila el registro FLAGS,
3. inhabilita las interrupciones IF=0,
4. apila el registro IP,
5. obtiene la dirección de la rutina de interrupción del vector de interrupciones,
6. modifica el IP para que apunte a la dirección de la rutina de interrupción.

Y así se comienza a ejecutar la rutina de interrupción. Estas tienen el mismo formato que una subrutina salvo que terminan en IRET en vez de RET.

5.8.1 Llamadas al sistema

El simulador permite realizar llamadas al sistema o syscalls. En el simulador, estas llamadas son realizadas idénticamente a las interrupciones. Así, para realizar una syscall basta con interrumpir a la CPU con el número de interrupción correspondiente. Estos números son:

• INT 0: termina la ejecución del programa, equivalente a la instrucción HLT;
• INT 6: lee un carácter del teclado;
• INT 7: escribe una cadena de caracteres en pantalla.

Las direcciones del vector de interrupciones asociadas a estos números están protegidas por el sistema, impidiendo que el usuario las modifique.

El contenido de estas rutinas se encuentran almacenadas en el monitor del sistemaen las direcciones A0h, B0h y C0h respectivamente.

La Figura 5.16 presenta una visión esquemática de la arquitectura general del simulador. En ella se distinguen los flujos de datos y de control, representando gráficamente la interacción entre los distintos módulos funcionales durante la ejecución de programas. Dicha representación facilita la comprensión estructural del sistema y su analogía con una arquitectura computacional real, simplificada para fines educativos.

Figura 5.16: Arquitectura general del simulador

La memoria principal se modela como una matriz de 16×16 expresada en hexadecimal, lo que permite almacenar hasta 256 bytes de datos. Esta capacidad es suficiente para la mayoría de los programas de ejemplo utilizados en el curso, y su diseño simplificado facilita la comprensión de los conceptos fundamentales de la memoria en una computadora.

Figura 5.17: Memoria principal

El bus de datos, direcciones y control se implementa como un conjunto de líneas que permiten la comunicación entre los distintos componentes del sistema. Este bus es esencial para el intercambio de información entre la CPU, la memoria y los dispositivos de entrada/salida, y su diseño modular permite una fácil expansión en futuras versiones del simulador.

Figura 5.18: Buses

Dentro de los buses interno de la CPU se incluyen circulos que representan circuitos multiplexores, que son componentes clave en la selección de datos y direcciones durante el ciclo de instrucción. Estos multiplexores permiten dirigir las señales adecuadas a los registros y a la ALU (Unidad Aritmético Lógica), facilitando así el flujo de datos dentro del procesador. Un multiplexor (MUX) es un conmutador digital que conecta datos de una de n fuentes a la salida. Están dotados de entradas de control capaces de seleccionar una, y solo una, de las entradas de datos para permitir su transmisión desde la entrada seleccionada hacia dicha salida

El simulador incluye la representación de un teclado y una pantalla con el objetivo de emular la interacción básica entre el usuario y el sistema. El teclado se modela como un vector de 16 posiciones, cada una capaz de almacenar un carácter ASCII. La pantalla, por su parte, se representa como una matriz de 16×16 que permite visualizar caracteres, facilitando así la comprensión del manejo de entrada y salida de datos en una arquitectura computacional simplificada.

Figura 5.19: Teclado y pantalla

La elección de estos bloques funcionales responde tanto a la necesidad de modelar componentes esenciales de una computadora real como a criterios pedagógicos de modularidad y claridad conceptual. La Tabla 5.3 resume los principales bloques que conforman la arquitectura simulada, junto con una breve descripción de su funcionalidad.

Tabla 5.3: Bloques funcionales principales

Bloque Funcional	Descripción
Unidad Central de Procesamiento (CPU)	Simulación de registros, unidad de control (UC) y unidad aritmético-lógica (ALU).
Memoria	Estructura de memoria y simulación de operaciones de lectura y escritura.
Sistema de Entrada/Salida (E/S)	Interacción con periféricos y manejo de interrupciones.
Bus de datos, direcciones y control	Modelado de la comunicación entre componentes.

5.8.2 Repertorio de instruciones

El repertorio de instrucciones se diseñó como una abstracción deliberada inspirada en la arquitectura x86, con el objetivo de optimizar los procesos de enseñanza y aprendizaje en entornos educativos. En una etapa inicial del proceso de enseñanza, se incluyen únicamente aquellas instrucciones esenciales que permiten introducir progresivamente los contenidos básicos de la asignatura Arquitectura de Computadoras. Este enfoque progresivo permite introducir los conceptos fundamentales de manera accesible, minimizando la complejidad innecesaria que podría obstaculizar la comprensión en las etapas iniciales del aprendizaje (John L. Hennessy and Patterson 2017a; Tanenbaum 2016). La Tabla 5.4 muestra un conjunto reducido de instrucciones que abarca las operaciones más frecuentes y pertinentes para una etapa introductoria de aprendizaje. Este repertorio se centra en las instrucciones de transferencia y procesamiento de datos, así como en las instrucciones de control de flujo, permitiendo al estudiante familiarizarse con los conceptos básicos de la arquitectura x86 sin la complejidad adicional de un repertorio completo.

Las instrucciones del simulador VonSim8 se dividen en dos categorías principales: las instrucciones de transferencia y procesamiento de datos, y las instrucciones de control de flujo. Las primeras permiten mover datos entre registros y memoria, realizar operaciones aritméticas y lógicas, y manipular el contenido de los registros. Las segundas permiten alterar el flujo de ejecución del programa mediante saltos condicionales e incondicionales, así como la detención del procesador.

Para facilitar el aprendizaje de la programación en ensamblador e introducir el ciclo de instruccion se propone el siguente repertorio de instrucciones, luego cuando se avance sobre los modulos de entrada y salida de acuerdo al programa de estudio de la asignatura Arquitectura de Computadoras (Facultad de Ciencias de la Administración, UNER 2025).

Tabla 5.4: Tabla de instrucciones de VonSim8

Instrucciones	nemónico	Acción
Transferencia de datos	MOV	Copiar
Procesamiento de datos	ADD	Sumar
	SUB	Restar
	CMP	Comparar
Control de flujo	JMP	Salto incondicional
	Jxx	Salto condicional si xx=1
	HLT	Detiene CPU

El parámetro xx en las instrucciones Jxx representa una combinación de los flags de estado. La negación de un flag se indica con la letra N.

Instrucción	Acción
JZ Dirección	Salta a Dirección si Z = 1
JNZ Dirección	Salta a Dirección si Z = 0
JC Dirección	Salta a Dirección si C = 1
JNC Dirección	Salta a Dirección si C = 0
JS Dirección	Salta a Dirección si S = 1
JNS Dirección	Salta a Dirección si S = 0
JO Dirección	Salta a Dirección si O = 1
JNO Dirección	Salta a Dirección si O = 0

En base a las entrevistas con los docentes y el análisis de los contenidos del curso, a continuación se establece para cada categorías de instrucciones su uso pedagógico esperado:

• Transferencia y procesamiento de datos: Instrucciones que permiten mover datos entre registros y memoria y realizar operaciones aritméticas. Estas instrucciones son fundamentales para la comprensión del flujo de datos en una arquitectura computacional mostrando como se llevan a cabo operaciones aritméticas como de lenguaje de alto nivel como Python:

x=2
y=3
z=0
z = x + y

Su traduccion a ensamblador sería:

```assembly
x db 2
y db 3
z db 0
mov AL, x   ;Se carga el valor de x (2) en AL
add AL, y   ;Se suma el valor de y (3) a AL (2) = 5
mov z, AL   ;Se guarda el valor del registro AL (5) en z 
hlt
```

• Control de flujo: Instrucciones que permiten alterar el flujo de ejecución del programa mediante saltos condicionales e incondicionales, así como la detención del procesador. Estas instrucciones son esenciales para comprender cómo se controlan las decisiones y el flujo de ejecución en un programa. Por ejemplo, permiten implementar estructuras condicionales similares a las de lenguajes de alto nivel como Python:

x=2
y=3
z=0
if x == y:
  z = y  + x

Su traduccion a ensamblador sería:

```assembly

x db 2 y db 3 z db 0 mov AL, x cmp AL, y jz EsIgual jmp Fin EsIgual: add AL, y mov z, AL Fin: hlt ```

x=2
y=3
z=0
if x < y:
  z = y  + x

Su traduccion a ensamblador sería:

```assembly

x db 2 y db 3 z db 0 mov AL, x cmp AL, y jc EsMenor jmp Fin EsMenor: add AL, y mov z, AL Fin: hlt ```

Por ejemplo, la estructura iterativa while en Python:

x = 0
suma = 0

while x < 10:
    suma = suma + x
    x = x + 1

Su traduccion a ensamblador sería:

```assembly

x db 1
suma db 0
Condicion: cmp x, 10 jc Bucle ; si x < 10 salta a etiqueta Bucle: jmp FinBucle ; si no salta a la etiqueta FinBucle: Bucle: mov BL, x add suma, BL add x, 1 jmp Condicion ; salta a Condicion: FinBucle: hlt ```

Tratamiento de vectores: El simulador permite trabajar con vectores y matrices, lo que facilita la comprensión de cómo se manejan estructuras de datos más complejas en una arquitectura computacional. Por ejemplo, el siguiente código en Python busca el máximo de un vector:

# Búsqueda del máximo en un vector
vector = [5, 2, 10, 4, 5, 0, 4, 8, 1, 9]
maximo = 0

for i in range(len(vector)):
    if vector[i] > maximo:
        maximo = vector[i]

Su traduccion a ensamblador sería:

```assembly

max db 0 vector db 5, 2, 10, 4, 5, 0, 4, 8, 1, 9 mov CL, 0 ; contador mov BL, offset vector ; obtiene la dirección del primer elemento del vector Condicion: cmp CL, 10 jc Bucle ; si x < 10 salta a etiqueta Bucle jmp FinBucle ; si no salta a la etiqueta FinBucle Bucle: mov AL, [BL] ; AL = vector[indice] cmp AL, max jc Proximo ; si AL < max, salta a Proximo mov max, AL ; si no, actualiza max Proximo: add BL, 1 ; BL = BL + 1 add CL, 1 ; CL = CL + 1
jmp Condicion FinBucle: hlt```

Estas instrucciones permiten a los estudiantes comprender cómo se ejecutan las operaciones aritméticas en la computadora, cómo se transfieren los datos entre registros y memoria, y cómo se controla el flujo de ejecución de un programa. Estas categorías de instrucciones se seleccionaron cuidadosamente para proporcionar una base sólida en los conceptos fundamentales de la arquitectura x86, permitiendo a los estudiantes familiarizarse con las operaciones más comunes y relevantes sin la complejidad adicional de un repertorio completo. Estas categorías se alinean con los objetivos pedagógicos del curso, permitiendo a los estudiantes familiarizarse con los conceptos básicos de la arquitectura x86 sin la complejidad adicional de un repertorio completo.

A traves de la implementación de estas instrucciones, el simulador VonSim8 busca proporcionar una experiencia de aprendizaje que facilite la comprensión de los principios fundamentales de la arquitectura de computadores, al tiempo que se minimiza la carga cognitiva en las etapas iniciales del aprendizaje. Permite al alumno entender como se ejecutan los operaciones artimeticas en la computadora, como se transfieren los datos entre registros y memoria, y como se controla el flujo de ejecución de un programa.

5.8.3 Formato de instrucciones

Las instrucciones del simulador VonSim8 se definen con un formato de 1 a 3 bytes, donde el primer byte contiene el código de operación (opcode) y los siguientes bytes pueden contener operandos adicionales según el modo de direccionamiento utilizado. El opcode determina la operación a realizar, mientras que los operandos especifican los datos o registros involucrados en la operación.

Tabla 5.5: Tabla de formato de instrucciones

Tipo	Operandos	Ejemplo
Transferencia y procesamiento	2	MOV operando-destino, operando-fuente
Control	1 / cero	JMP operando / HLT

5.8.4 Modos de direccionamiento

Los modos de direccionamiento definidos son:

• Registro a registro (Rx,Ry): operandos son registros del procesador y Rx indica registro destino y Ry indica registro fuente.

• Directo ([M]): un operando es un registro y el otro operando es el contenido de una dirección de memoria [M].

• Indirecto ([BL]): la dirección del operando se encuentra en el registro [BL].

• Inmediato (d): un operando es un valor contenido en la instrucción.

Estos modos de direccionamiento permiten al simulador representar una variedad de operaciones que abarcan desde la manipulación directa de registros hasta el acceso a memoria, proporcionando una base sólida para la comprensión del flujo de datos en una arquitectura computacional. La Tabla 5.6 resume los modos de direccionamiento implementados en el simulador, junto con ejemplos de uso y su propósito pedagógico.

Tabla 5.6: Tabla de modos de direccionamiento

Tipo	Operación	Parámetros
	A: Entre registros	Operandos son registros Rx, Ry
	B: Cargar a registro	Operando destino es registro Rx y el operando fuente puede ser: dirección [M] dirección registro [BL] valor en la instrucción d
Transferencia y procesamiento	C: Almacenar en memoria	Operando destino puede ser: dirección [M] dirección registro [BL]) y operando fuente puede ser: Registro: Ry valor en la instrucción d
Control	D: control de flujo	Si tiene operando es una dirección de memoria M (*)
Nota:
Las instrucciones de transferencia y procesamiento tienen los mismos modos de direccionamiento A, B y C.

Ejemplo de los modos de direccionamiento:

x db 2 
y db 3

; ejemplo modos direccionamiento
;----------------------
; carga en registro
;----------------------
; Directo
mov al, x

; Por registro
mov dl, al

; Inmediato
mov bl, 16

; Indirecto
mov cl, [bl] ; celda 16 = BL

;----------------------
; Almacenar en memoria
;----------------------
; Diecto
mov x, cl

; Indirecto
mov [bl], al

; Directo-Inmediato
mov x, 5

; Indirecto-Inmediato
mov [bl], 4

hlt

5.8.5 Codificación de instrucciones

El formato de las instrucciones se basa en la codificación binaria, donde cada instrucción se representa mediante un código de operación (opcode) seguido de los operandos. Las instrucciones del simulador VonSim8 se dividen en dos categorías principales: las instrucciones de transferencia y procesamiento de datos, y las instrucciones de control de flujo. Cada instrucción se codifica en un formato binario específico, que incluye un código de operación (opcode) y, en algunos casos, operandos adicionales. La Tabla 5.8 presenta una lista de las instrucciones implementadas en el simulador, junto con su acción correspondiente y su codificación binaria.

Tabla 5.7: Tabla de instrucciones y acciones

Tipo	Ejemplo	Acción
A: Entre registros	MOV Rx, Ry	Rx ← Ry
	ADD Rx, Ry	Rx ← Rx + Ry
	SUB Rx, Ry	Rx ← Rx - Ry
	CMP Rx, Ry	Rx - Ry *
B: Cargar a registro	MOV Rx, [M]	Rx ← Mem[Dirección]
	MOV Rx, [BL]	Rx ← Mem[BL]
	MOV Rx, d	Rx ← dato
	ADD Rx, [M]	Rx ← Rx + Mem[Dirección]
	ADD Rx, [BL]	Rx ← Rx + Mem[BL]
	ADD Rx, d	Rx ← Rx + dato
	SUB Rx, [M]	Rx ← Rx - Mem[Dirección]
	SUB Rx, [BL]	Rx ← Rx - Mem[BL]
	SUB Rx, d	Rx ← Rx - dato
	CMP Rx, [M]	Rx - Mem[Dirección] (*)
	CMP Rx, [BL]	Rx - Mem[BL] (*)
	CMP Rx, d	Rx - dato (*)
C: Almacenar en memoria	MOV [M], Ry	Mem[Dirección] ← Rx
	MOV [BL], Ry	Mem[BL] ← Rx
	MOV [M], d	Mem[Dirección] ← dato
	MOV [BL], d	Mem[BL] ← dato
	ADD [M], Ry	Mem[Dirección] ← Mem[Dirección] + Rx
	ADD [BL], Ry	Mem[BL] ← Mem[BL] + Rx
	ADD [M], d	Mem[Dirección] ← Mem[Dirección] + dato
	ADD [BL], d	Mem[BL] ← Mem[BL] + dato
	SUB [M], Ry	Mem[Dirección] ← Mem[Dirección] - Rx
	SUB [BL], Ry	Mem[BL] ← Mem[BL] - Rx
	SUB [M], d	Mem[Dirección] ← Mem[Dirección] - dato
	SUB [BL], d	Mem[BL] ← Mem[BL] - dato
	CMP [M], Ry	Mem[Dirección] - Rx
	CMP [BL], Ry	Mem[BL] - Rx
	CMP [M], d	Mem[Dirección] - dato
	CMP [BL], d	Mem[BL] - dato
D: control de flujo	JMP M	IP ← Dirección
	Jxx M	Si xx = 1 entonces IP ← Dirección
	HLT	Detiene el procesador
Nota *:
La instrucción CMP no almacena el resultado de la operación en el operando destino.

Tabla 5.8: Tabla de codificación de instrucciones

CodOp	Instrucción	Byte	Codificación
0	MOV Rx, Ry	1	0000 RxRy
1	MOV Rx, [M]	2	0001 Rx00 MMMMMMMM
1	MOV Rx, [BL]	1	0001 Rx01
1	MOV Rx, D	2	0001 Rx10 MMMMMMMM
2	MOV [M], Ry	2	0010 00Ry MMMMMMMM
2	MOV [BL], Ry	2	0010 01Ry
2	MOV [M], D	3	0010 1100 MMMMMMMM dddddddd
2	MOV [BL], D	2	0010 1101 MMMMMMMM
3	ADD Rx, Ry	1	0011 RxRy
4	ADD Rx, --	Carga en registro	0100 ---- --------
5	ADD [M], --	Almacenar en memoria	0101 ---- -------- --------
6	SUB Rx, Ry	1	0110 RxRy
7	SUB Rx, --	Carga en registro	0111 ---- --------
8	SUB [M], --	Almacenar en memoria	1000 ---- -------- --------
9	CMP Rx, Ry	1	1001 RxRy
A	CMP Rx, --	registro - memoria	1010 ---- --------
B	CMP [M], --	memoria - registro	1011 ---- -------- --------
C	JMP M	1	1100 0000 MMMMMMMM
C	Jxx M	1	1100 ffff MMMMMMMM
D	HLT	1	1101 0000

Considerando:

• ____: Código de operación de la instrucción, número de 4 bits.

• Rx o Ry: Índices de registros, número entre 0 y 3, cada índice es de 2 bits.

• 00: Junto con el código de operación indica si la operación es tipo B o C.

• M: Dirección de memoria, número de 8 bits.

• ffff: representan el comportamiento de la instrucción, número de 4 bits.

• d: Dato inmediato, número de 8 bits.

• MMMMMMMM: Dirección de memoria, número de 8 bits.

• dddddddd: Dato inmediato, número de 8 bits.

Tabla 5.9: Tabla de registros del simulador

Registros R	Binario	Decimal
AL	00	0
BL	01	1
CL	10	2
DL	11	3
Nota:
Los registros AL, BL, CL y DL corresponden a registros de propósito general de 8 bits.

El formato ampliado para las instrucciones incluye los siguientes casos tabla 5.10:

Tabla 5.10: Tabla de codificación de instrucciones ampliado

Tipo	Operación	Codificación	Parámetros
Transferencia y procesamiento	A: entre registros	____XXYY	XX = Registro destino, YY = Registro fuente
	B: Cargar a registro	____XX00 MMMMMMMM	XX00 = Registro destino y M = Dirección de memoria
		____XX01	XX01 = Registro destino y direccion en registro [BL]
		____XX00 dddddddd	XX10 = Registro destino y d = Dato inmediato
	C: Almacenar en memoria	____00YY MMMMMMMM dddddddd	YY = Registro fuente, M = Dirección de memoria, d = Dato Inmediato
Control	D: control de flujo	____ffff MMMMMMMM	ffff = funcionalidad, M = Dirección de memoria
Nota:
d = dato inmediato, no puede ser destino de la instrucción.

Bibliografía

Facultad de Ciencias de la Administración, UNER. 2025. “Programa de la asignatura Arquitectura de Computadoras.” Consejo Directivo, Facultad de Ciencias de la Administración, UNER; https://digesto.uner.edu.ar/documento.frame.php?cod=170316.

Hennessy, John L., and David A. Patterson. 2017a. Computer Architecture: A Quantitative Approach. 6th ed. Boston: Morgan Kaufmann.

Tanenbaum, Andrew S. 2016. Structured Computer Organization. Pearson Education India.