Wenas soy nuevo por aqui y tb con los PICs. Me han mandado a hacer una practica de programacion del 16f84 con ensamblador programado en MPLAB para el 16 de febrero. El problema es q el profesor lo q dio en clase fue solo los comandos y para q sirven y muy por encima y ahora nos manda a hacer un reloj
, increible. No os digo q me la resolvais sino q me guieis un poco xq es q estoy mu perdido.
Os dejo el enunciado:
El objetivo de la práctica es realizar ejercicios de programación de los recursos de Entrada/Salida en
un microcontrolador Pic16F84. Estos ejercicios se hacen en torno a un circuito propuesto que
implementa un reloj digital con alarma. La práctica se puede probar sobre el emulador MPLAB del
PIC, que es de libre disposición y se encuentra instalado también en las aulas de ordenadores.
Se trata de programar una rutina de servicio de interrupción cuyo objetivo sea actualizar
correctamente estas variables en memoria: Unidades y Decenas de Horas, Unidades y Decenas de
Minutos y Segundos. Para ello se usará el Timer0 del chip y se aprovechará su capacidad de provocar
interrupciones, como se detalla más abajo. Suponer que la frecuencia del reloj a la que funciona el
chip es de 10 MHz. Leer detenidamente el resumen de los recursos de E/S del PIC que aparece más
abajo para decidir cuáles usaremos y cómo programaremos las opciones que controlan esos recursos.
Pondremos código de inicialización de esos recursos en el programa principal y en la dirección 0004h
nuestra rutina de servicio de interrupción. Se usará la plantilla de código adjunta que ya hace parte del
trabajo y nos servirá de guía. El algoritmo es muy simple, se trata de incrementar en la rutina de
interrupción un contador (o mejor varios contadores, de forma anidada). Supongamos que
programamos la interrupción del timer para que interrumpa cada cierto período de tiempo fijo. En cada
interrupción, y después de incrementar nuestro primer contador, compararemos su valor con el número
de cuentas necesario para que pase un segundo, si es igual a esa cuenta, pondremos a cero ese primer
contador e incrementaremos nuestra variable dedicada a contar segundos, si es inferior, saldremos de
la rutina de interrupción. Después de incrementar los segundos, comprobaremos si dicha variable llega
a 60, momento en el que la pondremos a cero e incrementaremos nuestra variable de unidades de
minuto. Igual haremos para incrementar decenas de minutos y las horas a partir de las decenas de
minutos, y para pasar de las 24h a las 00h (comparación algo más difícil, porque involucra dos
dígitos).
En el programa principal, después de haber inicializado convenientemente los recursos de E/S
(programación del timer, habilitación de la interrupción, dirección de puertos…) nos quedaremos en
un bucle permanentemente, en el que iremos trasladando el contenido de las variables que se
actualizan en la rutina de interrupción a los puertos de salida que gobiernan el display. Opcionalmente
se podrá añadir cualquier elemento que acerque la práctica a su funcionamiento real (gestión de los
pulsadores, alarma, puntos de segundos,…)
Esta es la plantilla q tenemos q seguir
;**********************************************************************
; *
; *
;**********************************************************************
list p=16F84 ; directiva para definir el procesador
#include <p16F84.inc> ; fichero que incluye nombres de registros y bits
;***** DEFINICIONES DE VARIABLES
w_temp EQU 0x0C ; variable para preservar el acumulador durante las int.
status_temp EQU 0x0D ; igual para el registro de Status
; puede usarse la directiva CBLOCK para nuevas variables a
; partir de 0x0D
;**********************************************************************
ORG 0x000 ; El procesador empieza a ejecutar aqui al arranque o
; reset
goto main ; ir a nuestro programa principal
;Rutina de Servicio de Interrupción
ORG 0x004 ; Las interrupciones provocan la ejecucion de esta posición
movwf w_temp ; guardar el registro W del programa interrumpido
movf STATUS,w ; guardar ahora su registro de Status
movwf status_temp
; escribir aqui el cuerpo de la rutina de interrupción
movf status_temp,w ; recuperamos el valor del registro de Status
;guardado antes
movwf STATUS ; y lo restauramos
swapf w_temp,f
swapf w_temp,w ; restauramos registro acumulador W
retfie ; retorno de la interrupción
main
; escribir aqui el programa principal: inicializaciones de reg y bucle principal
END ; directiva fin del programa
Saludos y gracias a todos
