ACTIVIDAD #11

Directiva MACRO

    Esta directiva resulta muy potente y a diferencia de la directiva #define se pueden crear macros más extensas, lo que nos evitará tener que ejecutar reiteradamente fragmentos de código idénticos. Cuando una macro es invocada, esta es copiada por el ensamblador en el lugar de la invocación dentro del código fuente. La macro se declara con la directiva MACRO, y termina con la directiva ENDM.

    Creación de una macro denominada activar:

    activar macro

    CLRF PORTA

    BSF PORTB,2

    endm

   

Internas.

Para definir una macro, se utiliza la directiva MACRO. El formato de esta directiva es :

(nombre_de_macro) MACRO (lista_parámetros)

Una macro consta de tres partes esenciales:

a) CABECERA: Contiene el nombre de la macro, la pseudo-op MACRO y opcionalmente, variables ficticias que serán pasadas desde la macro.

b) CUERPO: Contiene el código real que será insertado en cualquier programa que llame al nombre de la macro.

c) FIN: Debe incluir la sentencia ENDM.

Ejemplo de una macro sencilla:

    INICIO   MACRO           ; Define macro

             MOV AX, DATA    ; cuerpo de  

             MOV DS, AX      ; la definición

             MOV ES, AX      ; de la macro

    ENDM 

Internas.

Una macro interna es aquella que se declara y se llaman dentro del mismo programa.

Externas o Bibliotecas de Macros.

Una de las facilidades que ofrece el uso de las macros es la creación de bibliotecas, las cuales son grupos de macros que pueden ser incluidas en un programa desde un archivo diferente.

La creación de estas bibliotecas es muy sencilla, unicamente tenemos que escribir un archivo con todas las macros que se necesitarán y guardarlo como archivo de texto.

Para llamar a estas macros solo es necesario utilizar la instrucción Include NombreDelArchivo, en la parte de nuestro programa donde escribiriamos normalmente las macros, esto es, al principio de nuestro programa (antes de la declaración del modelo de memoria).

Suponiendo que se guardó el archivo de las macros con el nombre de MACROS.TXT la instrucción Include se utilizaría de la siguiente forma:

;Inicio del programa 
Include MACROS.TXT 
.MODEL SMALL 
.DATA 
;Aqui van los datos 
.CODE 
Inicio: 
;Aqui se inserta el código del programa 
.STACK 
;Se define la pila 
End Inicio 
;Termina nuestro programa

Ejemplos de macros

; ************************************************************

; macros.asm ;

; "MACROS para 16F84" ;

; ************************************************************

callz   macro  subbrutina

        btfsc  STATUS,Z

        call   subrutina

        endm

       

callnz  macro  subrutina

        btfss  STATUS,Z

        call   subrutina

        endm

movff   macro  f2,f1  ;(atención, se destruye W)

        movf   f1,w

        movwf  f2

        endm

movlf   macro  file,literal  ;(atención, se destruye W)

        movlw  literal

        movwf  file

        endm

;Atención, para usar estas macros ya debe estar activo el banco 1

CONF_PORTA  macro  dato

            movlw  dato

            movwf  TRISA

            endm

CONF_PORTB  macro  dato

            movlw  dato

            movwf  TRISB

            endm

;configurar Option Register:

CONF_OPTION macro  dato

            movlw  dato

            movwf  OPTION_REG

            endm

;configurar el registro de interrupciones:

CONF_INTCON macro  dato

            movlw  dato

            movwf  INTCON

            endm

SET_BANK_0  macro

            BCF    STATUS,RP0

            endm

SET_BANK_1  macro

            BSF    STATUS,RP0

            endm

;enable y disable all the mascarable interrupts (16F84):

EI          macro

            bsf    INTCON,GIE

            endm

DI          macro

            bcf    INTCON,GIE

            endm

#define  iEnable   EI

#define  iDisable  DI

;arrancar el timer:

RESET_TIMER macro

            bcf    INTCON,T0IF

            endm

; inicializar timer antes de hacer RESET_TIMER para que arranque.

INIT_TIMER  macro   dato

            movlw   dato

            movwf   TMR0

            endm

jmp         macro   salto

            goto    salto

            endm

ret         macro

            return

            endm

;Complemento a 1 de W:

comw        macro

            xorlw   0xff

            endm

;Instrucciones de salto tipo Z80

jz      macro  _salto  ;salta si zero

        btfsc  STATUS,Z

        goto   _salto

        endm

jnz     macro  _salto  ;salta si no zero

        btfss  STATUS,Z

        goto   _salto

        endm

jc      macro  _salto  ;salta si carry

        btfsc  STATUS,C

        goto   _salto

        endm

jnc     macro  _salto  ;salta si no carry

        btfss  STATUS,C

        goto   _salto

        endm

; ************************************************************

;       FIN

; ************************************************************

PROCEDIMIENTOS

Un procedimiento es un conjunto de instrucciones que tienen la finalidad de ejecutar una tarea específica dentro de un programa. Los procedimientos son muy similares a las macros.

Un procedimiento se declara una sola vez en el código fuente y cuando el programa se ensambla y ejecuta, el procedimiento se coloca en memoria para que pueda ser utilizado por el programa.

Las principales ventajas en el uso de procedimientos son:

• Permiten una codificación más limpia y compacta.
• Código fuente es más pequeño.
• Permiten el ahorro de memoria, esto es porque un mismo procedimiento puede ser llamado varias veces en el mismo programa y s&olo requiere memoria una vez.

;

A continuación se describen los pasos necesarios para la ejecución de un procedimiento:

• 1. Se encuentra la llamada Call.
• 2. El microprocesador almacena en la Pila el contenido del IP.
• 3. Se coloca en el IP el valor del desplazamiento correspondiente al Procedimiento.
• 4. El microprocesador ejecuta las instrucciones del procedimiento.
• 5. El procedimiento termina cuando se encuentra con la instrucción Ret.
• 6. Se saca de la Pila el valor original del IP y se continua el flujo del programa

Los procedimientos no nos permiten el paso de parámetros, pero podemos hacer uso de"parámetros falsos" empleando los registros de propósito general antes de que el procedimeinto sea llamado.

El siguiente procedimiento coloca el cursor en las coordenadas establecidas en DI y DH:

Procedimientos externos.

Los procedimientos externos, a diferencia de los internos, se declaran en módulos o programas separados al programa donde el procedimiento es llamado, en otras palabras, la llamada al procedimiento se encuentra en un programa y el procedimiento en otro.

Para poder utilizar procedimientos externos, es necesario que sean declarados como públicos en el programa donde se encuentran y que sean llamados como externos en el programa donde serán usados. Se debe contar con tres directivas de ensamble: .PUBLIC para declarar los procedimientos como públicos, .EXTERN para indicar que el procedimiento que se va a usar está fuera del programa y .INCLUDE para enlazar el programa que contiene los procedimientos con el programa que los llama.

PUBLIC  PROC1               ; Se define como público
PROC1   PROC    FAR     ; comienzo del procedimiento (lejano)
                (instrucciones)    ; Instrucciones del procedimiento
                RET                     ;Instrucción para retornar
PROC1   ENDP                 ; Final del procedimiento

Para llamar a un procedimiento se utiliza la instrucción CALL:

CALL nombre_procedimiento

Por ejemplo Este programa muestra la forma de utilizar procedimientos y datos externos en los programas por medio de las directivas de inclusión include y public.

.MODEL TINY
.INCLUDE proc2.ASM ;Incluir el archivo proc2.asm
;el cual contiene la variable de cadena
;Cad1 y los procedimientos externos
;usados en este programa.
.DATA
Cad2 db 'Esta es una cadena de prueba 2...',13,10,'$'
.CODE
INICIO: ;Punto de entrada al programa
Mov Dl,20 ;X=20
Mov Dh,10 ;Y=10
Call GotoXY ;GotoXY 20,10
Lea DX,Cad2 ;DX->Cad2 en Proc3.asm
Call Imprime_Cad ;Imprime Cad2
Lea DX,Cad1 ;DX->Cad1 en Proc2.asm
Call Imprime_Cad ;Imprime Cad1
Mov AX,04C00h ;Fin del programa
Int 21h ;
END INICIO
END

Procedimientos internos.

Los procedimientos internos son aquellos que se declaran y semismo programa, también son llamados procedimientos locales. Un ejemplo de procedimiento interno es el siguiente:

;Procedimiento: GotoXY
;Descripción: Coloca el cursor una posición especifica de la pantalla
;Parámetros: Dl=X,Dh=Y
;**********************************************************************
PROC GotoXY
xor bh,bh
mov ah,02h
int 10h
ret
endp GotoXY