Sesión del Viernes 30 de septiembre

En la sesión de hoy realizaron la Práctica 3: Interrupciones del BIOS, donde aplican e investigan los datos de algunas interrupciones del BIOS.

Sesión del Jueves 29 de Septiembre

En la sesión de hoy seguimos estudiando algunas interrupciones del BIOS. Les escribí en el pizarrón la infomación de varias interrupciones del BIOS e ilustre su uso con un programa que limpia la pantalla usando varias opciones de Int 10:

; Archivo: limppant.asm
; Usa Int 10h,0f para obtener estado actual de video
; Int 10,6 para limpiar la pantala, Int 10h,2 para colocar
; cursor en (0,0)
pp segment stack 'stack'
    db 512 dup (?)
pp ends

cc segment 'code'
    assume ss:pp, cs:cc
Inicio:
    mov ah,06   ; Limpia la pantalla
    mov al,0
    mov bh,07   ; Atributo 0
    mov ch,0    ; Esq Sup Izq = (0,0)
    mov cl,0
    mov dh,24   ; Esq Inf Der= (24,79)
    mov dl,79
    int 10h

    mov ah,0fh  ; Obtiene estado de video
    int 10h

    mov ah,2    ; Coloca cursor
    mov dh,0    ; en (0,0)
    mov dl,0
    int 10h

    mov ax,4c00h    ; Termina
    int 21h
cc ends
    end Inicio

Sesión del Martes 27 de Septiembre

En la sesión de hoy empezamos a estudiar las interrupciones de software, y más específicamente las interrupciones del BIOS. Desde el punto de vista de programación, las interrupciones de software son llamadas a rutinas prefabricadas. Por tanto es necesario contar con la información del fabricante para poder utilizarlas. Les recomiendo la refererencia Help PC para obtener información sobre las interrupciones de software de la PC.

Ejemplo de uso de Interrupciones de BIOS

Para dibujar un punto se puede seguir la siguiente secuencia:

1. Cambiar a modo gráfico
2. Dibujar punto
3. Esperar por cualquier tecla
4. Regresar a modo texto
5. Terminar

Expliqué el siguiente programa que dibuja un punto en el centro de la pantalla siguiendo los pasos arriba mencionados a manera de ejemplo para ilustrar el manejo de las interrupciones:

; Archivo: punto.asm
; Dibuja un punto en el centro de la pantalla
; --------------------------------------------
pila segment stack 'stack'
        db 512 dup(?)
pila ends

prog segment 'code'
assume ss:pila,cs:prog
inicia:
        mov ah,0        ; Prepara Int 10h/0
        mov al,13h      ; Cambia a Modo 320x200, 256 colores
        int 10h

        mov ah,0ch      ; Prepara Int 10h/0ch
        mov dx,100      ; RC(100,160)
        mov cx,160
        mov al,0fh      ; Color = 0fh
        int 10h         ; Dibuja pixel

        mov ah,0        ; Prepara Int 16h/0
        int 16h         ; Espera por cualquier tecla

        mov ah,0        ; Regresa a modo texto 80x25 color
        mov al,3
        int 10h

        mov ax,4c00h    ; Regresa a DOS.
        int 21h
prog    ends
        end inicia

A manera de ejercicio les pedí 2 modificaciones al mismo:

1. Modificar para que espere por la tecla 'q' o 'Q' y entonces continúe su ejecución.
2. Modificarlo para que despliegue una cruz que cruce en el centro de la pantalla.

Sesión del Viernes 23 de Septiembre

En la sesión de hoy realizaron la Práctica 2 Captura, ensamble y ligado de programas en MASM. Como comentamos en clases anteriores, los pasos para la programación en ensamblador son:

1. Captura de programa en un editor de textos.
2. Ensamblar el programa con MASM.
3. Ligar el programa con LINK.
4. Probar la ejecución del programa.

El objetivo de este práctica es conocer el proceso de programación en ensamblador y los comandos utilizados para realizar cada uno de los pasos de este proceso.

Sesión del Jueves 22 de Septiembre

En la breve sesión de esta tarde les expliqué la instrucción
RCL: Rotación a la izquierda con la Bandera de Acarreo (Carry Flag, CF)

Comenté que el manejo de las Entradas y Salidas de la aquitectura de la PC está basado en el código ASCII.

Mostré una parte de la tabla del código ASCII para los dígitos numéricos (0 = 30h, 1 = 31h,..., 9= 39H).

Describí brevemente el funcionamiento de las interrupciones de DOS Int 21h/2 e Int 21h/4ch.

Finalmente expliqué el funcionamiento del siguiente programa que despliga un número en binario, esto es despliega una secuencia de 1's y 0's.

; Archivo: binario.asm
; Despliega un byte en binario
; Utiliza Int 21h/2
pila segment stack 'stack'
    DB 512 dup (?)
pila ends

prog segment 'code'
assume cs:prog,ss:pila
Inicio:
    mov bl,125        ; numero a desplegar
    mov cx,0          ; Limpia el contador
m1: cmp cx,8          ; Mientras (CX < 8)
    jge finm1
    mov ah,2          ;   Prepara despliege de caracter
    mov dl,30h        ;   Caracter = '0'
    rcl bl,1          ;   CF = bit mas significativo de BL
    adc dl,0          ;   Caracter = Caracter + CF
    int 21h           ;   Despliega caracter
    inc cx            ;   Actualiza Contador
    jmp m1            ; Fin_mientras
finm1:
    mov ax,4c00h      ; Llama a DOS para terminar el programa
    int 21h
prog ends
    end Inicio

Sesión del Martes 20 de Septiembre

En la sesión de hoy vimos una introducción al MacroAssembler de Microsoft.

Vimos que todo programa en ensamblador tiene 3 bloques:

• Segmento o sección de pila.
• Segmento o sección de datos, y
• Segmento o sección de código.

Donde los bloques de pila y datos son opcionales.

También vimos que todo programa está compuesto de:

• instrucciones,
• directivas o pseudoinstrucciones, y
• objetos (que pueden ser constantes, variables y etiquetas)

Posteriormente presenté y expliqué el siguiente programa ejemplo:

; hola.asm
; Despliega una cadena en pantalla
Pila segment stack 'stack'
  db 512 dup(?)         ; Reserva 512 bytes para la pila
Pila ends

Datos segment 'data'
msje db "Hola Mundo desde MacroAssembler!!!",10,13,"$"
Datos ends

Prog segment 'code'
assume cs:Prog, ds:Datos, ss:Pila
Inicio:
        mov ax,Datos    ; Inicializa DS
        mov ds,ax
        mov ah,9                ; Utilizamos DOS
        mov dx, offset msje     ; Para desplegar una cadena
        int 21h

        mov ax,4c00h            ; Utilizamos DOS para
        int 21h                 ; terminar el programa
Prog    ends
        end Inicio

Finalmente hablé del procedimiento de programación en ensamblador:

• Capturar programa en un editor de texto
• Ensambladr el código fuente (traducir a lenguaje máquina)
• Ligar para generar el ejecutable

Para reforzar estos temas les recomiendo esta referencia y también esta otra referencia.

Sesión del Viernes 9 de Septiembre

En la sesión de hoy realizaron la práctica 1
que trata sobre la conversión de ensamblador a lenguaje máquina, tanto de instrucciones sueltas como de un par de programas con instrucciones de control de flujo (loop y saltos condicionales e incondicionales).

Sesión del Jueves 8 de Septiembre

En la sesión de hoy les presenté la conversión de un programa en lenguaje ensamblador a lenguaje máquina.

Pueden consultar estos apuntes de la sesión

Sesión del Martes 6 de septiembre

En la sesión de hoy empezamos a estudiar la conversión de ensamblador a lenguaje máquina. Para esto usamos esta guía, que también está direccionada en la página del curso.
Realizaron por equipos el Ejercicio 3:

Ejercicio 3.
Convierte a lenguaje máquina las siguientes instrucciones en ensamblador:
     1. or ax,cx
     2. add cx,cx
     3. mul bl
     4. mul cx
     5. div bx
     6. mov ch,[bx+5]

Sesión del Viernes 2 de septiembre

En la sesión de hoy conocimos el programa debug. Este programa nos permite:

• Introducir instrucciones en lenguaje máquina
• Introducir programas en un ensamblador básico
• Trazar programas
• Desplegar el contenido de la memoria, entre otras funciones.

Quedó como ejercicio realizar la división que está al final de la presentación y capturar el programa que quedó como ejercicio en una clase anterior (un programa que calcula la raíz cuadrada aproximada por el método de restas succesivas).

Para esta clase me apoyé en esta presentación. Para conocer mejor el debug les recomiento este tutorial.

Sesión del Jueves 1 de Septiembre

En la sesión de hoy les presenté las soluciones para los ejercicios de aplicación del conjunto de instrucciones de los procesadores Intel x86. Estas propuestas de solución son las siguentes:

 Solución Problema 1
        mov ax,1000
        mov bx,40h
        mov es,bx
        rep1:                      ; Repite
                dec ax
                mov cx,[es:17h]
                bt cx,3            ; Hasta (Bit 3 de CX = 1)
                jc Fin
                cmp ax,0           ; OR (AX = 0)
                jne rep1
        Fin:

 Solución Problema 2
        mov ax,1000
        mov bx,40h
        mov es,bx
        rep1:                       ; Repite
                dec ax
                mov cx,[es:17h]
                bt cx,3             ; Hasta (Bit 3 de CX = 1)
                jnc rep1
                cmp ax,0            ; AND (AX = 0)
                je rep1
        Fin:

 Solución Problema 3
        mov bx,40h
        mov es,bx
        mov bx,[es:08]
        cmp bx,0                    ; Si (BX = 0)
        je Fin                      ;   jmp Fin
        inc bx                      ; Sino inc bx
   m1:                              ; Mientras (Bit 1 de [es:bx]=1
        bt [es:bx],1
        jnc Fin
        jmp m1                      ; Fin Mientras
        mov ax,1                    ; AX = 1

 Solución Problema 4
        mov bx,0b800h
        mov es,bx
        mov di,0
        mov al,"a"
   rep1:                            ; repite
        mov [es:di],al
        add di,2
        inc al
        cmp al,"z"                  ; Hasta (AL > "z")
        jle rep1

Posteriormente comentamos algunos ejemplos del manejo en bajo nivel de operaciones aritméticas como las siguientes:

i)     ax = 10
       bx = 15
       cx = ax * bx

ii)    bx = 100
       cx = 452
       dx = 109
       ax = bx + cx + dx

Las dificultades que nos presentan estas operaciones se deben al hecho de que las operaciones que nos proponen (cx = ax * bx y ax = bx + cx + dx) son instrucciones muy adecuadas para máquinas con instrucciones de 3 direcciones, pero los procesadores Intel tienen mayormente instrucciones con 2 direcciones, por lo que uno de los operandos es a la vez operando y destino, y en los pseudocódigos anteriores tanto en la multiplicación como en la suma, el destino es distinto a los operandos. Además, se debe cumplir que los operandos a la derecha del signo "=" no deben alterarse.