Capítulo 1

El microprocesador y la computadora

1.1 Introducción
La historia de los sistemas de computación, con µProcesadores Intel, comienza en 1971 con el Intel
4004, como se vé en la figura 1.1. Vea como fue mejorando la velocidad del reloj, el tamaño de los
registros, el aumento del set de instrucciones y su capacidad de direccionar posiciones de memoria.

Año µProcesador Registros Reloj IPS(*) Memoria

1971 4004 4 bits 100[KHz] 60K 16 KBytes
1972 8008 8 bits 740[KHz] 300K
1974 8080 8 bits 2[MHz] 640K 64 KBytes
1977 8085 8 bits
1978-1979 8086 16 bits 800K
1978-1979 8088 16 bits
1982 80286 16 bits de 6 a 25[MHz]
1982 80386 32 bits de 16 a 40[MHz]
1988 80386SX 32 bits de 12 a 40[MHz] 16 MBytes
1989 80486DX 32 bits de 16 a 100[MHz] 54M
1989 I486 32 bits de 16 a 100[MHz]
1993 Pentium 32 bits de 60 a 300[MHz] 100M
1995 Pentium Pro 32 bits de 133 a 200[MHz] 100M
1997 Pentium 2 32 bits de 233 a 450[MHz]
1998 Pentium 2 Xeon 32 bits de 233 a 450[MHz]
1999 Pentium III 32 bits 1[GHz]
2000 Pentium 4 32 bits de 1.3 a 4[GHz]
2003 Pentium M 32 bits 900[MHz] a 2.26[GHz]
2005 Pentium D 32 bits 2.66[GHz] a 3.73[GHz]
2006 Xeon dual core 64 bits 1.3[GHz] a 2.26[GHz]
2008 Intel Atom 64 bits 600[MHz] a 2.26[GHz]
2010 Intel Core I3 64 bits 3.4[GHz] a 4.2[GHz]
2010 Intel Core I5 64 bits 2.4[GHz] a 3.8[GHz]
2010 Intel Core I7 64 bits 2.9[GHz] a 4.2[GHz]
2011 Intel Core 2da generación 64 bits 1.3[GHz] a 4.5[GHz]

Figura 1.1: Historia de los µProcesadores Intel. (*)IPS = Instrucciones por segundo

Vale la pena resaltar algunas características especiales de cada µProcesador. Así el Intel 8085,
permitió simplificar el hardware necesario en las computadoras. El Intel 8086/8088 contaban con

1
1.1. INTRODUCCIÓN 2

cuatro registros, cada uno de los cuales, podía utilizarse como dos registros separados de 8 bits cada
uno. En 1981, con estos µProcesadores, IBM produjo computadoras IBM PC, dando lugar al
mercado de las computadoras compatibles IBM PC.

El Intel 80286 era compatible con el 8086 y el 8088. El Intel 80386, era compatible con los
anteriores µProcesadores y fue utilizado en las computadoras Compaq DeskPro 386. Con el
Intel 80386SX mejoró la aceptación del sistema operativo Windows, desarrollado por Microsoft.
Con el Intel 80486DX se implementó la memoria cache L1, en el mismo chip y con el I486 se
implementó la memoria cache L1 y unidad de coma flotante, todo en el mismo chip.

Los µProcesadores Pentium poseía una arquitectura capaz de ejecutar dos operaciones a la vez,
gracias a sus dos pipeline de datos, cada uno de 32 bits y con un bus de datos de 64 bits. En 1995
salio el Pentium Pro, que se aplicó mayormente para servidores.

A partir de 1997, Intel incluye en sus productos la tecnología MMX, que aparece el Pentium II,
este ejecutaba instrucciones de 16 bits y no contaba con memoria cache L2 en el mismo chip. La
memoria cache L1 era de 32 KBytes (16KB para datos y 16KB para instrucciones), la memoria
cache L2 se puso en una placa separada. El Pentium II Xeon utilizaba tanto el chipset 440GX
como el 450NX y el Pentium III incluye instrucciones SSE. El pentium 4 utilizó un diseño com-
pletamente nuevo.

El Pentium M se caracteriza por su bajo consumo energético y baja disipación de calor, útil para
computadoras portátiles. El Pentium D, que tiene básicamente dos Pentium 4 comunicados por
un bus FSB (2 núcleos Prescott para el core Smithfield y 2 núcleos Cedar Mill para el core Presler).
Posteriormente sale el Core 2 Duo. En 2005 Intel también proporcionó µProcesadores Core 2 Duo
a la empresa Apple Computer, quienes produjeron computadoras de escritorio y portátiles.

El Xeon dual core rendía 80% mas por vatio y era 60% mas rápido que cualquier µProcesador
de la competencia y ejecutaba instrucciones de 32 bits y de 64 bits. La marca core 3 abarcaba las
líneas SOLO (un núcleo), DUO (doble núcleo), QUAD (quad-core) y EXTREME (µProcesadores
de dos o cuatro núcleos). Por otro lado La marca Core 2 se refiere a una gama de µProcesadores
comerciales de Intel de 64 bits de doble núcleo y µProcesadores 2x2 MCM (módulo multi-chip)
de cuatro núcleos con el conjunto de instrucciones x86 – x64, basado en el Core Microarchitecture
de Intel, derivado del procesador portátil de doble núcleo de 32 bits. Posteriormente Intel saco
al mercado el Intel Atom, con tecnología CMOS y destinado a usarse en dispositivos móviles de
Internet, ultraportátiles, teléfonos inteligentes y otros de baja potencia. Ya en 2010 lanzó el Intel
Core I3, I5 e I7, todos de cuatro núcleos.

Core i3 está equipado con el acelerador Intel para medios gráficos de alta definición, un motor de
video de avanzada que ofrece una fluida reproducción y capacidades 3D de avanzada. Core i5 asigna
automáticamente la capacidad de proceso donde más se necesita, permitiendo al usuario crear videos
HD, componer música digital, editar fotos o jugar videojuegos. La familia Core 2010 de Intel posee
la tecnología Hyper Threading que permite que cada núcleo del procesador trabaje en dos tareas
al mismo tiempo. Por otro lado, Intel Core i5 e Intel Core i7 integran Turbo Boost, que incre-
menta de forma automática la velocidad de procesamiento de los núcleos por encima de la frecuencia
1.2. LOS REGISTROS DEL MICROPROCESADOR 3

operativa básica si no se han alcanzado los límites especificados de energía, corriente y temperatura.

En enero de 2011 Intel lanzó la segunda generación de la familia Core, tecnología que posee cam-
bios en la memoria caché, mejorías en el modo Turbo Boost y perfeccionamientos en la propia
arquitectura. Esta nueva familia tiene motor gráfico integrado para aumentar el desempeño de
procesamiento para video en alta definición, 3D, juegos, realización de múltiples tareas al mismo
tiempo y redes sociales o uso de multimedia en línea.

Además de las aplicaciones en computadoras domesticas o para las diferentes industrias, Los mi-
croprocesadores Intel también se han empleado en varias naves espaciales. El pequeño rover mar-
ciano Sojourner tenía un micro Intel 80C85 a 2 MHz y el telescopio espacial Hubble usa un
486 (80486), aunque antes empleaba un 386, un micro que también es usado en algunos ordenadores
principales de la ISS. La primera estación espacial estadounidense, Skylab, uso una computadora
IBM 4Pi en la versión de 16 bits, y a principios de los años 80 se incorporaron cinco computadoras
AP-101, una versión de 32 bits y 480[kHz] del 4Pi dotado de microprocesadores Intel 8086.

1.2 Los registros del microprocesador

Para los propósitos de este libro es necesario conocer los registros de trabajo de los µProcesadores
Intel; es decir, los registros que se utilizan para el desarrollo de software en sistemas de computación,
que utilizan µProcesadores Intel.

Registros de uso general Registros punteros Registros de 64 bits

← 64 bits → ← 64 bits → ← 64 bits →
RAX RSP R8
32 bits EAX 32 bits ESP R9
16 bits AX 16 bits SP
R10
AH AL RBP
R11
RBX 32 bits EBP
32 bits EBX 16 bits BP R12
16 bits BX RSI R13
BH BL 32 bits ESI R14
RCX 16 bits SI R15
32 bits ECX RDI
16 bits CX 32 bits EDI
CH CL 16 bits DI
RDX RIP
32 bits EDX 32 bits EIP
16 bits DX 16 bits IP
DH DL
EFLAGS
16 bits FLAGS

a) Registros de uso general b) Registros punteros c) Registros de 64 bits

Figura 1.2: Registros del µProcesador Intel

En la figura 1.2 se muestran los registros, que intervienen en el desarrollo de software, de la fa-
milia de µProcesadores Intel. Volviendo a referirnos a la historia de los µProcesadores Intel. Se ha
mantenido la compatibilidad hasta 1978, cuando salieron los µProcesadores 8086/8088. Es decir se
puede escribir, por ejemplo, la instrucción mov ah,10h cuando se programa con 8 bits, se puede escribir
mov bx,cx cuando se programa con 16 bits, se puede escribir mov edi, 100h cuando se programa con
32 bits y, finalmente se puede escribir mov rdi, C0000080h, cuando se programa con 64 bits. En otras
1.2. LOS REGISTROS DEL MICROPROCESADOR 4

palabras un programa que se escribió para el 8086 puede seguir ejecutándose en una computadora
con tecnología x64, Por eso decimos que se ha mantenido la compatibilidad.

Entonces los 16 registros de un µProcesador Intel de 64 bits pueden utilizarse para operaciones de
64 bits, de 32 bits, de 16 bits o de 8 bits. Conceptualmente la figura 1.2 se ha dividido en tres
partes. La figura 1.2a) muestra los registros de uso general. Con ellos se pueden realizar operaciones
aritméticas y lógicas, aunque cada uno de ellos tiene un uso específico, como veremos mas adelante.
La figura 1.2b) muestra los registros que se utilizan como punteros, estos permiten acceder a las
posiciones de memoria de varias maneras y la figura 1.2c) muestra los registros nuevos para Pen-
tium 4 cuando trabaja en modo de 64 bits.

15 8 0 15 8 0 15 8 0
AX SI CS
AH AL DI DS
BX SP ES
BH BL BP SS
CX
IP - - - - O D I T S Z - A - P - C
CH CL
DX
DH DL

a) Registros de uso general b) Registros puntero c) Registros de segmento y banderas

Figura 1.3: Registros del 8086/8088

En la figura 1.3 se muestra los registros de los µProcesadores Intel 8086/8088. Todos ellos de 16
bits. Vea en la figura 1.3a) que el µProcesador cuenta con cuatro registros de uso general, de 16
bits: AX (Acumulador), BX (Base), CX (Contador) y DX (Datos). Se dice que estos registros
son de uso general, porque participan en operaciones aritméticas y lógicas; sin embargo cada uno
de ellos tiene un uso especial, como veremos mas adelante. Además se cuenta con ocho registros
de uso general, de 8 bits: AH, AL (acumulador), BH, BL, CH, CL (contador), DH, DL. En
la figura 1.3b) se ven los registros puntero: SI (Source Index), DI (Destination Index), SP (Stack
pointer), BP (Base pointer) e IP (Instruction pointer). En la figura 1.3c) se ven los registros de
segmento: CS (Code segment), DS (Data segment), ES (Extra segment), SS (Stack segment) y el
registro de banderas (Flags register).

mov si ,0 mov si ,0 MemA MemB

mov di ,8 mov di ,8 + - - - - - - -+ + - - - - - - -+ - -+
mov cx ,8 mov dx ,8 0000 - >| 10 | 0008 - >| | |
F1 : mov al ,[ si ] F1 : mov bl ,[ si ] | 20 | | | |
mov [ di ] , al mov [ di ] , bl | 30 | | | |
inc si inc si | 40 | | | | > CX
inc di inc di | 50 | | | |
dec cx dec dx | 60 | | | |
cmp cx ,0 cmp dx ,0 | 70 | | | |
jne F1 jne F1 | 80 | | | |
ret ret + - - - - - - -+ + - - - - - - -+ - -+

a) AL para el proceso b) BL para el proceso c) Modelo del sistema

CX = contador DX = contador

Figura 1.4: Aplicación de los registros de uso general

1.2. LOS REGISTROS DEL MICROPROCESADOR 5

Empecemos explicando los registros de uso general. Como se dijo estos se utilizan para realizar
operaciones aritméticas y lógicas. En la figura 1.4c) se plantea un modelo para copiar datos desde
la MemA hasta la MemB. En la figura 1.4a), para el proceso de copia se utiliza el registro AL y
como contador se usa el registro CX; mientras que en la figura 1.4b), para el proceso de copia se
utiliza el registro BL y como contador se usa el registro DX. Entonces se puede concluir que no
importa qué registro de uso general se utiliza, el resultado siempre es el mismo. Como se ve este
programa puede utilizar como contador AX, BX, CX, DX, AH, AL, BH, BL, CH, CL, DH o DL y
los mismo para el proceso de copia se pueden utilizar AH, AL, BH, BL, CH, CL, DH o DL. Solo
debemos cuidar de no utilizar un registro para dos tareas en el mismo programa.

Por otro lado, varios de estos registros, tienen aplicaciones específicas. Empecemos con el acumu-
lador AX o AL, como se ve en la figura 1.5, cuando se quiere dividir 60/7 (un word entre un byte),
el dividendo tiene que estar en el acumulador, AX, el divisor puede estar en cualquier registro de
uso general y vea que el resultado está en el acumulador, AH = resto y AL = cociente.

Dividendo | Divisor 60 | 7 AX | BL AX | CL
+--------- +--- +--- +---
Resto Cociente 4 8 AH AL AH AL

mov ax ,3 Ch mov ax ,3 Ch ; Dividendo = AX

mov bl ,7 mov cl ,7 ; Divisor = un registro de 8 bits de uso general
div bl div cl ; Resto = AH = 4 , Cociente = AL = 8

Figura 1.5: Uso del acumulador en la división

Lo mismo pasa con la multiplicación, en la figura 1.6, el multiplicando tiene que estar en el acumu-
lador, AL, y el multiplicador puede estar en cualquier registro de uso general. El producto esta en
el acumulador, AX.

Multiplicando x Multiplicador = Producto 5 x 8 = 40

AL x BL = AX
AL x CL = AX

mov al ,5 mov al ,5 ; Multiplicando = AL

mov bl ,8 mov cl ,8 ; Multiplicador = un registro de 8 bits de uso general
mul bl mul cl ; Producto = AX = 28 h

Figura 1.6: Uso del acumulador en la multiplicación

Ahora veremos el registro de datos, DX. Cuando se hacen operaciones de multiplicación o división
de números grandes, se utiliza por defecto el registro DX. Como se en la figura 1.7, el multiplicando
esta en AX, el multiplicador en cualquier registro de 16 bits de uso general y el resultado está en
DX:AX. Por eso DX se denomina de datos.
1.2. LOS REGISTROS DEL MICROPROCESADOR 6

Multiplicando x Multiplicador = Producto 13973 x 28364 = 396330172

AX x BX = DX : AX
mov ax ,13973 ; Multiplicando = AX
mov bx ,28364 ; Multiplicador = un registro de 16 bits de uso general
mul bx ; Producto = DX : AX = 179 Fh :84 BCh

Figura 1.7: Uso del registro de datos en la multiplicación

Lo mismo pasa en la división de números grandes. En la figura 1.8 se ve la división de dos múmeros
grandes. El dividendo está en DX:AX y el divisor puede estar en cualquier registro de 16 bits de
uso general. El resultado está en DX:AX = Resto:Cociente

Dividendo | Divisor 396330172 | 13973 DX : AX | CX

+ - - -- - - - - +------- +-----
Resto Cociente 0 28364 DX AX

mov dx ,179 Fh ; Dividendo DX : AX

mov ax ,84 BCh ;
mov cx ,28364 ; Divisor = un registro de 16 bits de uso general
div cx ; Resultado = DX : AX = 0000 h :6 ECCh

Figura 1.8: Uso del registro de datos en la división

Tanto en la figura 1.7 como en la figura 1.8 se ve el uso obligatorio del acumulador AX y del registro
de datos DX.

El registro de datos DX y el acumulador AL también se utilizan en operaciones de entrada y salida.

EL primer programa lee un dato en el acumulador AL del puerto apuntado por el registro de datos
DX, que en este caso es el puerto 0378h. El segundo programa escribe el dato del acumulador AL
en el puerto apuntado por el registro de datos DX.

mov dx , 0378 h ; Se lee un dato en AL mov dx ,0378 h ; Se escribe el dato de AL

in al ; del puerto 0378 h mov al , dato ; en el puerto 0378 h
; DX apunta al puerto out dx , al

Figura 1.9: Uso del registro DX y del registro AL en Entrada/Salida

Ahora veamos el registro base, BX. Este se utiliza como puntero para acceder a direcciones de
memoria y leer o escribir en ellas. En la figura 1.10 se utiliza BX como registro base; es decir un
puntero que apunta a una dirección base, a partir de la cual se procesan los datos. Por ejemplo,
copiar los datos de la dirección DS:0000 a la dirección DS:0008, vea que la base dada por BX ¡No
se mueve! Para desplazarse entre los datos, se utiliza el puntero SI, pero también podría utilizarse
DI.
1.2. LOS REGISTROS DEL MICROPROCESADOR 7

mov bx ,0 MemA MemB

mov si ,0 + - - - - - - -+ + - - - - - - -+ - -+
mov cx ,8 0000 - >| 10 | 0008 - >| | |
F1 : mov al ,[ bx + si ] | 20 | | | |
mov [ bx + si +8] , al | 30 | | | |
inc si | 40 | | | | > CX
dec cx | 50 | | | |
cmp cx ,0 | 60 | | | |
jne F1 | 70 | | | |
ret | 80 | | | |
+ - - - - - - -+ + - - - - - - -+ - -+

a) Aplicación c) Modelo del sistema

Figura 1.10: Aplicación del registro base BX

Para terminar con los registros de uso general veamos el registro contador, CX. Para esto vamos a
aprovechar la figura 1.4, es decir queremos copiar ocho datos de la MemA a la MemB. En la figura
1.11 apuntamos con DI a la MemA y con SI a la MemB. El programa de la figura 1.11a) utiliza
el registro CX para contar la cantidad de datos a copiar, vea que CX puede ser reemplazado por
BX o por DX (un registro de uso general) y seguirá funcionando. Sin embargo, en la figura 1.11b)
estamos utilizando el registro CX como contador, esto se pone en evidencia porque la instrucción
loop funciona automáticamente con el registro CX. Se puede ver que el programa de la figura 1.11b)
es mas corto y mas rápido que el programa de la figura 1.11a).

mov di ,0 mov di ,0
mov si ,8 mov si ,8
mov cx ,8 mov cx ,8
F1 : mov al ,[ di ] F1 : mov al ,[ di ]
mov [ si ] , al mov [ si ] , al
inc si inc si
inc di inc di
dec cx loop F1
cmp cx ,0 ret
jne F1
ret

a) CX uso general b) CX contador

Figura 1.11: Aplicación del registro contador CX

Ahora expliquemos los registros puntero: SI, DI, SP, BP e IP. Vamos a partir con la figura 1.11.
En esta vea que los punteros SI y DI no los estamos utilizando como puntero fuente (Source Index)
y como puntero destino (Destination Index), respectivamente. Por eso los hemos intercambiado
intencionalmente.

Por el contrario, en la figura 1.12c), SI es Source Index y DI es Destination Index; además en

esta figura, CX es utilizado como registro contador. La instrucción rep mobsb de la figura 1.12
utiliza directamente CX como contador, SI como puntero fuente y DI como puntero DI. Compare los
programas de esta figura, evidentemente el correcto uso de los registros del µProcesador conducirá
a desarrollar sistemas de computación eficientes y eficaces (rápidos y cortos). Vea que el programa
de la figura 1.12d) es tan corto como el programa de la figura 1.12c); Sin embargo el más rápido es
1.2. LOS REGISTROS DEL MICROPROCESADOR 8

el de la figura 1.12d), este programa utiliza la instrucción rep movsw; es decir copia los datos de
dos en dos, mientras que el programa de la figura 1.12c) utiliza la instrucción rep mosb que copia
los datos uno a uno.

mov di ,0 mov si ,0 mov si ,0 mov si ,0

mov si ,8 mov si ,8 mov di ,8 mov di ,8
mov cx ,8 mov cx ,8 mov cx ,8 mov cx ,4
F1 : mov al ,[ di ] F1 : mov al ,[ si ] rep movsb rep movsw
mov [ si ] , al mov [ di ] , al ret ret
inc si inc si
inc di inc di SI -> + - - - - - -+ DI -> + - - - - - -+
dec cx loop F1 | MemB | | MemB |
cmp cx ,0 ret + - - - - - -+ + - - - - - -+
jne F1 <- CX -> <- CX ->
ret

a) b) c) d)

Figura 1.12: Aplicación del registro contador CX y los punteros SI y DI

Aquí haremos un paréntesis. Compare por favor, la figura 1.10 y las columnas c) y d) de la figura
1.12. En la primera se ve que los punteros SI y DI incrementan de arriba hacia abajo; mientras que
en la segunda los punteros SI y DI incrementan de izquierda a derecha. Hablaremos un poco mas
de esto cuando abordemos el tema de las banderas del µProcesador.
1.2. LOS REGISTROS DEL MICROPROCESADOR 9

pila segment stack

2 dw 100 dup (0) 1) ds ←sp+10
pila ends 2) ds ax ←sp+08
4 ; ---------------------------------------- 3) ds ax AX ←sp+06 ←bp+06
datos segment 4) ds ax AX BX ←sp+04 ←bp+04
6 a db 1 5) ds ax AX BX ip ←sp+02
b db 2 6) ds ax AX BX ip bp ←sp+00 ←bp+00
8 c db 0
datos ends 1) 2) 3) 4) 5) 6)
10 ; ----------------------------------------
codigo segment
12 program proc far
assume ss : pila , ds : datos , cs : codigo
14 push ds ; 1)
sub ax , ax
16 push ax ; 2)
mov ax , datos
18 mov ds , ax

20 mov al , a
push ax ; 3)
22 mov bl , b
push bx ; 4)
24 call sumar ; 5)
mov c , al
26 retf
program endp
28 ; ----------------------------------------
sumar proc
30 push bp ; 6)
mov ax , sp
32 mov bp , ax
mov ax ,[ bp +6]
34 mov bx ,[ bp +4]
add al , bl
36 pop bp
ret 2 ; Se descartan dos
38 ; operandos
sumar endp
40 ; ----------------------------------------
codigo ends
42 end program

a) ¿Como se usan BP y SP? b) Modelo para explicar SP y BP

Figura 1.13: Aplicación de los registros BP y SP

Ahora veamos los registros que nos permiten acceder a los datos de la pila (el stack), estos son el
SP y el BP. El registro SP accede a la pila secuencialmente y, el programador no tiene control
sobre el. Este registro accede a la pila cuando se utilizan instrucciones tales como push y pop,
call y ret, int e iret.

Por otro lado el registro BP permite acceder a la pila de forma aleatoria. Para entender el fun-
cionamiento de este registro proponemos el ejemplo de la figura 1.13. Se trata de sumar dos números
pasándolos a través de la pila.

En la figura 1.13a) se ve el programa. En el encabezamiento tenemos las instrucciones push ds y

push ax, que son los pasos 1) y 2) de la figura 1.13b). Luego se guardan dos datos en la pila, (mov
al,a) (push ax) y (mov bl,b) (push bx), los pasos 3) y 4). Luego se llama a la subrutina sumar,
1.2. LOS REGISTROS DEL MICROPROCESADOR 10

la instrucción call guarda IP en la pila, este es el paso 5). Finalmente para acceder aleatoriamente
a la pila, se guarda BP (push bp), este es el paso 6).

Fíjese que en la rutina sumar, para recuperar nuestros datos de la pila hacemos (mov ax,sp), luego
(mov bp,ax) ¡En este momento BP y SP apuntan a la misma dirección de la pila! Finalmente
recuperamos los datos: (mov ax,[bp+6]) y (mov bx,[bp+4]). La instrucción (ret) recupera IP
y, la instrucción (ret 2) recupera IP y descarta los dos datos guardados en la pila, AX y BX. La
instrucción (retf ) recupera la dirección de retorno al sistema operativo (DS:00).

Para terminar esta parte expliquemos los registros de segmento y las banderas. En la figura 1.14
se ve un modelo para explicar la memoria de la computadora, en ella se ve que la memoria esta
segmentada. El segmento de código (CS) es donde corren los programas, el segmento de
datos (DS) es donde se ponen los datos y las variables que manejaran los programas, el segmento
extra (ES) se puede utilizar como una extensión del segmento de datos o como una extensión del
segmento de código; finalmente, el segmento de pila (SS) se utiliza para guardar temporalmente
datos o direcciones de datos, variables o programas. Vea cómo los segmentos de la memoria de la
computadora se corresponden con los segmentos declarados en el programa de la figura 1.13a).

Memoria de la computadora
CS →
Segmento de Código (CS)
← IP
DS →
Segmento de Datos (DS)
← SI ← DI
ES →
Segmento de Extra (ES)
← SI ← DI

Segmento de de Pila (SS)

← SP ← BP
SS →

Figura 1.14: La memoria de la computadora esta segmentada

Antes de pasar a explicar las banderas, el estudiante debe estar seguro que las direcciones de las
instrucciones están dadas por CS:IP, las direcciones de los datos están dadas por DS:offset y las
direcciones de los datos en la pila están dados por SS:SP o SS:BP. El lector debe constatar que,
como los registros CS, DS, ES y SS, son de 16 bits, cada uno puede direcciónar 216 = 65.536. En
este contexto, El programa mas grande puede ser de 64KB, así como el segmento de datos mas
grande puede ser de 64KB.

El registro de banderas que se muestra en la figura 1.3c) permite controlar diversos aspectos del
µProcesador, a medida que van ocurriendo las cosas (paridad, acarreo, entre otras), también per-
miten cambiar el estado del µProcesador a requerimiento del programador (correr paso a paso,
1.2. LOS REGISTROS DEL MICROPROCESADOR 11

atender interrupciones, etc). En la figura 1.15 mostramos las banderas del µProcesador. Todos
estos “conceptos” los explicamos a continuación.

- - - - OF DF IF TF SF ZF - AF - PF - CF
↓ ↓ ↓
cld cli clc
std sti stc
cmc
Figura 1.15: Las banderas del µProcesador

Empecemos con las banderas OF y CF. En la figura 1.16 se exponen los conceptos de acarrero y
desbordamiento. Vea que cuando OF = 0 y CF = 0, entonces no importa que los operandos hayan
sido datos con signo o sin signo, el resultado estará bien; por el contrario, cuando OF = 1 y CF
= 1, sin importar si los operandos son datos con signo o sin signo, el resultado estará mal. En el
medio, cuando OF = 1, quiere decir que hubo un acarreo hacia el bit de signo y, portanto si se trata
de datos con signo, el resultado esta mal; el otro caso se da cuando CF = 1, entonces el resultado
de operaciones sin signo no es válido.

Sin signo Con signo OF CF

1111 1001 249 -7 0 0 El resultado en operaciones con signo

0000 0010 2 2 y sin signo es el mismo en binario
--------- --- -- y ambos estan bien
1111 1011 251 bien -5 bien

1111 1100 252 -4 0 1 El resultado en operaciones sin signo

0000 0101 5 5 no es valido debido al acarreo externo
--------- --- --
0000 0001 +1 1 bien

1 <- Acarreo hacia el bit de signo

0111 1011 123 123 1 0 Hay de sbordami ento cuando
0000 1011 11 11 1) Se tiene acarreo interno hacia el
--------- --- ---- bit de signo y no tiene acarreo
1000 0110 134 bien -124 hacia afuera.

1 <- Acarreo hacia afuera

1111 0110 246 - 10 1 1 2) Ocurre acarreo externo sin acarreo
1000 1001 137 -119 interno
--------- ---- ----
0111 1111 127 127

Figura 1.16: Banderas de acarrero CF y desbordamiento OF

La dificultad radica en que el acarreo para datos de 7 bits se da en el bit ocho y, este es bit de signo.
También se debe recordar que el desbordamiento ocurre cuando el resultado cabe en mas bits que
el tamaño de los datos. Por ejemplo, si se suma 00001010 = 10 y 10100000 = 160 el resultado entra
en 8 bits 10101010 = 170. Pero sumando 11111010 = 250 y 00001010 = 10, el resultado ya no entra
en ocho bits, se necesitan nueve bits (1 00000100) y, el µProcesador no tiene registros de nueve bits.
Entonces la responsabilidad del manejo de los datos es del desarrollador del sistema de computación.
1.2. LOS REGISTROS DEL MICROPROCESADOR 12

La bandera de dirección, DF, indica si el manejo de los datos es de izquierda a derecha, DF =

0 (cld), o si el manejo de los mismos es de derecha a izquierda, DF = 1 (std). La figura 1.17a)
muestra la aplicación de la instrucción clear direction flag, cld. En este ejemplo se incrementan
automáticamente los punteros SI y DI y se decrementa automáticamente el contador CX. En la
figura 1.17b) se muestra la aplicación de la instrucción set direction flag, std. En este ejemplo se
decrementan automáticamente los punteros SI, DI y el contador CX. En ambos casos, cuando CX
= 0, termina el programa. Observe que en la figura 1.17b) los punteros SI y DI apuntan al final de
las zonas de memoria MemA y MemB, respectivamente.

cld std
mov si ,0 mov si ,7
mov di ,8 mov di ,15
mov cx ,8 mov cx ,8
rep movsb rep movsb
ret ret

SI DI SI DI
| | | |
v v v v
+ - - - - - -+ + - - - - - -+ + - - - - - -+ + - - - - - -+
| MemA | | MemB | | MemA | | MemB |
+ - - - - - -+ + - - - - - -+ + - - - - - -+ + - - - - - -+
<- CX -> <- CX -> <- CX -> <- CX ->

a) se procesa de izquierda a derecha b) se procesa de derecha a izquierda

Figura 1.17: La bandera de dirección DF

La bandera de trap (paso a paso), permite ejecutar un programa paso a paso cuando, TF = 1, y
corre todo el programa cuando, TF = 0. Como el µProcesador no proporciona ninguna instrucción
para manipular la bandera TF, el usuario deberá desarrollar un pequeño programa para cambiar el
estado de esta bandera.

La bandera de signo, SF, indica si el resultado de una operación realizada es positivo (SF = 0) o
negativo (SF = 1). La bandera de cero, ZF, indica si el resultado de una operación realizada es
cero (ZF = 1) o no (ZF = 0). La bandera de paridad, PF, indica si el resultado de una operación
tiene numero impar de “unos” (PF = 0) o numero par de “unos” (PF = 1). Esta bandera no tiene
uso en la actualidad.

La bandera de acarreo auxiliar, AF, indica el acarreo que ocurre en el bit 3, hacia el bit 4 de una
operación
1 <- Acarreo auxiliar

D7 D6 D5 D4 D3 D2 D1 D0
1 0 1 0 1 0 1 0
0 0 0 0 1 0 0 1
-----------------------
1 0 1 1 0 0 1 1

Esta bandera se utiliza en operaciones ASCII y BCD. Como ejemplo vea la figura 1.18. La instruc-
ción aaa ve la bandera AF, SI AF = 1, entonces AL = AL + 6 y AH = AH + 1, además en AL
A7 A6 A5 A4 = 0000.
1.3. MEMORIA EN MODO TEXTO Y CÓDIGO ASCII 13

mov ax , 0009 h ; al = 9 , ah = 0 mov al , 64 h ; ax = 0064 h

mov bl , 7 ; bl = 7 mov bl , 73 h
add al , bl ; ax = 0010 h , AF = 1 add al , bl ; ax = 00 D7h
aaa ; ax = 0106 h , AF = 1 daa ; ax = 0037 h y CF = 1

a) Ajuste ASCII para suma b) Ajuste decimal para suma

Figura 1.18: Aplicación de la bandera de acarreo auxiliar, AF

Finalmente la bandera de interrupciones, IF, Si IF = 0 (cli) no se aceptan interrupciones, pero si AF

= 1 (sti) se aceptan interrupciones. Como veremos mas adelante el mundo de las interrupciones en
las computadoras con µProcesadores Intel es amplio. Por el momento solo diremos que la bandera
IF se refiere solo a las interrupciones enmascarables ¡Justamente IF actúa como una mascara!

1.3 Memoria en modo texto y código ASCII

Para el desarrollo de sistemas de computación planteamos el modelo de la figura 1.19. i) En
la capa 0 utilizamos circuitos integrados conbinacionales y secuenciales para satisfacer nuestras
necesidades. Por ejemplo un sumador, un reloj digital. ii) En la capa 1, además utilizamos chips
de memoria, por tanto podemos “programar” en hexadecimal. El programa es una secuencia de
códigos hexadecimales, vean que cambiando el programa, el mismo sistema podía satisfacer varias
necesidades. iii) En la capa 2 se programa utilizando nemonicos, aquí aparecen los µProcesadores
y permiten desarrollar sistemas muy flexibles, por ejemplo el juego de instrucciones del 8086/8088;
sin embargo, el usuario tenía que hacer todo el desarrollo (leer datos de un teclado, desplegar
información en un display, Etc.). iv) En la capa 3, los µProcesadores se utilizan para armar
sistemas de computación y aparecen los servicios de la BIOS (Basic Input Output System); la
BIOS permite facilitar las tareas de I/O y de despliegue de información, entre otras cosas. v) En la
capa 4, los µProcesadores son parte de sistemas de computación complejos que son administrados
por sistemas operativos, en este punto, los recursos con los que cuenta un sistema de computación,
pueden ser utilizados a través de las llamadas al Sistema Operativo. vi) Finalmente en la capa 5
además de todo lo mencionado se pueden desarrollar sistemas de computación utilizando lenguajes
de programación de alto nivel, tales como C/C++, Python, Etc.

Capa 5 Procedimientos, Funciones, Objetos Programación en lenguajes de alto nivel

Capa 4 Servicios del DOS Programación con nemonicos, llamadas al Sistemas opertivo
Capa 3 Servicios de la BIOS Programación con nemonicos, llamadas a la BIOS
Capa 2 Assembler Programación con nemonicos
Capa 1 Hadware (firmware) Programación en hexadecimal
Capa 0 Hadware Circuitos integrados

Figura 1.19: Modelo para desarrollo de sistemas de computación

Todo lo mencionado pone en evidencia que los sistemas de computación son básicamente sistemas
digitales y, como tales, su desarrollo involucra direcciones de memoria, direcciones de puertos de
I/O entre otros aspectos. Empezaremos con la memoria de la computadora en modo texto.

Para el desarrollo de sistemas de computación que utilizan la memoria en modo texto necesitamos
entender el código ASCII, el byte de atributo monocromático y a colores así como la paginación.
1.3. MEMORIA EN MODO TEXTO Y CÓDIGO ASCII 14

Como se ve en la figura 1.20, la memoria de video en modo texto empieza en la dirección 0B800h.
Esta memoria está paginada, cada página tiene un tamaño de 80x25x2 = 4000 Bytes; por tanto la
página 0 va de 0B800h hasta 0C7A0h. Por ejemplo, suponiendo un monitor monocromático,
vea que el caracter A, en la pantalla 80x25 está en la fila 00, columna 00 y es una letra blanca
sobre fondo negro. Esta letra se representa con el código ASCII 41h y su atributo sería 07h; es
decir la letra A ocupa la dirección 0B800h y su atributo la dirección 0B801h, respectivamente.

Memoria modo texto

0B800h Caracter
Atributo
..
.
0C7A0h Página 0
Columna
00 79
Fila 00 A
Página 1

Pantalla 80x25
Página 2

Página 3 24

Figura 1.20: La memoria en modo texto

En primer lugar veremos el código ASCII, en la figura 1.21 mostramos los caracteres imprimibles.
Por ejemplo el espacio en blanco es el ASCII 0x20, las letras minúsculas van de 0x61 hasta 0x7A,
las letras mayúsculas van de 0x41 hasta 0x5A y los números van de 0x30 hasta 0x39. El estudio
del código ASCII nos facilitará enormemente en el desarrollo de algoritmos para los sistemas de
computación.

0 x20 = 0 x21 = ! 0 x22 = " 0 x23 = # 0 x24 = $ 0 x25 = % 0 x26 = &

0 x27 = ' 0 x28 = ( 0 x29 = ) 0 x2a = * 0 x2b = + 0 x2c = , 0 x2d = -
0 x2e = . 0 x2f = / 0 x30 = 0 0 x31 = 1 0 x32 = 2 0 x33 = 3 0 x34 = 4
0 x35 = 5 0 x36 = 6 0 x37 = 7 0 x38 = 8 0 x39 = 9 0 x3a = : 0 x3b = ;
0 x3c = < 0 x3d = = 0 x3e = > 0 x3f = ? 0 x40 = @ 0 x41 = A 0 x42 = B
0 x43 = C 0 x44 = D 0 x45 = E 0 x46 = F 0 x47 = G 0 x48 = H 0 x49 = I
0 x4a = J 0 x4b = K 0 x4c = L 0 x4d = M 0 x4e = N 0 x4f = O 0 x50 = P
0 x51 = Q 0 x52 = R 0 x53 = S 0 x54 = T 0 x55 = U 0 x56 = V 0 x57 = W
0 x58 = X 0 x59 = Y 0 x5a = Z 0 x5b = [ 0 x5c = \ 0 x5d = ] 0 x5e = ^
0 x5f = _ 0 x60 = ` 0 x61 = a 0 x62 = b 0 x63 = c 0 x64 = d 0 x65 = e
0 x66 = f 0 x67 = g 0 x68 = h 0 x69 = i 0 x6a = j 0 x6b = k 0 x6c = l
0 x6d = m 0 x6e = n 0 x6f = o 0 x70 = p 0 x71 = q 0 x72 = r 0 x73 = s
0 x74 = t 0 x75 = u 0 x76 = v 0 x77 = w 0 x78 = x 0 x79 = y 0 x7a = z
0 x7b = { 0 x7c = | 0 x7d = } 0 x7e = ~

Figura 1.21: Código ASCII, caracteres imprimibles

Por ejemplo si quisieramos convertir de minúsculas de mayúsculas o de mayúsculas a minúsculas el

algoritmo es super sencillo gracias al código ASCII.
a = 0 x61 = 0110 0001 A = 0 x41 = 0100 0001
1.3. MEMORIA EN MODO TEXTO Y CÓDIGO ASCII 15

AND OR
0 xDF = 1101 1111 0 x20 = 0010 0000
--------- ---------
A = 0 x41 = 0100 0001 a = 0 x61 = 0110 0001
| |
+ - - - - - - Solo cambia un bit + - - - - - - Solo cambia un bit

En segundo lugar, veremos el byte de atributo. Para esto tenemos que saber, que en los sistemas
de computación pueden utilizarse monitores monocromáticos y monitores a color. La definición del
byte de atributo está en la figura 1.22.

Monocromático Colores
byte Atributo Fondo Caracter Atributo
00 Invisible B R G B I R G B
01 Subrayado 1 0 0 0 0 0 0 0 Parpadeo
07 Normal 0 1 0 0 0 0 0 0 Fondo rojo
09 Intenso subrayado 0 0 1 0 0 0 0 0 Fondo verde
0F Intenso 0 0 0 1 0 0 0 0 Fondo azul
70 Inverso 0 0 0 0 0 1 0 0 Caracter rojo
87 Parpadeo 0 0 0 0 0 0 1 0 Caracter verde
8F Intenso, parpadeo 0 0 0 0 0 0 0 1 Caracter azul
F0 Inverso, parpadeo 0 0 0 0 1 1 1 1 Caracter blanco intenso

Figura 1.22: Definición del byte de atributo

Por defecto, cuando encendemos la computadora, la terminal (consola) esta en monocromático

80x25 y modo normal (0x07); es decir, caracter blanco sobre fondo negro. Por defecto también se
despliega el prompt C:/>, esto en la memoria se codifica como:
Direccion Caracter y atributo

0 xB800 0 x43 Caracter C

0 xB801 0 x07 Atributo
0 x8002 0 x3A Caracter :
0 xB803 0 x07 .
0 xB804 0 x2F .
0 xB805 0 x07 .
0 xB806 0 x3E
0 xB807 0 x07

En tercer lugar, veremos la correspondencia entre la pantalla 80x25 y la memoria destinada para el
modo texto. Para esto, a partir de la figura 1.20 se puede ver que:

MemTex(col,fil) = (16*PaSe)+(NroPa*TaPa)+(2*NroFil*AnFi)+(2*NroCo) + K (1.1)

Donde:

MemTex = Posición de memoria de texto en función de la columna y la fila de la pantalla 80x25.

PaSe = Párrafo de segmento. El 16*PaSe = 0x0B800
NroPa = Número de página. En el modo 80x25 se cuentan con cuatro páginas (0, 1, 2 y 3). Por
defecto esta en la página 0
TaPa = Tamaño de página. Para el modo 80x25 cada página tiene 4000 bytes de tamaño.
NroFi = Número de fila. En el modo 80x25 se cuentan con 25 filas (de 0 a 24).
AnFi = Ancho de fila. En el modo 80x25, el ancho de una fila es 24*2.
1.3. MEMORIA EN MODO TEXTO Y CÓDIGO ASCII 16

NroCol = Número de columna.En el modo 80x25, se cuentan con 80 columnas (de 0 a 79).

Además K = 0, cuando se trata de acceder a un caracter y K = 1, cuando se trata de acceder al

atributo del caracter.

Finalmente veremos los modos de video texto. En la figura 1.23 se muestran los modos de video
texto. Vea que básicamente hay dos tamaños: 40x25 y 80x25. Una pantalla 40x25 ocupa 2000
bytes en la memoria y se disponen hasta ocho páginas de viveo modo texto. Mientras que una
pantalla 80x25 ocupa 4000 bytes en la memoria y se disponen hasta cuatro páginas de video
modo texto.

Modo tamaño (ColumnaxFila) Resolución Colores

00 40x25 360x400
01 40x25 360x400 16 de 262, 144
02 80x25 720x400
03 80x25 720x400 16 de 262, 144
07 80x25 720x400

Figura 1.23: Modos de video texto

Ejemplo 1.1 Desarrollar un sistema de computación que permita acceder a la memoria de video
texto, para desplegar caracteres ASCII.

En la figura 1.24 se muestra el programa que permite implementar un sistema de computación para
acceder a la memoria de video texto. La memoria de video texto es apuntada por el registro ES
(lineas 23 y 24). Luego el programa principal, entre las líneas 25 y 33, simplemente lee los datos
a través de SI y los escribe en la memoria de la computadora utilizando el procedimiento posxy
(línea 29). Se esta utilizando CX como contador y la variable col permite desplegar los datos en
la pantalla de forma horizontal.

El procedimiento posxy (líneas 39 a 48) resuelve la ecuación 1.1 y el procedimiento pomem (líneas
53 a 64) resuelven la ecuación (NroPa*TaPa)+(2*NroFil*AnFi)+(2*NroCo)+K. En este
punto vea que como, se selecciona por defecto, la página 0, no calculamos la parte (NroPa*TaPa),
simplemente se calcula la posición de memoria en función a la fila y columna. También fijese que si
K = 0 (línea 40) se accede a los caracteres y si K = 1 (línea 43) se accede a los atributos.

Ejemplo 1.2 Desarrollar un sistema de computación que permita “dibujar” letras con un tamaño
de 8x12 = Columnas*Filas, en un monitor 80x25.

En la figura 1.25 mostramos el modelo y el diagrama de flujo para dibujar los caracteres pedidos
(8x12). Se ve que X controla el número de bits dentro de un byte, además Y controla el número
de bytes. La letra A se codifica en 12 bytes. Vea que dentro de cada byte, los bits se desplazan
hacia la bandera de acarreo (shl al). Entonces, si CF = 1 se dibuja un punto en la pantalla. Las
variables col y fil permiten controlar los puntos que se dibujan en la pantalla, en base al patron
de bits de la letra A. El sistema completo se muestra en la figura 1.26
1.3. MEMORIA EN MODO TEXTO Y CÓDIGO ASCII 17

pila segment stack

2 dw 100 dup (0)
pila ends
4 ; ---------------------------------------------------------------------
datos segment
6 cadena db ' Javier '
largo dw 6
8 fil dw 12
col dw 40
10 k dw 0
atrib db 67 h
12 datos ends
; ---------------------------------------------------------------------
14 codigo segment
program proc far
16 assume ss : pila , ds : datos , cs : codigo
push ds
18 sub ax , ax
push ax
20 mov ax , datos
mov ds , ax
22
mov ax ,0 b800h
24 mov es , ax
lea si , cadena
26 mov cx , largo
otro :
28 mov al ,[ si ]
call posxy
30 inc si
inc col
32 loop otro
ret
34 program endp
; ---------------------------------------------------------------------
36 ; Resuelve la eccuacion
; (16* PaSe ) +( NroPa * TaPa ) +(2* NroFil * AnFi ) +(2* NroCo ) + K
38 ; ---------------------------------------------------------------------
posxy proc
40 mov k ,0 ; Caracter
call pomem
42 mov es :[ bx + di ] , al ; MemTex ( col , fil )
mov k ,1 ; Atributo
44 call pomem
mov al , atrib
46 mov es :[ bx + di ] , al ; MemTex ( col , fil )
ret
48 posxy endp
; ---------------------------------------------------------------------
50 ; Resuelve la ecuacion
; ( NroPa * TaPa ) +(2* NroFil * AnFi ) +(2* NroCo ) + K
52 ; ---------------------------------------------------------------------
pomem proc
54 push ax
mov ax , fil
56 mov bx ,160
mul bx ; Resultado en DX : AX
58 mov bx , ax ; BX = Nro. Fila x Ancho fila x 2
mov di , col
60 shl di ,1
add di , k ; DI = 2 x Nro. Columna + K
62 pop ax
ret
64 pomem endp
; ---------------------------------------------------------------------
66 codigo ends
end program

Figura 1.24: Programa para acceder a la memoria de video texto

1.3. MEMORIA EN MODO TEXTO Y CÓDIGO ASCII 18

X fonts
SI → 1 1 1 0x38 C 1 1 1
1 1 1 0x38
1 1 0x28 shl al si = carA
1 1 1 1 0x6C
1 1 1 1 0x6C y ← 12
Y 1 1 1 1 0x6C
1 1 0x44
1 1
x ← 8 fo1:
0x44
1 1 1 1 1 1 1 0xFE
1 1 1 1 1 1 1 0xFE col ← 40
1 1 1 1 0xC6
1 1 1 1 0xC6 al ← [si]

fo2: shl al
carA db 38 h ,38 h ,28 h ,6 ch ,6 ch ,6 ch si
db 44 h ,44 h ,0 feh ,0 feh ,0 c6h ,0 c6h no
CF = 1
x db 0 ; Controla las posiciones de bit
y db 0
fil dw 5 ; Controla posiciones de pantalla punto
col dw 40
k dw 0 ; Si k =0 caracter , si k =1 atributo fo3: col ← col + 1
atrib db 07 h
x←x-1

no
x=0
si
si ← si + 1

fil ← fil + 1

y←y-1

no
y=0
si
. ret

Figura 1.25: Sistema de computación que genera fonts en modo texto 80x25

pila segment stack

dw 100 dup (0)
pila ends
; ----------------------------------------------------------
datos segment
carA db 38 h ,38 h ,28 h ,6 ch ,6 ch ,6 ch
db 44 h ,44 h ,0 feh ,0 feh ,0 c6h ,0 c6h
x db 0 ; Controla las posiciones de bit
y db 0
fil dw 5 ; Controla posiciones de pantalla
col dw 40
k dw 0 ; Si k =0 caracter , si k =1 atributo
atrib db 07 h
datos ends
; ----------------------------------------------------------
codigo segment
program proc far
assume ss : pila , ds : datos , cs : codigo
push ds
sub ax , ax
push ax
1.3. MEMORIA EN MODO TEXTO Y CÓDIGO ASCII 19

mov ax , datos
mov ds , ax
mov ax ,0 b800h
mov es , ax
lea si , carA
mov y ,12
fo1 :
mov x ,8
mov col ,40
mov al ,[ si ]
fo2 :
shl al ,1
jnc fo3
call punto
fo3 :
inc col
dec x
cmp x ,0
jne fo2
inc si
inc fil
dec y
cmp y ,0
jne fo1
ret
program endp
; ----------------------------------------------------------
pomem proc
mov ax , fil
mov bx ,160
mul bx
mov bx , ax
mov di , col
shl di ,1
add di , k
ret
pomem endp
; ----------------------------------------------------------
punto proc
push ax
mov k ,0 ; Caracter
call pomem
mov al , 'o '
mov es :[ bx + di ] , al
mov k ,1 ; Atributo
call pomem
mov al , atrib
mov es :[ bx + di ] , al
pop ax
ret
punto endp
; ----------------------------------------------------------
codigo ends
end program

Figura 1.26: Sistema que permite dibujar fonts en una pantalla 80x25

En la figura 1.26, el procedimiento punto utiliza la ecuación 1.1. El procedimiento pomem resuelve
la ecuación (NroPa*TaPa)+(2*NroFil*AnFi)+(2*NroCo)+K, vea que con K = 0 accedemos
a los caracteres mientras que cuando K = 1 accedemos a los atributos
1.4. MEMORIA EN MODO GRÁFICO 20

1.4 Memoria en modo gráfico

Para estudiar el modo gráfico será necesario adelantarnos un poco y utilizar algunos servicios para
cambiar el modo de video y esperar una tecla para terminar el programa. En la figura 1.27 presen-
tamos algunos servicios necesarios para estudiar el modo gráfico. La figura 1.27a) obtiene el modo
de video actual en AX, por eso nosotros guardamos AX (mov vian,ax). En la figura 1.27b) ponemos
el modo de video especificado en AL, en nuestro caso el modo 13h, 320x200x256. Finalmente en la
figura 1.27c) se lee una tecla en AL, este servicio detiene el programa hasta que el usuario presione
cualquier tecla, esto nos permitirá ver lo realizado en el modo gráfico.

omovi proc pmovi proc lseco proc

mov ah ,0 fh mov ah ,0 mov ah ,07
int 10 h mov al ,13 h int 21 h
mov vian , ax int 10 h ret
ret ret lseco endp
omovi endp pmovi endp ; AL = caracter

a) Obtiene modo de video b) Pone modo de video c) Lee una tecla sin eco

Figura 1.27: Servicios necesarios para estudiar los modos gráficos

Modo Resolución Colores Dirección Modo Resolución Colores Dirección

0Dh 320x200 16 0x0A000 04h 320x200 4 0x0B800
0Eh 640x200 16 0x0A000 05h 320x200 0x0B800
10h 640x350 16 0x0A000 06h 640x200 0x0B800
12h 640x480 16 de 262, 144 0x0A000 0Fh 640x350 0x0A000
11h 640x480 2 de 262, 144 0x0A000
13h 320x200 256 de 262, 144 0x0A000

Figura 1.28: Modos de video gráfico

Memoria modo gráfico

0A000h 0 0 0 0 0 0 1 0

Columna
00 320
Fila 00 •

..
.

Pantalla 320x200

..
.
0FA00h 200

Figura 1.29: La memoria en modo gráfico

Ejemplo 1.3 Desarrollar un sistema de computación que permita dibujar un pixel amarillo en cada
esquina de la pantalla 320x200x256
 1.4. MEMORIA EN MODO GRÁFICO 21

pila segment stack

2 dw 100 dup (0)
pila ends
4 ; ----------------------------------------------------------
datos segment
6 posx dw 0
posy dw 0
8 color db 14 ; Amarillo
vian dw 0
10 datos ends
; ----------------------------------------------------------
12 codigo segment
program proc far
14 assume ss : pila , ds : datos , cs : codigo
push ds
16 sub ax , ax
push ax
18 mov ax , datos
mov ds , ax
20 mov ax ,0 a000h
mov es , ax
22 mov ah ,0 fh ; Obtener modo de video
int 10 h
24 mov vian , ax
mov al ,13 h ; Pone modo 13 h
26 mov ah ,0 ; 320 x200x256
int 10 h
28 call pixel ; ESI
mov posx ,319 ;
30 call pixel ; ESD
mov posy ,199 ;
32 call pixel ; EID
mov posx ,0 ;
34 call pixel ; EII
mov ah ,07 ; Espera una tecla
36 int 21 h
mov ax , vian ; Repone
38 mov ah ,0 ; modo texto
int 10 h
40 ret
program endp
42 ; ----------------------------------------------------------
pixel proc
44 push cx
mov bx , posy
46 mov di , bx
mov cl ,8 ; posy *256
48 shl bx , cl
mov cl ,6 ; posy *64
50 shl di , cl
add di , posx ; posy *(256+64) + posx
52 mov al , color
mov es :[ bx + di ] , al ; 0 a000 + posy *(320) + posx
54 pop cx
ret
56 pixel endp
; ----------------------------------------------------------
58 codigo ends
end program

Figura 1.30: Acceso a la memoria de video en modo gráfico 320x200x256

1.4. MEMORIA EN MODO GRÁFICO 22

En los modos texto, la unidad básica de información es el caracter, mientras que en los modos
gráficos la unidad básica de información es el pixel. Un pixel es un punto en la pantalla gráfica.
Cuando se trata de los modos gráficos es necesario entender como se representa un pixel. Por
ejemplo en la figura 1.29, en el modo 13h un pixel se representa con 8 bits (un byte) por eso se
disponen de 256 colores; desde el (00000000) hasta el (11111111). La cantidad de memoria necesaria
para una pantalla de 320x200 es de 64000 bytes. Es decir una pantalla gráfica de 320x200x256, en
la memoria de la computadora va desde la dirección 0x0A000 hasta la dirección 0x0FA00.

MemGraf(posx,posy) = 0x0A000+posy*(320)+posx (1.2)

Para convertir de una posición de pantalla (posx,posy) en una posición de memoria de video
320x200x256 utilizamos la fórmula 1.2. La implementación de esta fórmula esta en las líneas 43 a
56 del programa de la figura 1.30. Cuando haga correr el programa fíjese que primero se imprime
un pixel amarillo en la esquina superior izquierda, ESI (0,0); luego en la esquina superior derecha,
ESD (319,0); luego en la esquina inferior derecha, EID (319,199); finalmente en la esquina inferior
izquierda EII (0,199).

El programa de la figura 1.30 primero cambia de modo texto a modo gráfico (lineas 22 a 27 de la
figura 1.30), luego dibuja cuatro pixels, uno en cada esquina de la pantalla (lineas 28 a 34), luego
espera una tecla y termina el programa.

Ejemplo 1.4 Desarrollar un sistema de computación que, utilizando la formula 1.2 permita dibujar
en la pantalla líneas verticales de diferente color

pila segment stack

dw 100 dup (0)
pila ends
; ----------------------------------------------------------
datos segment
posx dw ?
posy dw ?
color db 0
vian dw 0
datos ends
; ----------------------------------------------------------
codigo segment
program proc far
assume ss : pila , ds : datos , cs : codigo
push ds
sub ax , ax
push ax
mov ax , datos
mov ds , ax
mov ax ,0 a000h
mov es , ax
mov ah ,0 fh ; Obtener modo de video
int 10 h
mov vian , ax
mov al ,13 h ; Pone modo 13 h
mov ah ,0 ; 320 x200x256
int 10 h
mov cx ,319 ; CX lineas
mov posx ,0 ; posx , posy
mov posy ,2 ; Un pixel es ubicado por
otro : call linea
add posx ,1 ; Espacio entre lineas
1.4. MEMORIA EN MODO GRÁFICO 23

inc color
loop otro
mov ah ,07 ; Espera una tecla
int 21 h
mov ax , vian
mov ah ,0 ; Pone modo 13 h
int 10 h
ret
program endp
; ----------------------------------------------------------
linea proc
push cx
push posy
mov cx ,100 ; linea de CX pixels
li1 : call pixel
inc posy
loop li1
pop posy
pop cx
ret
linea endp
; ----------------------------------------------------------
pixel proc
push cx
mov bx , posy
mov di , bx
mov cl ,8 ; posy *256
shl bx , cl
mov cl ,6 ; posy *64
shl di , cl
add di , posx ; posy *(256+64) + posx
mov al , color
mov es :[ bx + di ] , al ; 0 a000 + posy *(320) + posx
pop cx
ret
pixel endp
; ----------------------------------------------------------
codigo ends
end program

Figura 1.31: Acceso a la memoria de video en modo gráfico 320x200x256

En la figura 1.31, se muestra el sistema para dibujar una recta vertical (procedimiento linea). Vea
que una recta es una secuencia de pixeles, por eso incrementamos posy. Cada línea es de 100 pixeles
de largo. También es importante indicar que para dibujar la siguiente recta es necesario hacerlo a
partir de (posx,posy), por eso es necesario conservar posy, para eso utilizamos push posy y pop posy.

Para aclarar la manera como se representa un pixel en la memoria de video gráfico, veamos el modo
04h que tiene una resolución de 320x200x4; es decir 300 columnas, 200 filas y cuatro colores

D7 D6 D5 D4 D3 D2 D1 D0
Color 1 Color 2 Color 3 Color 4

Figura 1.32: Cada pixel ocupa dos bits

1.4. MEMORIA EN MODO GRÁFICO 24

pila segment stack

dw 100 dup (0)
pila ends
; ----------------------------------------------------------
datos segment
posx dw 0
posy dw 0
color db 01001011 b ; Cuatro colores
vian dw 0
datos ends
; ----------------------------------------------------------
codigo segment
program proc far
assume ss : pila , ds : datos , cs : codigo
push ds
sub ax , ax
push ax
mov ax , datos
mov ds , ax
mov ax ,0 B800h
mov es , ax
mov ah ,0 fh ; Obtener modo de video
int 10 h
mov vian , ax
mov al ,04 h ; Pone modo 13 h
mov ah ,0 ; 320 x200x256
int 10 h
call pixel ; ESI
mov posx ,79 ; 319/4
call pixel ; ESD
mov posy ,99 ; 199/2
call pixel ; EID
mov posx ,0
call pixel ; EII
mov posy ,1 ; Una recta en posy = 1
mov cx ,80 ; CX = 320/4
otro : call pixel
inc posx
loop otro ;
mov ah ,07 ; Espera una tecla
int 21 h
mov ax , vian ; Repone
mov ah ,0 ; modo texto
int 10 h
ret
program endp
; ----------------------------------------------------------
pixel proc
push cx
mov ax ,80
mul posy
mov bx , ax
mov di , posx
mov al , color
mov es :[ di + bx ] , al ; 0 B800 + posy *(320/4) + posx
pop cx
ret
pixel endp
; ----------------------------------------------------------
codigo ends
end program

Figura 1.33: Acceso a la memoria de video en modo gráfico 320x200x4

1.5. INTERRUPCIONES Y MAPEO DE MEMORIA DE LA COMPUTADORA 25

Figura 1.34: Resultado del programa de la figura 1.33

1.5 Interrupciones y mapeo de memoria de la computadora

a) Vector de interrupciones b) Un vector ocupa cuatro bytes

Dirección Vector de interrupción Tipo Dirección int 21h

FFFFh Para el usuario int FFh 0087h CS high
.. .. .. 0086h CS low
. . . 0085h IP high
01E0h Para el usuario int 78h 0084h IP low
01D8h Controlador de disco duro int 76h
01D4h Procesador matemático int 75h
01C0h Reloj de tiempo real int 70h
.. .. ..
. . .
00CCh Mouse int 33h
00C8h Para el usuario int 32h
.. .. ..
. . .
0098h Escritura absoluta de disco int 26h
0094h Lectura absoluta de disco int 25h
0084h Llamada al DOS int 21h
0080h Termina programa int 20h
.. .. ..
. . .
0068h Lee y pone la hora int 1Ah
005Ch Salida por la impresora int 17h
0058h Entrada desde teclado int 16h
0050h Comunicación E/S int 14h
0040h Gestión de pantalla int 10h
0024h Teclado int 09h
0020h Temporizador (TIC) int 08h
0008h NMI int 02h
0004h Paso a paso int 01h
0000h Error al dividir int 00h

Figura 1.35: Vector de interrupciones de las computadoras con µProcesadores Intel

1.5. INTERRUPCIONES Y MAPEO DE MEMORIA DE LA COMPUTADORA 26

Las tareas que hemos realizado antes, como desplegar un texto en la pantalla entre otras, también
las podemos realizar utilizando los servicios de la BIOS y del DOS, que son accedidos a través de
interrupciones.

Para esto introducimos el concepto de vector de interrupciones. El vector de interrupciones,

como se muestra en la figura 1.35 es una colección de direcciones de programas de servicio a las
interrupciones. Por ejemplo la int 9 es la interrupción dedicada al teclado de la computadora, vea
que la int 9 está en la dirección 0x0024 y ocupa cuatro bytes.

Algunas interrupciones, tales como la int 10h o la int 21h realizan varios servicios. Por ejemplo el
servicio AH = 02 de la int 10h permite colocar el cursor en una posición de pantalla modo texto.
Veamos un ejemplo.

Poner el cursor Scroll UP, DOWN Leer posición del cursor

mov ah ,02 mov ah ,06 ; o mov ah ,07 mov ah ,03
mov bh ,00 ; Pagina mov al , N ; Lineas a desplazar mov bh ,00
mov dh , fila mov bh ,07 ; Atributo int 10 h
mov dl , columna mov cx ,0000 ; ESI ; Devuelve en
int 10 h mov dx ,184 Fh ; EID ; DH = Fila
; int 10 h ; DL = Columna

Poner modo de video Obtener modo de video Escribir un caracter

mov ah ,00 mov ah ,0 Fh mov ah ,09 ; o mov ah ,0 Ah
mov al , Modo de video int 10 h mov al , char
int 10 h ; Devuelve mov bh , pagina
; ; AL = Modo alctual mov bl , atributo
; ; AH = Caracteres por linea mov cx , repeticion
; ; BH = Pagina actual int 10 h

Figura 1.36: Algunos servicios de la int 10h

Ejemplo 1.5 Desarrollar un sistema de computación que borre la pantalla, modo texto 80x25 y,
escriba una letra en el centro de la misma

page 65 ,132
title TITULO DEL inicio
; ------------------------------------------------------------------
; Segmento de pila
; ----------------
pila segment para stack ' stack '
dw 32 dup (?)
pila ends
; ------------------------------------------------------------------
; Segmento de datos
; -----------------
datos segment para ' data '
datos ends
; ------------------------------------------------------------------
codigo segment para ' code '
inicio proc far
assume ss : pila , ds : datos , cs : codigo , es : datos
push ds
sub ax , ax
push ax
1.5. INTERRUPCIONES Y MAPEO DE MEMORIA DE LA COMPUTADORA 27

mov ax , datos
mov ds , ax
call bopan
call pocur
call esChar
ret
inicio endp
; ------------------------------------------------------------------
bopan proc
mov ah ,06 ; o mov ah ,07
mov al ,0 ; Si AL =0 se borra la pantalla
mov bh ,07
mov cx ,0000 ; ESI
mov dx ,184 Fh ; EID
int 10 h
ret
bopan endp
; ------------------------------------------------------------------
pocur proc
mov ah ,02
mov bh ,00 ; Pagina
mov dh ,12 ; fila
mov dl ,40 ; columna
int 10 h
ret
pocur endp
; ------------------------------------------------------------------
esChar proc
mov ah ,09 h ; o mov ah ,0 Ah
mov al , 'J '
mov bh ,0
mov bl ,07
mov cx ,1
int 10 h
ret
esChar endp
; ------------------------------------------------------------------
codigo ends
end inicio

Figura 1.37: Aplicación de los servicios de la int 10h

Ahora veamos algunos servicios de las int 21h.

1.5. INTERRUPCIONES Y MAPEO DE MEMORIA DE LA COMPUTADORA 28

Escribe una cadena en pantalla Escribe un caracter Leer una cadena de teclado
cadena db " ETN903 " ,24 h mov ah ,02 cadena label byte
; mov dl , caracter lomax db N
mov ah ,09 int 21 h loact db ?
lea dx , cadena ; nombre db N dup (?)
int 21 h ; ;
; ; mov ah ,0 Ah
; ; lea dx , cadena
; ; int 21 h

Lee un caracter con eco Leer un caracter sin eco Lee el estado del teclado
mov ah ,01 mov ah ,07 mov ah ,0 Bh
int 21 h int 21 h int 21 h
; ; ;
; Devuelve el caracter en AL ; Devuelve el caracter en AL ; Devuelve el estado en AL
; y lo replica en pantalla ; no lo replica en pantalla ; AL = FFh si hay tecla
; ; ; AL = 00 h si no hay tecla

Figura 1.38: Algunos servicios de la int 21h

Ejemplo 1.6 Desarrollar un sistema de computación que permita crear un menú horizontal. La
primera letra de cada elemento del menú debe ser diferente a las demás letras del elemento.

Menu Archivo........$ Editar.........$ Ver............$ Correr.........$ Punto de parada$

↑ ↑ ↑ ↑ ↑
DS:0000 0 16 32 48 64
Pantalla Archivo Editar Ver Correr Punto de parada
↑ ↑ ↑ ↑ ↑
poMenu 0 8 15 19 26
Figura 1.39: Posiciones de memoria y posiciones de pantalla del menú

En la figura 1.39 se muestra el modelo planteado para desarrollar un sistema de computación que
permita dibujar un menú horizontal. En la primera fila de la figura 1.39 se muestran las direcciones
que ocupan los elementos del menú en la memoria de la computadora. El elemento Archivo está en
la dirección 0, el elemento Editar está en la dirección 16, etc. Esto se implementa en el programa
en la línea 36 de la figura 1.41.

En la segunda fila de la figura 1.39 mostramos las posiciones que ocupan los elementos del menú en
la pantalla 80x25. El elemento Archivo se ubicará en la columna 0, el elemento Editar se ubicará
en la columna 8 y así sucesivamente. Esto se implementa, en el programa, en las líneas 30 y 31.
Vea que la fila es común, DH = 00.

Para desplegar los elementos del menú se utiliza el servicio AH = 09 de la int 21h. Este servicio
requiere que la cadena de caracteres, a desplegar en la pantalla, debe terminar con el ASCII “$” o
“24h”.
1.5. INTERRUPCIONES Y MAPEO DE MEMORIA DE LA COMPUTADORA 29

call bopan
bopan
mov cx ,5
lea si , menu
cx ← 5 lea bx , poMen
mov dx ,0000 h
si = menu otro : mov dl ,[ bx ]
bx = poMen call pocur
call esCad
dx ← 0000
call pocur
otro mov al ,[ si ]
dl ← [bx] call esChar
add si ,16
pocur inc bx
loop otro
esCad
pocur
al ← [si]
esChar

si ← si + 16

bx ← bx + 1

no cx = 0
si

ret

Figura 1.40: Programa principal del sistema que dibuja un menu horizontal

page 65 ,132
title TITULO DEL inicio
; - - - - - - - - - - - - - - - - - - - - - - - - - - - Segmento de pila - - - - - - - - - - - - - - - - - - - - - - -
; ----------------
pila segment para stack ' stack '
dw 32 dup (?)
pila ends
; - - - - - - - - - - - - - - - - - - - - - - - - - - - Segmento de datos - - - - - - - - - - - - - - - - - - - - - -
; -----------------
datos segment para ' data '
menu db " Archivo $Editar $Ver $"
db " Correr $Punto de parada$ "
poMen db 0 ,8 ,15 ,19 ,26
datos ends
; - - - - - - - - - - - - - - - - - - - - - - - - - - - Segmento de codigo - - - - - - - - - - - - - - - - - - - - -
; ------------------
codigo segment para ' code '
inicio proc far
assume ss : pila , ds : datos , cs : codigo , es : datos
push ds
sub ax , ax
push ax
mov ax , datos
mov ds , ax
call bopan
mov cx ,5
lea si , menu
lea bx , poMen
mov dx ,0000 h
otro : mov dl ,[ bx ]
call pocur
1.5. INTERRUPCIONES Y MAPEO DE MEMORIA DE LA COMPUTADORA 30

call esCad
call pocur
mov al ,[ si ]
call esChar
add si ,16
inc bx
loop otro
ret
inicio endp
; - - - - - - - - - - - - - - - - - - - - - - - Borra la pantalla - - - - - - - - - - - - - - - - - - - - - - - - - -
; -----------------
bopan proc
mov ah ,06 ; o mov ah ,07
mov al ,0 ; Si AL =0 se borra la pantalla
mov bh ,07
mov cx ,0000 ; ESI
mov dx ,184 Fh ; EID
int 10 h
ret
bopan endp
; - - - - - - - - - - - - - - - - - - - - - - - - - - Pone el cursor - - - - - - - - - - - - - - - - - - - - - - - - - -
; --------------
pocur proc
push bx
mov ah ,02
mov bh ,00 ; Pagina
int 10 h
pop bx
ret
pocur endp
; - - - - - - - - - - - - - - - - - - - - - - - - - Escribe un caracter - - - - - - - - - - - - - - - - - - - - - -
; -------------------
esChar proc
push cx
push bx
mov ah ,09 h ; o mov ah ,0 Ah
mov bh ,0
mov bl ,0 Ah
mov cx ,1
int 10 h
pop bx
pop cx
ret
esChar endp
; - - - - - - - - - - - - - - - - - - - - - - - - - - - Escribe una cadena - - - - - - - - - - - - - - - - - - - - -
; ------------------
esCad proc
push dx
mov dx , si
mov ah ,09
int 21 h
pop dx
ret
esCad endp
; ------------------------------------------------------------------
codigo ends
end inicio

Figura 1.41: Aplicación de los servicios de la int 10h y la int 21h

Como se ve en la figura 1.42, hay varias teclas que se repiten: los números, Shift, Ctrl, Insert, Supr,
Etc. Entonces es necesario estudiar cómo distinguir entre dos teclas con el mismo código ASCII.
1.6. EL TECLADO 31

1.6 El teclado

Figura 1.42: Teclado de computadora

N equ 5 leCade proc

texto db N ,? , N dup (?) mov ah ,0 Ah
| | | lea dx , texto
| | +------> Area de datos N -1 , int 21 h
| | el ultimo es ENTER = 0 Dh ret
| +--------> Longitud actual leCade endp
+----------> Longitud maxima ;

a) en el segmento de datos b) En el segmento de código

Figura 1.43: Servicio AH = 0Ah de la int 21h

Por ejemplo si se lee “1234” desde teclado el segmento de datos quedaría como
05 04 31 32 33 34 0 D

Si se lee “123” desde el teclado el segmento de datos quedaría como, fíjese que XX significa que es
basura que quedo de la anterior lectura.
05 03 31 32 33 0 D XX

1.6.1 Los códigos de rastreo

Para acceder a los códigos de rastreo, la computadora nos ofrece el servicio 10h de la int 16h.
Este devuelve en AX el código de rastreo y el código ASCII o, los códigos 00h o E0h, como se ve
en la tabla 1.1.

Tecla AH AL
Normal Código de rastreo Código ASCII
Extendido Código de rastreo 00h o E0h
Tabla 1.1: Servicio 10h de la int 16h
1.6. EL TECLADO 32

En las tablas 1.2 a 1.9 se muestran los códigos de rastreo para las diferentes teclas que componen
el teclado.

Letras Nornal Shift Ctrl Alt Letras Nornal Shift Ctrl Alt
ayA 1E 61 1E 41 1E 01 1E 00 nyN 31 6E 31 4E 31 0E 31 00
byB 30 42 30 62 30 02 30 00 oyO 18 6F 18 4F 18 0F 18 00
cyC 2E 63 2E 43 2E 03 2E 00 pyP 19 70 19 50 19 10 19 00
dyD 20 64 20 44 20 04 20 00 qyQ 10 71 10 51 10 11 10 00
eyE 12 65 12 45 12 05 12 00 ryR 13 72 13 52 13 12 13 00
fyF 21 66 21 46 21 06 21 00 syS 1F 73 1F 53 1F 13 1F 00
gyG 22 67 22 47 22 07 22 00 tyT 14 74 14 54 14 14 14 00
hyH 23 68 23 48 23 08 23 00 uyU 16 75 16 55 16 15 16 00
iyI 17 69 17 49 17 09 17 00 vyV 2F 76 2F 56 2F 16 2F 00
jyJ 24 6A 24 4A 24 0A 24 00 wyW 11 77 11 57 11 17 11 00
kyK 25 6B 25 4B 25 0B 25 00 xyX 2D 78 2D 58 2D 18 2D 00
lyL 26 6C 26 4C 26 0C 26 00 yyY 15 79 15 59 15 19 15 00
myM 32 6D 32 4D 32 0D 32 00 zyZ 2C 7A 2C 5A 2C 1A 2C 00
Barra espaciadora 39 20 39 20 39 20 39 20

Tabla 1.2: Códigos de rastreo de las letras del teclado

Teclas de función Nornal Shift Ctrl Alt Teclas de función Nornal Shift Ctrl Alt
F1 3B 00 54 00 5E 00 68 00 F7 41 00 5A 00 64 00 6E 00
F2 3C 00 55 00 5F 00 69 00 F8 42 00 5B 00 65 00 6F 00
F3 3D 00 56 00 60 00 6A 00 F9 43 00 5C 00 66 00 70 00
F4 3E 00 57 00 3D 61 6B 00 F10 44 00 5D 00 67 00 71 00
F5 3F 00 58 00 3D 62 6C 00 F11 85 00 87 00 89 00 8B 00
F6 40 00 59 00 3D 63 6D 00 F12 86 00 88 00 8A 00 8C 00

Tabla 1.3: Códigos de exploración de las funciones del teclado

Teclado numérico Nornal Shift Ctrl Alt Teclado numérico Nornal Shift Ctrl Alt
Ins y 0 52 00 52 30 92 00 Home y 7 47 00 47 37 77 00 00 07
End y 1 4F 00 4F 31 75 00 00 01 Flecha arriba y 8 48 00 48 38 8D 00 00 08
Flecha abajo y 2 50 00 50 32 91 00 00 02 PgUp y 9 49 00 49 39 84 00 00 09
PgDn y 3 51 00 51 33 76 00 00 03 + 4E 2B 4E 2B 90 00 4E 00
Flecha arriba y 4 4B 00 4B 34 73 00 00 04 - 4A 2D 4A 2D 8E 00 4A 00
5 4C 00 4C 35 8F 00 00 05 Del y . 53 00 53 2E 93 00
Flecha derecha y 6 4D 00 4D 36 74 00 00 06 * 37 2A 37 2A 96 00 37 00

Tabla 1.4: Códigos de rastreo del teclado numérico

Fila de números Nornal Shift Ctrl Alt Fila de números Nornal Shift Ctrl Alt
‘y˜ 29 60 29 7E 29 00 7y& 08 37 08 26 7E 00
1y! 02 31 02 21 78 00 8y* 09 38 09 2A 7F 00
2y@ 03 32 03 40 03 00 79 00 9y( 0A 39 0A 38 80 00
3y# 04 33 04 23 7A 00 0y) 0B 30 0B 29 81 00
4y$ 05 34 05 24 7B 00 -y_ 0C 2D 0C 5F 0C 1F 82 00
5y% 06 35 06 25 7C 00 =y+ 0D 3D 0D 2B 83 00
6yˆ 07 36 07 5E 07 1E 7D 00

Tabla 1.5: Códigos de rastreo de los números del teclado

1.7. LAS SEÑALES DEL MICROPROCESADOR 33

Teclas de operación Nornal Shift Ctrl Alt Teclas de operación Nornal Shift Ctrl Alt
Esc 01 1B 01 1B 01 1B 01 00 Tab 0F 09 0F 00 94 00 A5 00
Retroceso 0E 08 0E 08 0E 7F 0E 00 Enter 1C 0D 1C 0D 1C 0A 1C 00

Tabla 1.6: Códigos de rastreo de las teclas de operación

Teclas de operación Nornal Shift Ctrl Alt Teclas de operación Nornal Shift Ctrl Alt
[ y { 1A 5B 1A 7B 1A 1B 1A 00 \y | 2B 5C 2B 7C 2B 1C 2B 00
] y } 1B 5D 1B 7D 1B 1D 1B 00 ,y< 33 2C 33 3C 33 00
; y : 27 3B 27 3A 27 00 . y> 34 2E 34 3E 34 00
’ y " 28 27 28 22 28 00 /y? 35 2F 35 3F 35 00

Tabla 1.7: Códigos de rastreo de las teclas de operación

Teclas repetidas Nornal Shift Ctrl Alt Teclas repetidas Nornal Shift Ctrl Alt
Diagonal E0 2F E0 2F 95 00 A4 00 Flecha abajo 50 E0 50 E0 91 E0 A0 00
Enter E0 0D E0 0D E0 0A A6 00 Flecha izquierda 4B E0 4B E0 73 E0 9B 00
Home 47 E0 47 E0 77 E0 97 00 Flecha derecha 4D E0 4D E0 74 E0 9D 00
End 4F E0 4F E0 75 E0 9F 00 Flecha arriba 48 E0 48 E0 8D E0 98 00
PgUp 49 E0 49 E0 84 E0 99 00 Ins 52 E0 52 E0 92 E0 A2 00
PgDn 51 E0 51 E0 76 E0 A1 00 Del 53 E0 53 E0 93 E0 A3 00

Tabla 1.8: Códigos de rastreo de las teclas repetidas

Teclas de control Teclas de control

CapsLock 3A Shift (derecho) 36
NumLock 45 Alt 38
ScrollLock 46 Crtl 1D
Shift (izquierdo) 2A PrtSc 37

Tabla 1.9: Códigos de rastreo de las teclas de control

Como ejemplo, el procedimiento de la figura 1.44, lee el estado del teclado y, si se presiona cualquier
tecla, devuelve en AX el código de rastreo y su código ASCII (este es el caso de la tecla Esc) o, el
código de rastreo y 00h o E0h (este es el caso de la tecla º y la tecla »).

leTecla proc
mov ah ,0 Bh
int 21 h
cmp al ,00
je fin
Esc AH = 01 AL = 1Bh
mov ah ,10 h º AH = 48h AL = E0h
int 16 h » AH = 50h AL = E0h
fin :
ret
leTecla endp

Figura 1.44: Servicio 10h de la int 16h para leer los códigos de rastreo del teclado

1.7 Las señales del microprocesador

En los µP 8086/8088, la inmunidad al ruido se define como la diferencia entre los valores de voltaje
del “0” lógico de entrada y el voltaje del “0” lógico de salida; es decir 0.8V-0.45V=0.35V=350mV.
1.7. LAS SEÑALES DEL MICROPROCESADOR 34

Máximo Mínimo
GN D<1 40=Vcc
Características de entrada
AD14<2 39=AD15 “0” = 0.8V max, 10µA max
AD13<3 38=A16 /S3 “1” = 2.0V max, 10µA max
AD12<4 37=A17 /S4 Características de salida
“0” = 0.45V max, 2.00µA max
AD11<5 36=A18 /S5 “1” = 2.4V max, -400µA max
AD10<6 35=A17 /S6 Consumo
AD9<7 34=BHE/S7 Vcc = 5V±10%, Imax = 360mA
Temperatura
AD8<8 33=M N/M X 0◦ C a 82◦ C
AD7<9 32=RD
AD6<10 31=RQ/GT 0 HOLD
AD5<11 8086 30=RQ/GT 1 HLDA
Versión CMOS
AD4<12 29=LOCK WR Consumo
AD3<13 28=S 2 M/IO Imax = 10mA
AD2<14 27=S 1 DT /R Temperatura
-50◦ C a 108◦ C
AD1<15 26=S 0 DEN
AD0<16 25=QS0 ALE
N M I<17 24=QS1 IN T A
IN T R<18 23=T EST
CLK<19 22=READY
GN D<20 21=RESET

Figura 1.45: Terminales del µProcesador 8086

Los circuitos digitales estándar tienen un “0” de salida lógico de 0.4V y en “0” lógico de entrada
de 0.8V, con una inmunidad al ruido igual a 0.4 = 400mV. Se ve entonces que los µP reducen la
inmunidad al ruido. Por esta razón los cables conectados a cada terminal del µP no deben ser largos
y tampoco debe conectarse demasiada carga en cada patita. Se recomienda como máximo 10 cargas
antes de realizar el acoplamiento completo.

En las figuras 1.45 y 1.46 se muestran las señales asignadas a cada “pin” de los µProcesadores 8086
y 8088 respectivamente. De ambas figuras se constata que el 8088 tiene solo 8 pines para el bus de
datos; mientras que el 8086 tiene 16 pines.

• V cc: +5[V] con 10% de tolerancia.

• GN D: Tierra.

• AD0 − AD15 : Las 16 patitas por las que se multiplexa la información del bus de direcciones.
Durante el primer estado de reloj (T1 ) del ciclo de máquina, por estas patitas sale la dirección
y a partir del segundo estado salen los datos.

• S 0 , S 1 , S 2 : Muestran el estado del procesador en el modo máximo. Estas se activan durante

T4 , T1 y T2 , cuando son usadas por el controlador de Bus (8288) para decodificarlas y generar
las señales de control.
1.7. LAS SEÑALES DEL MICROPROCESADOR 35

Mínimo Máximo
GN D<1 40=Vcc
Características de entrada
A14<2 39=A15 “0” = 0.8V max, 10µA max
A13<3 38=A16 /S3 “1” = 2.0V max, 10µA max
A12<4 37=A17 /S4 Características de salida
“0” = 0.45V max, 2.00µA max
A11<5 36=A18 /S5 “1” = 2.4V max, -400µA max
A10<6 35=A19 /S6 Consumo
A9<7 34=SS 0 Vcc = 5V±10%, Imax = 340mA
Temperatura
A8<8 33=M N/M X 0◦ C a 82◦ C
AD7<9 32=RD
AD6<10 31=HOLD RQ/GT 0
AD5<11 8088 30=HLDA RQ/GT 1
Versión CMOS
AD4<12 29=W R LOCK Consumo
AD3<13 28=IO/M S2 Imax = 10mA
AD2<14 27=DT /R S1 Temperatura
-50◦ C a 108◦ C
AD1<15 26=DEN S0
AD0<16 25=ALE QS0
N M I<17 24=IN T A QS1
IN T R<18 23=T EST
CLK<19 22=READY
GN D<20 21=RESET

Figura 1.46: Terminales del µProcesador 8088

S0 S1 S2 Estado del µProcesador

0 0 0 Reconocimiento de interrupción
0 0 1 Lectura en puerta I/O
0 1 0 Escritura en puerta I/O
0 1 1 Parada (HALT)
1 0 0 Acceder a código
1 0 1 Lectura de memoria
1 1 0 Escritura en memoria
1 1 1 Pasivo, no espera

• A16 /S3 − A19 /S6 : En el primer estado del ciclo de máquina, en estas patitas sale la dirección
y en el segundo ciclo las señales S3–S6. S3 y S4 informan sobre el segmento de memoria que
se está utilizando. El pin S5 informa sobre el estado de la bandera de interrupciones, IF. Si
el pin S6 = 0 el procesador está en posesión del bus. Si S6 = 1 el bus está en posesión de otro
dispositivo.

S4 S3 Segmento utilizado
0 0 ES
0 1 SS
1 0 CS o ninguno
1 1 DS

• BHE/S7 : Durante T1 , por este pin sale la señal BHE, que permite el acceso al byte de más
peso del bus de datos. Los elementos conectados a los 8 bits de más peso del bus de datos
pueden utilizar esta señal como selección de chip. Cuando se transfiere un dato por las líneas
de más peso del bus de datos la señal BHE=0, durante T1 , en los ciclos de lectura, escritura
y reconocimiento de interrupción. A partir de T2 , sale la señal S7 = 0, excepto cuando pasa
a triestado como consecuencia de haber ocurrido una solicitud de “HOLD”.
1.7. LAS SEÑALES DEL MICROPROCESADOR 36

• RD: Señal de lectura que se activa con nivel bajo a partir del segundo estado del ciclo de
máquina cuando la CPU realiza una operación de lectura.

• T EST : Con la instrucción WAIT en un programa, se lleva el procesador al estado de espera,

del que no sale hasta que se active este pin mediante un impulso a nivel bajo. Sí el procesador
está en estado de espera y llega una interrupción, la misma es atendida y cuando termina
el programa de servicio de la interrupción se vuelve al estado de espera. Esta característica
permite conectar el 8086 con otros procesadores.

• READY : Se conecta al generador de reloj. Sirve para atender memorias y periféricos lentos.
Si uno de estos dispositivos comienza a funcionar, activa el pin RDY del generador de reloj
para solicitar más tiempo de ciclo de bus asignado, El generador de reloj pasa esta solicitud al
procesador activando la señal READY que origina la inserción de estados de espera después
de T3 del ciclo de bus. Los estados de espera se insertan mientras funciona el dispositivo
lento y cuando termina se pasa al estado T4 y se da por concluido el ciclo. En resumen si
READY = 0 el µProcesador introduce estados de espera y permanece en el mismo ciclo de
bus; si READY = 1 el µProcesador funciona normalmente.

• RESET : Se conecta al generador de reloj. Si RESET = 1, por al menos cuatro periodos de

reloj, el µProcesador efectúa un proceso de inicialización limpiando los registros IP, DS, SS y
ES; CS=FFFFh. Por tanto un RESET comienza un programa en la dirección FFFF:0000
y desactiva la bandera de interrupciones, IF=0.

• N M I: Interrupción no enmascarable. La atiende el tipo 2 de interrupción y se activa por

flanco, además debe permanecer en nivel alto por lo menos durante dos ciclos de reloj.

• IN T R: Interrupción enmascarable. Se activa por nivel, pero si IF=0 se rechaza, y si IF=1

se acepta. Cuando se acepta la interrupción la CPU activa el pin IN T A para avisar la
aceptación a los periféricos. Entonces el periférico debe colocar el tipo de interrupción en las
8 líneas de menos peso del bus de datos. La bandera IF se examina en el último ciclo de cada
instrucción.

• CLK: Proporciona las señales de reloj. El ciclo de trabajo mínimo de esta señal tiene que ser
de 33%.

• ALE: Activa a nivel alto durante el estado T1 de cualquier ciclo de bus. Indica la presencia
de direcciones en el bus multiplexado y se emplea para cargar los flip-flop que separan las
direcciones.

• DEN : Activa a nivel bajo, que detecta la presencia de un dato. Su periodo de activación
comienza al principio de T2 en los ciclos de escritura y en la mitad de T2 , en los ciclos de
lectura y de reconocimiento de interrupción se desactiva en la mitad de T4 en todos los tipos
de ciclo.

• DT /R: Controla la dirección del flujo de datos, indicando si son recibidos o trasmitidos por
la CPU.

• W R: Indica que el procesador ejecuta un ciclo de escritura de memoria.

• M/IO: Diferencia entre el acceso a una posición de memoria o a un dispositivo de E/S.

1.7. LAS SEÑALES DEL MICROPROCESADOR 37

• IN T A: Permiso de lectura en los ciclos de reconocimiento de interrupción. Funciona de la

misma manera que la señal.

• RD: Señal de lectura que se activa con nivel bajo a partir del segundo estado del ciclo de
máquina cuando la CPU realiza una operación de lectura.

• HOLD: En presencia de varios procesadores esta señal solicita el dominio del bus del sistema
por parte de otro dispositivo externo. Este es el caso del acceso directo a memoria (DMA)
que cuando se acepta, los buses se ponen en alta impedancia.

• HLDA: Comunica el reconocimiento y aceptación de HOLD. Cuando se activa esta señal,

el µProcesador, pone en estado de alta impedancia las líneas de control y las del bus local.
Cuando µProcesador detecta que HOLD pasa a nivel bajo, desactiva la línea HLDA y toma
el control de los buses.

• RQ/GT 0 y RQ/GT 1 : Realizan la misma función que las señales HOLD y HLDA en el modo
mínimo, la señal RQ/GT 0 tiene más prioridad que RQ/GT 1 . El procesador esclavo solicita
Bus a través de una de estas patitas al procesador maestro, este contesta por la misma patita
identificando la concesión del Bus. Se usa para DMA.

• LOCK: Con esta señal se indica a los otros procesadores que no se pueden obtener el control
del Bus. Se activa por medio de cualquier instrucción que lleve el prefijo LOCK y se mantiene
activa hasta que se complete la siguiente instrucción.

• Estado de la cola: En el 8086 la cola de instrucciones es de 6 bytes y en el 8088 es de 4

bytes e inicia un ciclo de búsqueda de instrucción siempre que exista un byte libre en la cola.

QS1 QS0 Estado de la cola del µP

0 0 No hay operación en la cola
0 1 Primer byte de una instrucción
1 0 Cola vacía
1 1 Siguiente byte de una instrucción

• Estado del µProcesador: El funcionamiento es similar al de las señales S 0 , S 1 , S 2

IO/M DT/R SS 0 Estado del µP

0 0 0 Reconocimiento de Interrupción
0 0 1 Lectura de memoria
0 1 0 Escritura en memoria
0 1 1 Parada (HALT)
1 0 0 Acceder a código
1 0 1 Lectura I/O
1 1 0 Escritura I/O
1 1 1 Pasivo, no espera
1.8. DEMULTIPLEXADO DE LAS SEÑALES DEL µPROCESADOR 38

1.8 Demultiplexado de las señales del µProcesador

BHE/S7 BHE

A19 /S6 − A16 /S3 74373 A19 − A16

OE
G

A15 − A8

ALE A7 − A0

8086
74373 G G 74373
OE OE

AD15 − AD8 D15 − D8

AD7 − AD0 D7 − D0

M/IO M/IO
RD RD
WR WR
M N/M X

Vcc

A19 /S6 − A16 /S3 74373 A19 − A16

OE
G

A15 − A8 A15 − A8

A7 − A0

8088
ALE G 74373
OE

AD7 − AD0 D7 − D7

M/IO M/IO
RD RD
WR WR
M N/M X

Vcc
1.9. ACOPLAMIENTO DE LAS SEÑALES DEL µPROCESADOR 39

1.9 Acoplamiento de las señales del µProcesador

M/IO M/IO
RD 74244 RD
WR OE WR

BHE/S7 BHE
A19 /S6 A19
A18 /S5 74373 A18
A17 /S4 A17
A16 /S3 • G A16
OE

A8 − A15

8086 A0 − A7

74373
ALE • G OE 74373
G OE

AD8 − AD15 74245 D8 − D15

G DIR

AD0 − AD7 74245 D0 − D7

GN D Vcc DT /R DEN G DIR
• •

IO/M IO/M
RD 74244 RD
WR OE WR

A19 /S6 − A16 /S3 74373 A19 − A16

G OE

A15 − A8 74244 A15 − A8

8088 OE

74373 A7 − A0
ALE • G OE

AD7 − AD0 74245 D7 − D0

G DIR

GN D Vcc DT /R DEN