Carrera Asignatura Clave Unidad Tema Nombre Alumno
4.1El buffer de
López Hipólito Rafael
Sistemas y Lenguajes de 4. Programación video en modo
SCC-1014 Gómez Sandoval Marco
Computación Interfaz de dispositivos texto.
Antonio
Docente: Ing. S.C. Erika Muciño Mancilla Calificación:
Material de Apoyo
Cualquiera de estas funciones necesita, al igual que todas las llamadas a interrupciones software, que se indique el
valor de la función a llamar en AH y algún parámetro para esa función en AL.
La función para establecer el modo gráfico es la 00h de la INT 10h.
Según el valor indicado en AL, pasaremos al modo gráfico (diferentes resoluciones y colores están disponibles
según el modo) o texto:
AH = 00
AL = 00: text 40*25 16 colores (monocr.)
01: text 40*25 16 colores
02: text 80*25 16 colores (monocr.)
03: text 80*25 16 colores
04: CGA 320*200 4 colores
05: CGA 320*200 4 colores
06: CGA 640*200 2 colores
07: MDA texto monocromo 80*25
0D: EGA 320*200 16 colores
0E: EGA 640*200 16 colores
0F: EGA 640*350 monocromo
10: EGA 640*350 16 colores
11: VGA 640*480 16 colores
12: VGA 640*480 16 colores
13: VGA 320*200 256 colores El
modo VGA256
Una desventaja de utilizar la INT 10h es su lentitud, ya que hay que ejecutar mucho código de la BIOS por cada
píxel. Modo de vídeo 13h : 320x200 con 256 colores
Es la forma más sencilla de dibujar utilizando acceso directo a memoria de vídeo. Los pixeles se encuentran
mapeados en un array bidimensional de bytes, donde cada byte corresponde al color de un píxel.
El array comienza con el píxel en la esquina superior-izquierda y continua toda la fila hasta la parte derecha (320
bytes). El siguiente byte corresponderá al primer píxel de la segunda fila de la pantalla, y así hasta la esquina
inferiorderecha. Así, la posición concreta de un píxel en memoria es y*320+x. El segmento de memoria donde está
situada la memoria de vídeo VGA es 0A000h.
Sólo se utiliza un byte porque sólo necesitamos 256 valores diferentes para representar todos los colores posibles.
Aunque más abajo (en la sección de “Código de ayuda”) se muestren las líneas en ensamblador necesarias para
pintar un píxel usando acceso directo a memoria de vídeo, veremos a continuación cómo llevar a cabo estos accesos
desde un programa en C y desde un programa ensamblador:
/* se supone que estamos en modo gráfico 13h */
void far *memory_address;
void far *base_address;
base_address = 0xA0000;
memory_address = base_address + ( 320 * Y ) + X;
*(memory_address) = color;
; se supone que estamos en modo gráfico 13h
mov ax,0A000h mov
es,ax mov ax,( 320 *
Y ) + X mov di,ax
mov [es:di], COLOR
Cada valor de un píxel no representa realmente un color, sino el índice en cierta tabla llamada paleta de colores.
Cada entrada en la paleta almacena tres valores (con valores entre 0 y 63) correspondientes a la cantidad de rojo,
verde y azul (RGB). La entrada 0 corresponde al color de fondo de la pantalla.
Aunque sólo podemos mostrar 256 colores en un momento dado en pantalla, los estaremos eligiendo de entre
262144 colores diferentes (643). La paleta podremos modificarla en cualquier momento de la ejecución del
programa, creando efectos en las imágenes.
Paleta de colores RGB
Los colores RGB se basan en la mezcla aditiva de luz: podemos usar el color negro dejando los tres niveles de
intensidad de color a 0. El blanco se puede hacer poniendo los tres niveles al máximo (63). En cualquier caso, si
dejamos los tres niveles iguales, obtendremos un nivel de gris: rojo verde azul Color
0 0 0 Negro
20 20 20 gris oscuro
35 35 35 Gris
50 50 50 gris claro 63
63 63 blanco
Los colores puros (rojo, verde, azul) se obtendrán dejando los otros niveles a 0 y el correspondiente al máximo.
Diferentes niveles se consiguen incrementando este nivel.
Otros modos de vídeo: modos VESA SVGA
Hasta ahora hemos estado trabajando con el modo de pantalla VGA320x200 con 256 colores. Sin embargo,
podemos hacer uso de las resoluciones superiores que tienen nuestras tarjetas de vídeo. Para ello, debemos
inicializar el modo gráfico utilizando alguno de los modos VESA SVGA, por ejemplo:
mov ax,4F02h ; modo VBE (función VESA-BIOS 4F02h)
mov bx,0101h ; 640x 480 256-colores (modo 101h)
int 10h
Otros modos de vídeo disponibles son (el valor a usar se indicará en BX):
Modo de vídeo (resolución) Valor en BX
640x480 256 colores 0101h
800x600 256 colores 0103h
1024x768 256 colores 0105h
640x480 64 Kcolores 0111h
320x200 16 Mcolores 010Fh
640x480 16 Mcolores 0112h
En estos modos de vídeo, la escritura de pixeles en pantalla se realiza de forma similar a como se hace el acceso
directo a memoria de pantalla en 320x200 con 256 colores.
Sólo hay que tener en cuenta la resolución de la pantalla en cada caso. Así:
mov ax, Y ; coord Y
mov bx, 640 ; resolución en horizontal
mul bx ;(640*y)% 0ffffh en AX y (640*y)/0ffffh en DX add
ax, X ; coord X
jnc no_acarreo ; si hubo acarreo, incrementamos DX inc
dx
no_acarreo: mov bx,0a000h ; acceder a memoria de
pantalla a dibujar mov es,bx ; ES -> a000h
mov di,ax ; el offset está calculado en AX mov
ax, COLOR ; color del pixel
mov [es:di],ax
Algoritmos de trazado de líneas rectas División
en punto fijo:
Como la división en punto fijo no permite un cálculo de decimales, debemos recurrir a multiplicar el dividendo por
una cantidad fija conocida (216 = 65536). Con esto se consigue que el cociente mejore su precisión con 16 bits de
resolución. Supongamos que ∆x > ∆y , con lo que el algoritmo (para el octante en el que se representa la línea gruesa)
quedaría:
e = 0 c = ∆y * 65536 /
∆x for i = 1 to ∆x do
begin
plot(x,y)
e = e + c if
ACARREO then y
=y+1 x=x+1
endfor
Si ∆y > ∆x siempre se incrementa y, y x sólo cuando haya acarreo.
Si ∆y = ∆x se incrementan tanto x como y (es una diagonal).
Algoritmo de Bresenham:
Según este algoritmo, en cada iteración sólo una de las coordenadas cambia en ±1. La otra coordenada puede o no
cambiar, dependiendo del valor de un término error mantenido por el algoritmo. Este error almacena la distancia
perpendicular al eje del movimiento mayor. En cada paso, la pendiente de la línea ∆y/∆x es añadida al término error.
Antes de esto, el signo del error es usado para incrementar la coordenada del punto actual.
Un valor positivo del error indica que la línea está situada sobre el punto actual; por tanto, la coordenada es
incrementada y el error se decrementa en 1. Si el error es negativo, la coordenada no cambia. Suponiendo ∆x > ∆y
el algoritmo queda:
e = 2 * ∆y - ∆x for i = 1
to ∆x do begin
plot(x,y) if e > 0 then
begin
y=y+1
e = e + (2 * ∆y – 2 * ∆x)
end else e =
e + 2 * ∆y
x=x+1
endfor
Ecuación de
una recta entre
dos puntos:
La tercera posibilidad es usar la ecuación de una recta, junto con un sencillo bucle para ir calculando cada uno de
los puntos de la recta.
En el caso de rectas completamente horizontales o completamente verticales no es conveniente usarlo, ya que hay
formas mucho más sencillas, pero en cualquier otro tipo de recta sí es adecuado.
La idea es usar esta ecuación: (y-y1)=( (y2-y1)/(x2-x1) )*(x-x1) que se puede simplificar como: y=( (y2-y1)/(x2-x1)
)*(x-x1) + y1 Necesitaremos una serie de variables para ir calculando cada parte de la ecuación:
datos segment 'data'
x1 dw 255 y1 dw 20
x2 dw 100 y2 dw
140 m dw 0 increm
dw 1 datos ends
El código que calcule y dibuje los puntos de la recta debe hacer unas operaciones previas para calcular valores que
son constantes para todos los puntos; se trata de la división ( (y2-y1)/(x2-x1) ) . Después comenzamos desde la
coordenada X de inicio hasta X final (de una unidad en una unidad para hacer una línea continua) aplicando la
ecuación:
mov ax,y2
sub ax,y1 ; numerador de M
mov dx,0 mov bx,32 imul bx
mov bx,x2 sub bx,x1 ;
denominador de M
idiv bx ; M=((y2-y1)*32)/(x2-x1)
mov m,ax mov
ax,x1 cmp
ax,x2 jb seguir
mov increm,-1
seguir: mov
cx,x1 bucle:
mov ax,cx sub
ax,x1 mov
dx,0 mov
bx,m imul bx
mov dx,0
mov bx,32
idiv bx add
ax,y1 ;
cx=X ax=Y
mov dx,ax
pixel cx, dx, 4
; pintar el punto en la coord.
add cx,increm
cmp cx,x2
jnz bucle
Código de ayuda
Cambiar el modo de vídeo a texto o gráfico (320x200 256 colores):
TEXTO EQU 3h
GRAFICO EQU 13h
;cambia el modo de video (modo-texto=3h o modo-grafico=13h)
mov al, MODO mov ah,0 int 10h
Pintar un píxel (usando INT) en cierta coordenada de la pantalla:
;pone un pixel en la coordenada X,Y de color COLOR
mov cx,X mov dx,Y mov al,COLOR mov ah,0Ch int
10h
Pintar un píxel (usando acceso directo) en cierta coordenada de la pantalla:
;pone un pixel en la coordenada X,Y de color COLOR
mov ax,0a000h mov es,ax mov ax,Y mov bx,320
imul bx add ax,X mov bx,ax mov es:[bx],byte ptr
COLOR
Colocar el cursor en la posición (X,Y) de la pantalla de texto:
mov dl, COLUMNA
mov dh, FILA mov
bh, 0 mov ah, 2 int
10h
Generar un número aleatorio y guardarlo en una variable:
Para calcular un número aleatorio se inicializa una semilla leyendo de uno o varios de los tres contadores de 16 bits
de la pastilla 8253, en los puertos 40h, 41h y 42h. Una vez inicializada la semilla se puede calcular el siguiente
número aleatorio según la expresión xn+1 = xn * 65521 + 13
in ax,40h mov
dx,0 mov
bx,65521 mul
bx add ax,13
and ax,01FFh
mov word ptr NUMERO , ax
Lectura de una cadena de texto desde teclado:
mov dx,offset BUFFER mov
bx,dx
mov byte ptr [bx+0] , LONGITUDMAX
mov ah,0Ah int 21h
Lectura de una letra desde teclado:
mov ah,01h int 21h ; el código ASCII de la letra pulsada queda en
el registro AL Mostrar una letra por pantalla: mov dl, LETRA mov
ah, 2 int 21h
Mostrar una cadena de texto por pantalla:
mov dx, offset CADENA
mov ah, 9 int 21h
Lectura de una cadena de texto desde fichero:
mov bx, MANEJADOR mov
dx,offset BUFFER mov cx,10
;cantidad de bytes a leer
mov ah,3Fh int
21h
Apertura y cierre de un fichero:
;abrir un fichero mov
dx,offset NOMBREFICH
mov al,00 ;abrir para lectura
mov ah,3Dh int 21h
mov MANEJADOR,ax
;cerrar el fichero una vez leido
mov bx, MANEJADOR mov
ah,3Eh int 21h
Transformar una cadena en número entero:
mov cx, LONGITUDCAD
mov ax,0 mov di,10 mov
bh,0 mov si,0 bucle: mul di
mov bl,byte ptr CADENA[si]
sub bl,'0' add
ax,bx
inc si
loop bucle mov
NUMERO , ax
Mostrar por
pantalla un
número entero:
;subrutina recursiva ; AX=numero ; BX=base(normalmente 10) escribir_numero
PROC NEAR
push ax push dx
mov dl,al cmp ax,bx
jb escribir_resto sub
dx,dx div bx call
escribir_numero
escribir_resto: add
dl,'0' mov ah,2 int
21h pop dx pop ax
ret
escribir_numero ENDP
Desarrollo: En esta práctica se crea un programa en ensamblador que escribe directamente en la memoria de video
en modo texto. Su propósito es mostrar números del 0 al 9 repetidos en pantalla, cambiando de color en cada ciclo
hasta llegar al color blanco, momento en el cual se detiene.
El programa trabaja directamente con el segmento de video (B800h), lo que permite mostrar caracteres en pantalla
sin usar funciones del sistema operativo. Se usan registros para controlar el carácter y su color, y se escribe en la
pantalla manipulando la memoria de forma manual.
Esta práctica ayuda a comprender cómo está organizada la pantalla en modo texto y cómo se pueden aplicar colores
a los caracteres mediante el manejo directo de la memoria de video.
Conclusión:
Con esta práctica se logró comprender cómo se puede acceder y manipular directamente la memoria de video en
modo texto utilizando ensamblador. Se aprendió a mostrar caracteres con distintos colores y a controlar su
presentación sin depender del sistema operativo. Esto refuerza el conocimiento del funcionamiento interno del
hardware y la memoria, además de fortalecer la lógica en programación de bajo nivel.
