Ing.

En sistemas Computacionales
Sistemas Programables

Practica 1
Uso de subrutinas

Por:
Oppai Dragons:

Maestro:
Javier Silvestre Zavala

23/septiembre/2019
Objetivo

 Conocer el uso y características de las subrutinas en el lenguaje ensamblador

 Aprender a manipular MPLAB para crear programas.
 Conocer las características de PROTEUS para la creación de diagramas.
 Aprender a quemar programas en PIC 16F84A
 Creación de un circuito con el PIC 16F84A.
 Utilización de la simulación de PROTEUS con un código escrito y compilado en
MPLAB
Material

 1 programador de PIC
 1 microcontrolador PIC 16F84A
 1 cristal de cuarzo de 4 MHz
 2 capacitores cerámicos de 22pF
 1 resistor de 1KΩ
 7 resistor de 220Ω
 7 LEDS
 1 protoboard
 Proteus 8 Professional
 MPLAB IDE
Sustento teórico
Una subrutina en el lenguaje ensamblador del microcontrolador PIC 16F84A, es un
fragmento de programa que ejecuta alguna tarea concreta que a menudo es repetitiva, y
que para ahorrar memoria y hacer el programa más legible, se hace uso de ellas. Una
subrutina se ejecuta llamándola con la instrucción CALL, siendo necesario poner al final
de ella la instrucción RETURN para que regrese al punto de donde se le llamó después
de ejecutarse.
En el siguiente fragmento de programa se muestra el uso de las subrutinas. Como
podemos ver en la etiqueta INICIO en la segunda instrucción se llama a la subrutina
ESPERA. Por lo tanto, el programa realiza el salto a esa etiqueta y ejecuta el código que
encuentra ahí. Cuando termina de ejecutarse el código de la subrutina se coloca la
instrucción RETURN, que hace que el programa regrese a la tercera línea de la etiqueta
INICIO.
En la fig. se muestra el diagrama de flujo del programa cuyo código se exhibe en el punto
1 del procedimiento de la práctica.

El PIC16F84 es un microcontrolador de 8
bits programable el cual contiene todos
los componentes para poder realizar una
tarea.
Tiene una arquitectura de 8 bits y 18
pines. Consta de:

 Memoria flash (1k x 14bits).

 Memoria RAM (68 registros x
8bits).
 Timer de 8 bits.
 Un divisor de frecuencia.
  Varios puertos de entrada-salida (13 pines en dos puertos, 5 pines el puerto A y 8
pines el puerto B).

Un oscilador de cristal es un oscilador electrónico que utiliza la resonancia mecánica de

un cristal vibratorio de material piezoeléctrico para crear una señal eléctrica con una
frecuencia precisa. Esta frecuencia se utiliza comúnmente para controlar el tiempo, como
en los relojes de cuarzo, para proporcionar una señal de reloj estable para circuitos
integrados digitales y para estabilizar las frecuencias de los transmisores y receptores de
radio.
El Capacitor es un dispositivo capaz de almacenar energía sustentando un campo
eléctrico. Está formado por un par de superficies conductoras, generalmente en forma de
láminas o placas.
Osciladores para microprocesadores o microcontroladores. Todo microprocesador o
microcontrolador requiere de un circuito que le indique a que velocidad debe trabajar. Este
circuito es conocido como un oscilador de frecuencia. En el caso del microcontrolador
PIC16F84A el pin 15 y el pin 16 son utilizados para introducir la frecuencia de reloj.
Existen microcontroladores que tienen su oscilador internamente y no requieren de
pequeños circuitos electrónicos externos. El microcontrolador PIC16F84A requiere de un
circuito externo de oscilación o generador de pulsos de reloj. La frecuencia de reloj
máxima es de 20 Mhz.
Oscilador tipo “XT” (XTal) para frecuencias no mayores de 4 Mhz.:
En la imagen siguiente figura se puede observar la configuración del circuito.
La condición básica importante para que este oscilador funcione es que
los capacitores C1 y C2 deberán ser iguales. En la tabla anterior se detallan algunos
valores de C1 y C2.

Procedimiento
Para ejecutar el código, se pasó al programa MPLAB y el diseño del circuito se diseñó en
PROTEUS 8 PROFESSIONAL.
1. El siguiente código fue copiado en el programa MPLAB
.
;
########################################################################
################### ; PRÁCTICA 1. USO DE SUBRUTINAS
;ESTE PROGRAMA MUESTRA EL USO DE SUBRUTINAS. SU FUNCIÓN ES LA
REALIZACIÓN
;DE LA SUMA Y LA RESTA DE DOS VALORES PREVIAMENTE CARGADOS EN EL
PROGRAMA.
;EL VALOR DE LA SUMA Y LA RESTA SE MUESTRAN ALTERNATIVAMENTE
DURANTE UN
;LAPSO DE TIEMPO DE LA MISMA DURACIÓN.
;#######################################################################
####################
INCLUDE <P16F84A.INC>
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC
;
########################################################################
################### ; Declaración de variables
;#######################################################################
####################
DATO1 EQU 0CH ;En Dato1 y Dato2 se guardan los valores que ;se sumarán y
restarán
DATO2 EQU 0DH
RET1 EQU 0EH ;Ret 1 y Ret2 son variables usadas para el retardo
RET2 EQU 0FH
;#######################################################################
####################
;
########################################################################
################### ;CONFIGURACIÓN DE LOS PUERTOS
;#######################################################################
####################
ORG 00H
BSF STATUS,RP0 ;Nos cambiamos al banco 1
MOVLW 0X00 ;Cargamos W con 0s
MOVWF TRISB ;Configuramos PORTB como salidas
BCF STATUS,RP0 ;Nos regresamos al banco 0
;
########################################################################
###################
GOTO INICIO

INICIO MOVLW D'45' ;Cargamos 45 decimal a W

MOVWF DATO1 ;Se lo pasamos a Dato1
MOVLW D'35' ;Cargamos 35 decimal a W
MOVWF DATO2 ;Se lo pasamos a Dato2
;
########################################################################
################## ;Subrutina de suma
;#######################################################################
###################
SUMA MOVF DATO1,W ;Cargamos W con Dato1
ADDWF DATO2,W ;Esta instrucción hace W + Dato2 y ;guarda el resultado en W
MOVWF PORTB ;Pasamos el resultado para su visualización ;al puerto B
CALL RETARDO ;Llamamos a la rutina de retardo para que el ;resultado
permanezca en el puerto B durante ;un cierto lapso de tiempo
CALL RETARDO
;
########################################################################
################# ;Subrutina de resta
;#######################################################################
##################
RESTA MOVF DATO2,W ;Cargamos W con Dato2
SUBWF DATO1,W ;Esta instrucción realiza Dato1 - Dato2 ;y guarda el resultado en
W
MOVWF PORTB ;Pasamos el resultado para su visualización ;al puerto B
CALL RETARDO ;Llamamos a la rutina de retardo para que el ;resultado
permanezca en el puerto B durante ;un cierto lapso de tiempo
CALL RETARDO
GOTO INICIO ;Regresamos al inicio para repetir el proceso ;de forma infinita
;
########################################################################
################# ;Subrutina de retardo
;#######################################################################
##################
RETARDO MOVLW 0XFF ;Cargamos Ret1 y Ret2 con FF(255 en hexadecimal)
MOVWF RET2
BUCLE1 MOVLW 0XFF
MOVWF RET1
BUCLE2 DECFSZ RET1 ;Decrementamos en 1 Ret1
GOTO BUCLE2 ;Si el resultado del decremento no es 0, seguimos ;decrementando
BUCLE3 DECFSZ RET2 ;Si el resultado del decremento de Ret1 fue 0, iniciamos
;con el decremento de Ret2
GOTO BUCLE1 ;Si el resultado del decremento no es 0, saltamos a Bucle1
RETURN ;Si el resultado del decremento es 0, abandonamos la subrutina ;y
regresamos una línea abajo de donde fue llamada
END ;Fin del programa
2.- Se ensambló el código mencionado anteriormente para generar el archivo .HEX que
se grabará en el microcontrolador.
3.- Antes de grabar el código al PIC se diseñó y probó el circuito en PROTEUS. Fig. 2
 Figura 2.- Diagrama del circuito en Proteus.
4.- Una vez que vimos que el circuito en proteus funcionaba y daba los resultados
correctos, procedimos a quemar el PIC.
5.- Con el PIC quemado se monto el circuito en físico. Fig. 3.

Figura 3.- Circuito físico de la practica 1.

5.1.- Las salidas del PIC de RB0 a RB6 se conectan resistencias de 220 ohm con unos
LEDS. Estos nos mostraron el resultado de la suma y resta.
5.2 Los dos capacitores son conectados a tierra y al cristal de cuarzo, y el cuarzo se
conectan a los pines del oscilador (OSC1 y OSC2) representando la señal de reloj que
entra y sale.
5.3.- Al pin 4 que es la entrada de voltaje se le conecta una resistencia de 1K.
6.- ¿Qué pasaría si no escribimos la línea INCLUDE <P16F84A.INC> en el
programa?, ¿Por qué?
El programa no se ejecutaría, ya que no está reconociendo a que componente darle las
instrucciones, esa línea indica sobre que microcontrolador se está trabajando.
7.- Si no existiera la subrutina de RETARDO, ¿qué resultados arrojaría la
simulación?
El programa se ejecutaría tan rápido que no se mostrarían los resultados, ya que no se
espera a que termine la instrucción cuando ya está ejecutando la otra.
8.- El circuito lo que hace es hacer una suma y una resta y repetidamente alternan los
valores entre una y otra.
El circuito es fácil de realizar, ya que solo es conectar los pines de entrada y salida donde
corresponden, una vez teniendo el circuito funcional en virtual es más fácil pasarlo a
físico. La parte complicada fue pasar el código al editor de texto de MPLAB ya que había
que agregar ciertas líneas para hacer que funcionara correctamente. Hay que hacer las
cosas con cuidado porque por un fallo no se sabe si es por mal funcionamiento del circuito
o si es el fallo es del código.
Actividades complementarias
Realice un programa en lenguaje ensamblador para el microcontrolador PIC 16F84A que
encienda en secuencia tres LEDS conectados en los pines RB0, RB1 y RB2 del puerto B
del microcontrolador. La secuencia será la siguiente: 100, 010, 001, 100, 010, ….. Cada
LED durará encendido cierto tiempo (puede usar la rutina de retardo empleada en el
programa de ejemplo). Escriba el programa correspondiente y repita los pasos 2 a 5 de la
práctica.

2.- Se ensambló el código siguiente en el editor de textos de MPLAB para posteriormente

grabarlo en el PIC.
INCLUDE <P16F84A.INC>
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC
;
########################################################################
################### ; Declaración de variables
;#######################################################################
####################
RET1 EQU 0EH ;Ret 1 y Ret2 son variables usadas para el retardo
RET2 EQU 0FH
;#######################################################################
####################
;#######################################################################
#################### ;CONFIGURACIÓN DE LOS PUERTOS
;#######################################################################
####################
ORG 00H
BSF STATUS,RP0 ;Nos cambiamos al banco 1
MOVLW 0X00 ;Cargamos W con 0s
MOVWF TRISB ;Configuramos PORTB como salidas
BCF STATUS,RP0 ;Nos regresamos al banco 0
;
########################################################################
###################
GOTO INICIO
INICIO
movlw b'00000001' ;LE PASAMOS EL NUMERO 4 AL REGISTRO W SE ACOMODA ASI
YA QUE EL NUMERO SE ORDENA EL ULTIMO BIT VA PARA EL PUERTO B1
movwf PORTB ;LO MOVEMOS AL PUERTO B
CALL RETARDO ;LLAMAMOS AL RETARDO

movlw b'00000010' ;LE PASAMOS EL NUMERO 2 AL REGISTRO W SE ACOMODA ASI

YA QUE EL NUMERO SE ORDENA EL ULTIMO BIT VA PARA EL PUERTO B1
movwf PORTB
CALL RETARDO ;Llamamos a la rutina de retardo para que el ;resultado
permanezca en el puerto B durante ;un cierto lapso de tiempo
movlw b'00000100' ;LE PASAMOS EL NUMERO 1 AL REGISTRO W SE ACOMODA ASI
YA QUE EL NUMERO SE ORDENA EL ULTIMO BIT VA PARA EL PUERTO B1
movwf PORTB
CALL RETARDO
goto INICIO
;
########################################################################
################# ;Subrutina de retardo
;#######################################################################
##################
RETARDO MOVLW 0XFF ;Cargamos Ret1 y Ret2 con FF(255 en hexadecimal)
MOVWF RET2
BUCLE1 MOVLW 0XFF
MOVWF RET1
BUCLE2 DECFSZ RET1 ;Decrementamos en 1 Ret1
GOTO BUCLE2 ;Si el resultado del decremento no es 0, seguimos ;decrementando
BUCLE3 DECFSZ RET2 ;Si el resultado del decremento de Ret1 fue 0, iniciamos
;con el decremento de Ret2
GOTO BUCLE1 ;Si el resultado del decremento no es 0, saltamos a Bucle1
RETURN ;Si el resultado del decremento es 0, abandonamos la subrutina ;y
regresamos una línea abajo de donde fue llamada de la subrutina.

END ;Fin del programa

3.- Como ya se tenía la base del programa anterior, fue más fácil identificar las cosas y
programarlo bien, los errores pasados ya no se tuvieron en esta.
4.- El circuito es prácticamente el mismo que el del programa pasado así que no hubo
necesidad de cambiar nada. (Figura 2)
5.- Se quemó el PIC con el código para poder verificar que se realizó bien.

Resultados

Ilustración 1.- Circuito de suma y resta

Ilustración 2.- Circuito de secuencia binaria

Conclusión
Al querer pasar el código a MPLAB se tuvieron dificultades primeramente con el tipo de
archivo que se debía de guardar, ya que no lográbamos hacer que leyera el archivo.
Cuando se trataba de ensamblar el programa se marcaban varios errores en el código
que eran líneas de más que se iban a la hora de copiar o líneas que faltaban para que
pudiera funcionar. La primera vez que se logró quemar, no se daban los resultados
esperados en el circuito físico, así que se tuvo que requemar y de esta manera ya
funcionó.
Con está practica se entendió un poco mejor el uso de las subrutinas y las aplicaciones
que estas pueden tomar, así como el uso de la PIC y los usos que está puede dar. Las
subrutinas son importantes para realizar tareas repetitivas que puedan consumir más
memoria de lo que se espera y de esta manera solo mandarlas llamar sin necesidad de
tener que volver a hacer todo el procedimiento que esta conlleva.
Referencias Bibliográficas
• Mano, Morris M y Charles R. Kime (2da. Edicion)
Logic and computer design fundamentals
Prentice Hall.
• Stallings, William
Organización y arquitectura de computadoras
Pearson