Numero Binario de 8 bits a BCD mediante el algoritmo Recorre y Suma+3

En la entrada anterior se encuentra una rutina para convertir un numero Binario de 8 bits a BCD empleando un metodo de division po restas sucesivas. En esta ocasion presento una rutina para lograr la misma conversion de Binario a BCD empleando el algoritmo Recorre y Suma+3.

El algoritmo funciona de la siguiente manera:

• Recorre 1 bit a la izquierda el numero binario.
• Si se han hecho 8 corrimientos, el numero BCD se encuentra en las columnas CENTENAS, DECENAS y UNIDADES.
• Si el valor binario de cualquiera de las columnas BCD es 5 o mayor, se suma 3 al valor en esta columna BCD.
• Si se desea convertir un byte despues de haber efectuado 8 corrimientos la conversion ha finalizado, para 2 bytes se necesitarian 16 y asi sucesivamente.

Es un metodo muy facil de entender y aplicar. Utilizando este algoritmo la rutina que permite convertir un numero binario de 8 bits a BCD es la siguiente:

BIN2BCD_RS3
        clrf     BCDH
        clrf     BCDL

        movlw    0x08
        movwf    CUENTA

CONVERSION1
        bcf      STATUS,C
        rlf      BIN,f
        rlf      BCDL,f
        decfsz   CUENTA,f
        goto     $+2
        goto     TERMINA_CONVERSION
        movlw    b'00001111'
        andwf    BCDL,w
        movwf    BCD_TEMP
        movlw    0x05
        subwf    BCD_TEMP,w
        btfsc    STATUS,C
        call     SUMA0x03
        movlw    b'11110000'
        andwf    BCDL,w
        movwf    BCD_TEMP
        movlw    0x50
        subwf    BCD_TEMP,w
        btfsc    STATUS,C
        call     SUMA0x30
        goto     CONVERSION1

TERMINA_CONVERSION
        return 

Al igual que la rutina anterior, antes de llamar a esta rutina de conversion es necesario tener almacenado el numero que se desea convertir en la variable BIN. Al finalizar la rutina el numero BCD estara almacenado en las variables BCDH y BCDL. El nibble bajo de BCDH tendra almacenadas las CENTENAS, el nibble alto de BCDL las DECENAS y el nibble bajo de BCDL las UNIDADES.

De nuevo hay que tener en cuenta que al realizar la conversion el numero que se tenia en un principio en la variable BIN es destruido, asi que se debe tener un respaldo de su valor en otro registro si se desea seguir trabajando con el.

Las rutinas SUMA0×03 Y SUMA0×30 simplemente se encargan de sumar 3 a la columna BCD que lo necesite. Estas rutinas se encuentran en el codigo de la rutina.

Descargar codigo: Conversion numero Binario de 8 bits a BCD – Recorre y Suma+3

Convertir un numero Binario de 8 bits a BCD

El Codigo binario decimal (BCD) es un codigo para numeros decimales en el que cada digito es representado por su propia secuencia binaria. Su principal ventaja es que permite una conversion facil a digitos decimales para su despliegue y permite tambien realizar calculos decimales mas rapidos.

Aqui se presenta una rutina para convertir un numero binario a BCD, precisamente un numero de 8 bits (1 byte) a su equivalente BCD. El valor maximo de un byte es 0xFF = 255, asi que al convertir un numero binario de 8 bits se obtienen 3 digitos BCD.

Esta rutina convierte el numero binario a su equivalente BCD empaquetado. El resultado de la conversion del numero binario a BCD ocupa un byte y medio y se representa en las variables de memoria BCDH y BCDL. El numero binario a convertir debe estar almacenado en la variable BIN.

ej. 0xFF = 255
 BIN -> BCDH:BCDL
  FF     02   55

La conversion se hace realizando divisiones mediante restas sucesivas. Primero entre 100 para obtener el nibble bajo de BCDH y despues entre 10 para obtener el nibble alto de BCDL y el residuo pasa a formar el nibble bajo de BCDL.

El codigo de la rutina es el siguiente:

BIN8_BCD3
        clrf    BCDH
        clrf    BCDL
BCD_HIGH
        movlw   .100
        subwf   BIN,f
        btfss   STATUS,C
        goto    SUMA_100
        incf    BCDH,f
        goto    BCD_HIGH
SUMA_100
        movlw   .100
        addwf   BIN,f
        movlw   0x0F
        movwf   BCDL
BCD_LOW movlw   .10
        subwf   BIN,f
        btfss   STATUS,C
        goto    SUMA_10
        incf    BCDL
        movlw   0x0F
        iorwf   BCDL
        goto    BCD_LOW
SUMA_10 movlw   .10
        addwf   BIN,f
        movlw   0xF0
        andwf   BCDL,f
        movf    BIN,w
        iorwf   BCDL,f

        return

Antes de llamar a la rutina de conversion es necesario tener almacenado el numero que se desea convertir en la variable BIN. Al finalizar la rutina el numero BCD estara almacenado en las variables BCDH y BCDL. BCDH tendra el numero BCD mas significativo mientras que en BCDL se encontraran los dos numeros restantes, siendo el nibble alto de BCDL el mas significativo de los dos y el nibble bajo de BCDL el menos significativo.

De este modo se logra convertir un numero binario de 8 bits a su equivalente BCD. Solamente hay que tener en cuenta que al realizar la conversion el numero que se tenia en un principio en la variable BIN es destruido, asi que se debe tener un respaldo de su valor en otro registro si se desea seguir trabajando con el.

Descargar codigo: Conversion numero Binario de 8 bits a BCD

Un teclado matricial es un simple arreglo de botones conectados en filas y colúmnas, de modo que se pueden leer varios botones con el mínimo número de pines requeridos. Un teclado matricial 4×4 solamente ocupa 4 lineas de un puerto para las filas y otras 4 lineas para las colúmnas, de este modo se pueden leer 16 teclas utilizando solamente 8 líneas de un microcontrolador. Si asumimos que todas las columnas y filas inicialmente están en alto (1 lógico), la pulsación de un botón se puede detectar al poner cada fila a en bajo (0 lógico) y checar cada columna en busca de un cero, si ninguna columna está en bajo entonces el 0 de las filas se recorre hacia la siguiente y así secuencialmente.

Un modo simple de detectar la tecla presionada es incrementar una variable con la cuenta de las teclas revisadas, de este modo al detectaruna pulsación el valor de la cuenta será el valor de la tecla presionada. Si al final no se presionó ninguna tecla la variable se pone a cero y la cuenta vuelve a comenzar. El puerto B del microcontrolador 16f628 (así como en el 16f877) viene preparado especialmente para el control de un teclado matricial 4×4. Para tener siempre un valor de 1 lógico en las colúmnas del teclado (parte alta del puerto B del pic) es necesario conectar resistencias de pull-up, sin embargo el puerto B cuenta con resistencias de pull-up integradas, de ese modo es posible trabajar con un teclado matricial sin necesidad de ningún componente externo.

Las resistencias de pull-up del puerto B se habilitan poniendo en 0 el bit NOT_RBPU del registro OPTION_REG.Al método aqui expuesto para detectar la pulsación de una tecla en un teclado matricial se le conoce como muestreo secuencial. Existen otros, sin embargo esté es tal vez el más sencillo. En el siguiente ejemplo cada tecla del teclado matricial tiene un valor de 0 a F, valor que se despliega en un display de 7 segmentos. El el código necesario para leer un teclado matricial con un microcontrolador pic 16f628 es el siguiente.

Programa principal:

El programa principal es muy sencillo, simplemente configura el puerto A como salida, la parte baja del puerto B también como salida y la parte alta del puerto B como entrada. Además de configurar los puertos también se habilitan las resistencias de pull-up internas con la línea bcf OPTION_REG,NOT_RBPU. Después de la configuración se llama a una rutina llamada TECLADO encargada de escanear el teclado y regresar el valor de la tecla pulsada para poder desplegar el número correspondiente en un display de 7 segmentos y el programa ahí se queda en un ciclo llamando a la rutina TECLADO y después desplegando y repitiendo lo mismo cíclicamente.La rutina TECLADO escanea el teclado matricial usando el método que ya se mencionó.

Primero se carga un 0 a la primer fila, después se checa columna a columna si hay un cero, en caso de que no se detecte ningún cero, el cero de las filas se recorre y se vuelven a revisar las columnas. Si no se detectó ningún cero significa que no se presionó ninguna tecla y la rutina vuelve a comenzar. Si se detectó un cero significa que se presionó una tecla y en ese momento la salta a la rutina ANTIRREBOTES. Después de eliminar los rebotes se decodifica la tecla pulsada utilizando una tabla como la que se utilizó en el ejemplo del display de 7 segmentos.

Existen otros métodos de manejar teclados matriciales, pero creo que ésta es la más sencilla. Para terminar una imágen del circuito:

Descargar el código: Teclado Matricial 4×4.

Como ya hemos visto, para que el microcontrolador lleve acabo una tarea, debemos indicarle exactamente que debe hacer, o en otras palabras, debemos escribir el programa que el micro ejecutara. Ya hemos visto varios ejemplos y muchas de las instrucciones del pic, pero ahora veremos las 35 instrucciones del ensamblador mpasm. Estas 35 instrucciones son las mismas para toda la gama media de los microcontroladores pic asi que si mas adelante se quiere realizar un programa para un pic 16F877 se usaran las mismas instrucciones.

Antes de continuar es necesario definir algunos terminos que se usaran para explicar las instrucciones:
f: cualquier registro del microcontrolador
W: registro de trabajo
b: posicion de un bit en el registro ‘f’
d: destino, puede ser ‘f’ (d=1) o ‘W’ (d=0)
etiqueta: grupo de caracteres que marcan el inicio de una parte del programa
[]: opcional
: posicion de un bit dentro de un registro

Instrucciones orientadas a registros

ADDWF: Suma W y f
Suma el contenido del registro ‘W’ y el registro ‘f’. Si “d” es 0, el resultado se almacena en el registro W. Si ‘d’ es 1 el resutado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] ADDWF f,d
Operación: (W) + (f) –> (destino)
Flags afectados: C, DC, Z
Ejemplo: ADDWF REG,1
Antes de la instrucción: W=0×03, REG=0×04
Después de la instrucción: W=0×03, REG=0×07

ANDWF: W AND f
Realiza la operación lógica AND entre el registro W y el registro “f”. Si “d” es 0 el resultado se almacena en el registro W. Si “d” es 1, el resultado se almacena en el registro “f”.
Sintaxis: [etiqueta] ANDWF f,d
Operación: (W) AND (f) –> (destino)
Flags afectados: Z
Ejemplo: ANDWF REG,1
Antes de la instrucción: W=0×17, REG= 0xC2
Después de la instrucción: W=0×17, REG= 0×02

CLRF: Borra un registro
Borra el contenido del registro ‘f’ y se activa el flag Z.
Sintaxis: [etiqueta] CLRF f
Flags afectados: Z
Ejemplo: CLRF REG
Antes de la instrucción: REG=0×54
Después de la instrucción: REG=0×00, Z=1

CLRW: Borra el registro de trabajo W
Borra el contenido del registro ‘W’ y se activa el flag Z. Esta instruccion no tiene operandos.
Sintaxis: [etiqueta] CLRW
Flags afectados: Z
Ejemplo: CLRW
Antes de la instrucción: W=0×54
Después de la instrucción: W=0×00, Z=1

COMF: Complementa el registro f
El contenido del registro ‘f’ se complementa. Si d=0 el resultado se almacena en el registro W. Si d=1 el resultado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] COMF f,d
Flags afectados: Z
Ejemplo: COMF REG,0
Antes de la instruccion: REG=0×13
Después de la instrucción: REG=0×13, W=0xEC

DECF: Decrementa f en 1
De decrementa en uno el contenido del registro ‘f’. Si d=0, el resultado se almacena en W. Si d=1, el resultado se almacena en ‘f’.
Sintaxis: [etiqueta] DECF f,d
Flags afectados: Z
Ejemplo: DEC CONT, 1
Antes de la instrucción: CONT=0×01, Z=0
Después de la instrucción: CONT=0×00, Z=1

DECFSZ: Decrementa en 1 y salta si el resultado es 0
El contenido del registro ‘f’ se decrementa. Si ‘d=0, el resultado se coloca en el registro W. Si d=1, el resultado se coloca en el registro ‘f’. Si el resultado es 0, se salta la siguiente instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] DECFSZ f,d
Flags afectados: Ninguno

INCF: Incrementa el registro f
Incrementa en uno el contenido del registro ‘f’. Si d=0, el resultado se almacena en W. Si d=1, el resultado se almacena en ‘f’.
Sintaxis: [label] INCF f,d
Flags afectados: Z
Ejemplo: INCF CONT,1
Antes de la instrucción: CONT=0xFF, Z=0
Después de la instrucción: CONT=0×00, Z=1

INCFSZ: Incrementa en 1 y salta si el resultado es 0
El contenido del registro ‘f’ se incrementa. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado se coloca en el registro ‘f’. Si el resultado es 0, se salta la siguiente instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] DECFSZ f,d
Flags afectados: Ninguno

IORWF: W OR f
Realiza la operación lógica OR entre el registro W y el registro ‘f’. Si d=0 el resultado se almacena en el registro W. Si d=1, el resultado se almacen en el registro ‘f’.
Sintaxis: [etiqueta] IORWF f,d
Flags afectados: Z
Ejemplo: IORWF REG,0
Antes de la instrucción: REG=0×13, W=0×91
Después de la instrucción: REG=0×13, W=0×93

MOVF: Mover el registro f
El contenido del registro ‘f’ se mueve al destino ‘d’. Si d=0, el destino es el registro W. Si d=1, el destino es el propio registro ‘f’.
Sintaxis: [etiqueta] MOVF f,d
Flags afectados: Z
Ejemplo: MOVF REG,0
Después de la instrucción: W=REG

RLF: Rota el registro f a la izquierda
El contenido del registro ‘f’ se rota una posición a la izquierda. El bit de más peso pasa al carry y el carry se introduce por el bit de menos peso de ‘f’. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’.
Sintaxis: [etiqueta] RLF f,d
Flags afectados: C
Ejemplo: RLF REG,1
Antes de la instrucción: REG=b’11100110′, C=0
Después de la instrucción: REG=b’11001100′, C=1

RRF: Rota el registro f a la derecha
El contenido del registro ‘f’ se rota una posición a la derecha. El bit de menos peso pasa al carry y el carry se introduce por el bit de más peso de ‘f’. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’.
Sintaxis: [etiqueta] RLF f,d
Flags afectados: C
Ejemplo: RLF REG,1
Antes de la instrucción: REG=b’11100110′, C=0
Después de la instrucción: REG=b’01110011′, C=0

SUBWF: Resta f – W
Resta el contenido del registro ‘f’ menos el contenido del registro W. Si d=0, el resultado se almacena en el registro W. Si d=1, el resultado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] SUBWF f,d
Flags afectados: C, DC, Z
Ejemplo: SUBWF REG,1
Antes de la instrucción: REG=0×01, W=0×02
Después de la instrucción: REG=0xFF, W=0×02

SWAPF: Intercambio de f
El nibble bajo del registro ‘f’ se intercambia con el nibble alto del mismo. Si d=0, el resultado se coloca en el registro W. Si d=1, el resultado queda en el registro ‘f’.
Sintaxis: [etiqueta] SWAPF f,d
Flags afectados: Ninguno
Ejemplo: SWAPF REG,1
Antes de la instrucción: REG=0×54
Después de la instrucción: REG=0×45

XORWF: W XOR f
Realiza la función lógica OR exclusiva entre el contenido del registro W y el registro ‘f’. Si d=0, el resultado se almacena en el registro W. Si d=1 el resultado se almacena en el registro ‘f’.
Sintaxis: [etiqueta] XORWF f,d
Flags afectados: Z
Ejemplo: XORWF REG,1
Antes de la instrucción: REG=0xAF, W=0xB5
Después de la instrucción: REG=0×1A, W=0xB5

NOP: No operacion
No realiza ninguna operacion, solo consume un ciclo de reloj
Sintaxis: [etiqueta] NOP

Instrucciones orientadas a bits

BCF: Borra un bit
Borra el bit ‘b’del registro ‘f’
Sintaxis: [etiqueta] BCF f,b
Ejemplo: BCF REG,0
Antes de la instrucción: REG=b’01101101′
Después de la instrucción: REG=b’01101100′

BSF: Activa un bit
Activa el bit ‘b’ del registro ‘f’
Sintaxis: [etiqueta] BSF f,b
Ejemplo: BSF REG,2
Antes de la instrucción: REG=b’01001001′
Después de la instrucción: REG=b’01001011′

BTFSC: Checa un bit y salta si es 0
Si el bit “b” del registro “f” es 0, se salta una instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] BTFSC f,b

BTFSS: Checa un bit y salta si es 1
Si el bit “b” del registro “f” es 1, se salta una instrucción y se continúa con la ejecución.
Sintaxis: [etiqueta] BTFSS f,b

Instrucciones orientadas a constantes y de control

ANDLW: W AND literal
Realiza la operación lógica AND entre el registro W y la constante “k”. El resultado se almacena en el registro W.
Sintaxis: [label] ANDWL k
Flags afectados: Z
Ejemplo: ANDLW 0×5F
Antes de la instrucción: W=0xA3
Después de la instrucción: W=0×03

CALL: Llamada a subrutina
Llamada y salto a subrutina. La dirección de retorno se guarda en el stack. La constante “k” de 8 bits forma la dirección de salto y se carga en los bits del PC. Los bits del PC se cargan con los bits del registro “STATUS”. PC se pone a 0.
Sintaxis: [etiqueta] CALL k
Ejemplo: INICIO CALL DESTINO
Antes de la instrucción: PC=INICIO
Después de la instrucción: PC=DESTINO

CLRWDT: Borra el watchdog timer
Esta instrucción borra tanto el “watchdog” como el prescaler. Los bits TO y PD del registro de estado se ponen a “1″.
Sintaxis: [label] CLRWDT
Flags afectados: TO, PD

GOTO: Salto incondicional
Se trata de un salto incondicional. Los 9 bits de la constante “k” que forman la instrucción, se cargan en los bits del PC y forman la dirección de salto. Los bits del PC se cargan con los bits del registro de estado.
Sintaxis: [etiqueta] GOTO k
Ejemplo: INICIO GOTO DESTINO
Antes de la instrucción: PC=0
Después de la instrucción: PC=DESTINO

IORLW: W OR literal
Se realiza la función lógica OR entre el registro W y la contante “k”. El resultado se almacena en el registro W.
Sintaxis: [etiqueta] IORLW k
Flags afectados: Z
Ejemplo: IORLW Ox35
Antes de la instrucción: W=0×9A
Después de la instrucción: W=0xBF

MOVLW: Carga un literal en W
El registro W se carga con el valor de 8 bits expresado mediante la literal “k”.
Sintaxis: [etiqueta] MOVLW k
Ejemplo: MOVLW 0×5A
Después de la instrucción: W=0×5A

RETURN: Regresa de una subrutina
El programa regresa de la subrutina y ejecuta la instruccion que sigue a CALL
Sintaxis: [etiqueta] RETURN

RETLW: Regresa de una subrutina y carga el valor K en W
El programa regresa de la subrutina y carga el valor de 8 bits del registro k en el registro W
Sintaxis: [etiqueta] RETLW,k
Ejemplo: RETLW,0×45
Antes de la instruccion: W=xx
Despues de la instruccion: W=0×45

RETFIE: Regresa de la rutina de servicio
Sintaxis: [etiqueta] RETFIE

SLEEP: Entra en estado de reposo
Al salir, activa el bit de estado TO y borra el PD. El WDT y el prescaler se borran.Al entrar en el modo SLEEP, se detiene el oscilador.
Sintaxis: [etiqueta] SLEEP
Flags afectados: TO, PD, GPWUF

XORLW: W XOR literal
Realiza la función lógica OR exclusiva entre el contenido del registro W y la constante “k” de 8 bits. El resultado se almacena en el registro W.
Sintaxis: [etiqueta] XORLW k
Flags afectados: Z
Ejemplo: XORLW 0xAF
Antes de la instrucción: W = 0xB5
Después de la instrucción: W = 0×1A

SUBLW: Resta L – W
A una constante “k” de 8 bits se le resta el registro W. El resultado es guardado en el mismo registro W.
Sintaxis: [etiqueta] SUBLW k
Flags afectados: C,DC,Z

Y estas son las 35 instrucciones que podemos utilizar para programar los microcontroladores PIC. La razon para que solo se utilicen 35 instrucciones en la programacion es que los PIC son microcontroladores RISC, y estas instrucciones estan bien optimizadas para tener una mayor velocidad de trabajo, una arquitectura mas simple y un codigo mas compacto.

El ensamblador que utiliza MPLAB por defecto y el que utilizaremos para programar los PIC es MPASM. Los elementos básicos del lenguaje ensamblador son:

• Etiquetas
• Instrucciones
• Operandos
• Directivas
• Comentarios

Para la programación se utiliza una cierta tabulación que se debe respetar, además utilizar una tabulación adecuada hace los programas más claros y legibles. Las etiquetas se escriben en la primer columna de cualquier línea, las instrucciones y directivas en la segunda y por último, en la tercer columna, los operandos. Los comentarios se pueden escribir en cualquier parte del programa.

Etiquetas

Una etiqueta es una palabra utilizada para designar alguna línea o sección del programa, se pueden utilizar para saltar de una parte hacia esa etiqueta. Es importante que las etiquetas empiecen con una letra o con un guión bajo “_”. La longitud de una etiqueta puede ser de hasta 32 caracteres y como ya se dijo se deben escribir en la primer colúmna.

Instrucciones

Las instrucciones son las operaciones que realiza el microcontrolador, así que estas ya estan definidas para cada familia de PIC. El 16F628a así como todos los PICs de gama media utiliza un conjunto de 35 instrucciones que están definidas en la hoja de datos del PIC.

Operandos

Son los elementos que emplea la instrucción que se está ejecutando. Usualmente los operandos son los registros, las variables o las constantes.

Directivas

Las directivas son similares a las instrucciones, pero a diferencia de estas las directivas son propias del lenguaje ensamblador e independientes del microcontrolador que se utilice. Las directivas representan algunas  características del lenguaje ensamblador, se utilizan para especificar el procesador empleado así como la configuración de este, también para asignar locaciones de memoria, entre otras cosas.

Comentarios

Los comentarios son las palabras, frases y oraciones que se pueden escribir en el código para hacer el programa más claro y legible, o solo para recordar el momento =P. Los comentarios se pueden escribir en cualquier parte del código pero siempre deben empezar con punto y coma ”;”.

Un programa de prueba

El siguiente ejemplo es un programa simple escrito en ensamblador donde se muestran los elementos básicos del lenguaje:

Este ejemplo se escribió usando MPLAB, se puede ver que MPLAB reconoce la sintaxis del lenguaje ensamblador y utiliza diferentes colores para los diferentes elementos del código. Las directivas se muestran en azul, las instrucciones en azul y en negritas, los comentarios son mostrados en verde y por ultimo las etiquetas y los operandos se muestran en color lila.

La primer directiva ”list“ sirve para especificar el PIC seleccionado, en este caso fue el 16F628a. La directiva “include” se utiliza para incluir un archivo externo en el programa. Con la directiva “__config” se establece la configuración del PIC, el tipo de reloj usado, la configuración del watchdog, el reset interno, etc. ”org“ define la dirección de memoria a partir de la cual el programa se guarda y ”end“ es la directiva que marca el final del programa, esta directiva es muy importante y nunca debe faltar en el código, además todo lo que se escriba después de esa directiva directamente será ignorado.

Este es un programa muy simple, comienza con la directiva “org” , después la instrucción goto dirige el flujo del programa hacia la etiqueta “Inicio“. El siguiente paso es seleccionar el banco de memoria 1 (bsf STATUS,RPO) para poder configurar el puerto B como salida (clrf PORTB), después volvemos al banco de memoria 0 (bcf STATUS,RPO) y por último ponemos todos los pines del puerto B a “1″(movlw 0xFF, movwf PORTB) y con eso el programa prácticamente está finalizado. Se incluye la etiqueta ”Ciclo“ y la última instruccion goto para que el programa se quede ciclado en ese punto (goto Ciclo). Al final se incluye la directiva ”end“ que es necesaria para que el programa ensamblador sepa que no hay más instrucciones que interpretar.

Este programa puede servir de toma de contacto en esto de la programación en ensamblador, más adelante se verán las instrucciones y directivas con mayor detalle.