Está en la página 1de 15

P.G.F.

Resumen de temporizacin
RET DELAY_1 movlw Movwf decfsz goto goto d255 ;Carga el valor 255 al registro DATO_A DATO_A ; DATO_A,1 ;Decrementa la variable DATO-A y salta si es cero DELAY_1;Si no es cero espera en ciclo infinito hasta que lo sea RET ;Luego comienza nuevamente la rutina (Aqu se retorna de la temporizacin)

La parte en rojo ocupa 1s por instruccin, por lo tanto llevamos 2s. En la parte azul tenemos que al decrementar el registro DATO_A se ocupa 1s cuando no se ha llegado a cero y 2s por la instruccin goto y esto se repite hasta que el registro DATO_A llegue a cero, es decir 255 veces. Por lo tanto hasta el momento llevamos 2 + 255*3 s (es decir 767s), pero al llegar a cero el registro DATO_A la instruccin decfsz produce un salto que ocupa 2s ms a nuestra rutina. Terminada la rutina de temporizacin, el tiempo total ocupada por sta ser 767 + 2 s, es decir 769s. Ahora si se requiere temporizar 10ms, se puede ocupar la misma rutina realizada anteriormente repitindola 13 veces, es decir 769*13s aproximadamente 10ms). (9.997s

Supongamos que se desea una temporizacin de 10 ms (10 milisegundos), que ests trabajando con un XT de 4 Mhz, y que a dems se selecciona como Divisor de frecuencia 256 (es decir PS2,PS1,PS0 = 1,1,1).

4 EXP + 6 10 EXP 3 4 = 255 39 = 216 TMR0 = 255 ( 10 ) 256


Eso significa que en TMR0 se deber cargar 255-39=216 (es decir 0xD8 en hexa) y a partir de all el TMR0 contar los 39 ciclos que faltan para desbordarse y producir la interrupcin (si se habilita, sino solamente habr que verificar la bandera en el registro INTCON, sin necesidad de que se produzca la instruccin), y el tiempo que tardar en hacerlo es aproximadamente 10000 us, o sea 10 ms. Realizar un programa en MPLAB que temporice 20ms ocupando una rutina de temporizacin sin recursos especiales, slo por una rutina de ciclo anidado.

1.- Primero debemos calcular cuntas veces debemos repetir la rutina de los 769s, para esto resolvemos la siguiente ecuacin: 0.02 = 0.000769 X

P.G.F.

donde 0.02 seg son los 20ms y X corresponde a cuntas veces debemos repetir la rutina para alcanzar los 20ms. Por lo tanto, al resolver la ecuacin X ser igual a 26.
;Programa ejemplo que realiza una temporizacin de 20ms list p=16f877 include <p16f877.inc> __config (_WDT_OFF & _XT_OSC & _BODEN_OFF) errorlevel -302 ;ignorar errores al almacenar en banco 1 ;******************************************************* ;Definicin de Variables ;******************************************************* cblock 0x20 DATO_A ;Registro para temporizar 769 useg DATO_B ;Registro para repetir la rutina 26 veces endc ;******************************************************* ;Vector de Reset ;******************************************************* org 0x0 ;Indica al ensamblador la direccin de memoria de la sig. instruccin goto inicio ;******************************************************* ;Configuracin de registros ;******************************************************* org 0x5 ;Salta interrupciones inicio clrf INTCON ;Borra interrupciones ;******************************************************* ;Programa Principal ;******************************************************* ppal call DELAY_20MS ;Llama a la rutina de temporizacin goto ppal ;Repite la rutina en forma indefinida ;******************************************************* ;Sub-rutina de temporizacin ;******************************************************* DELAY_20MS movlw movwf clrf DEL_769 decfsz goto d'26' DATO_B DATO_A DATO_A,1 DEL_769 ;Carga el valor 26 al registro ;DATO -B ;Carga la variable DATO-A ;Decrementa la variable DATO-A

P.G.F.

Estimados alumnos, aqu se explica de nuevo como hacer una temporizacin con el registro TMR0
El tiempo empleado en una temporizacin se puede calcular a partir de un ciclo de instruccin (es decir 1 instruccin por cada microsegundo, si estas trabajando con un XT de 4 Mhz), tambin necesitas el valor del Divisor de Frecuencia (el que seleccionabas con los Bit's PS2, PS1 y PS0), y finalmente con el complemento del valor cargado en TMR0 (es decir 255-TMR0), la ecuacin que te permite realizar el clculo es la que sigue... Temporizacin = Ciclo de instruccin * (255-TMR0) * Divisor de Frecuencia Vemos un ejemplo...??? Suponte que deseas una temporizacin de 10 ms (10 milisegundos), que ests trabajando con un XT de 4 Mhz, y que a dems seleccionaste como Divisor de frecuencia 256 (es decir PS2,PS1,PS0 = 1,1,1). Pregunta: Cul es el valor que se debe cargar en TMR0...??? Lo arreglaremos con un pasaje de trminos... 255-TMR0 = Temporizacin(en microsegundos)/(1 ciclo/us * Div. de Frec.) y reemplazando tendrn... 255-TMR0 255-TMR0 255-TMR0 255-TMR0 = = = ~ 10000 us/(1 ciclo/us * 256) 10000 /(256 ciclos) 39,0625 ciclos 39 ciclos

decfsz goto return end

DATO_B,1 DEL_769

;Decrementa la variable DATO-B ;Retorna a la lnea 30 (1 posicin despus del llamado) ;Fin del cdigo

Eso significa que en TMR0 debers cargar 255-39=216 (0xD8 en hexa) y a partir de all el TMR0 contar los 39 ciclos que faltan para desbordarse y producir la interrupcin, y el tiempo que tardar en hacerlo es aproximadamente 10000 us, o sea 10 ms. Antes de seguir, despejemos un par de dudas:

P.G.F.

1 seg. = 1000 ms = 1000000 us y ... 1 ciclos/us es el tiempo empleado en ejecutarse una instruccin ok..., sera bueno que me confirmen si la mayor temporizacin que se puede obtener haciendo uso de este registro es 0,06528 segundos, ser...??? ah queda...!!! Lo que haremos ahora, ser codificar un ejemplo pero una vez producida la interrupcin encendemos un LED, luego volvemos, temporizamos 10 ms y en la prxima interrupcin, lo apagamos, es decir, el LED parpadear cada 10 ms, como es obvio, no lo vamos a notar, as que slo lo simularemos en MPLAB, (en realidad si se nota, luego te cuento como). Bien, el cdigo es el siguiente... ORG GOTO ORG BTFSS GOTO BCF BCF RETFIE BSF BCF RETFIE BSF CLRF MOVLW MOVWF BCF MOVLW MOVWF CLRF MOVLW MOVWF BTFSC GOTO 0x00 inicio 0x04 PORTB,0 LED PORTB,0 INTCON,2 PORTB,0 INTCON,2

LED Inicio

Tiempo NADA

STATUS,5 TRISB 0x07 OPTION_REG STATUS,5 0xA0 ; cargo w con 10100000 INTCON ; habilitamos GIE y T0IE PORTB ; limpiamos PORTB 0xD8 ; cargo w con 216 TMR0 ; lo paso a TMR0 TMR0,7 ; me quedo haciendo nada NADA ; hasta que TMR0 desborde, y entonces

; ; ; ; ; ; ; ; ; ; ; ; ;

Atiendo la interrupcin si el LED est apagado voy a LED y lo enciendo sino apago el LED limpio la bandera T0IF regreso habilitando la interrupcin enciendo el LED borro la bandera T0IF regreso habilitando la interrupcin configurando puertos puerto B es salida cargo w con 00000111 el Divisor = 256

P.G.F.

Aqu vamos...

GOTO END

tiempo

; volver a cargar TMR0

ORG 0X04 ; Atiendo la interrupcin Aqu vendremos cuando se desborde el TMR0, es decir cuando se produzca la interrupcin atenderemos la interrupcin directamente aqu. El cdigo que sigue es como dice el comentario, se trata de verificar si RB0 est a 1 (es decir si el LED esta encendido), y como de comienzo no lo est, ir a GOTO LED, ah lo enciende, luego... BCF INTCON,2 ; limpio la bandera T0IF Esto es lo que debemos tener en cuenta para salir de una interrupcin, borrar la bandera que indica al micro que hubo una interrupcin, o nos quedaremos siempre en la rutina de servicio. Finalmente con... RETFIE Habilitamos nuevamente la interrupcin. Pasemos ahora a la etiqueta inicio, lo primero que haremos ser cambiar de banco y luego configurar el puerto B como salida, y aqu viene lo nuevo... MOVLW 0x07 ; cargo w con 00000111 MOVWF OPTION_REG ; el Divisor = 256 Veamos que Bit's estamos configurando en OPTION_REG Los Bit's 7 y 6 no los utilizamos por ahora, T0CS=0 (TMR0 es temporizador), T0SE=0 (no se usa), PSA=0 (Prescaler asignado a TMR0), PS2,PS1,PS0=1,1,1 (Prescaler es 256), en conclusin 00000111=0x07 y es lo que cargamos en el registro OPTION. Ahora cambiamos de banco y habilitamos las interrupciones GIE, y en especial T0IE, que es la interrupcin por desbordamiento del registro TMR0, luego... CLRF PORTB ; limpiamos PORTB Lo que viene ahora es preparar la temporizacin, y de los clculos que hicimos debamos cargar 216 en TMR0 y a partir de ah esperar a que este registro se desborde y produzca la interrupcin, entonces hacemos eso justamente...

P.G.F.

Tiempo

MOVLW 0XD8 ; cargo w con 216 MOVWF TMR0 ; lo paso a TMR0 tiempo es la etiqueta en donde cargar el registro TMR0 cada vez que quiera hacer una temporizacin, y 0xD8 es 216 en hexadecimal. NADA BTFSC TMR0,7 ; me quedo haciendo nada GOTO NADA ; hasta que TMR0 desborde, y entonces GOTO tiempo ; volver a cargar TMR0 La verdad es que ya no tengo nada que hacer, sino esperar a que desborde el TMR0,as es que hice un bucle al cuete, con BTFSC TMR0,7 estas probando si el Bit7 de TMR0 est a 0, y como ya sabemos que estar a 1, pues ah te quedas dando vueltas en ese bucle mientras el tiempo pasa, hasta que de repente se produce una interrupcin, luego vas, la atiendes y cuando regresas caes en... GOTO tiempo ; volver a cargar TMR0 para que comiences a temporizar nuevamente, es decir recargar TMR0 con 216 para luego quedarte en el bucle a esperar la interrupcin. Ahora pasemos a lo mejor de todo esto, La simulacin en MPLAB, all vamos.

Vamos al cdigo, lo copias, lo pegas y luego... Project --> Build All Perfecto...!!! Abriremos dos ventanas que son para chequear el funcionamiento de la temporizacin y la interrupcin, para ello ve a ... Windows --> Special Function Register Windows --> Stopwatch... Reseteen con F6 y luego con F7 avanza hasta la etiqueta Nada

P.G.F.

En Special Function Register Configuracin de puertos, el puerto A no me interesa por que no lo utilizo as que ah queda, con sus 5 Bit's como entrada (TRISA=00011111), El puerto B est todo como salida (TRISB=00000000), y hemos configurado OPTION_REG como estaba planeado para TMR0 incluso puedes ver el prescaler (los 3 primeros Bit's=111), en el registro INTCON est habilitado GIE y T0IE, finalmente hemos cargado TMR0 con 216. En Stopwatch: Es la primera vez que abrimos esta ventana, y como vers en Cycles, tenemos 12, es decir que hemos ejecutado 12 ciclos de instruccin y estos han consumido 12 microsegundos lo cual puedes ver en Time, la frecuencia de procesador utilizada es de 4 Mhz. y est tildado Clear On Reset, esto ltimo significa que cuando resetees el micro Stopwatch limpiar todo y lo pondr a cero, pero como lo que queremos es ver si realmente nuestro programa consume los 10 milisegundos hasta que se desborde TMR0, pues limpiaremos todo a mano, as que dale a Zero, y entonces Cycles=0 y Time=0. Analicemos un poco lo que tiene que ocurrir a partir de ahora, primero que nada, estimados pongan atencin que aqu comienza la temporizacin de los 10 milisegundo y terminar cuando se produzca la interrupcin y salta a ORG 0x04 y como este ltimo es slo un vector de interrupcin pondremos un Breack Point en la siguiente lnea es decir en. BTFSS PORTB,0 Entonces ve a esa direccin y click con el botn derecho, seleccionas Breack Point(s) y esta lnea se pintar de rojo, lo que hicimos recin es poner un punto de ruptura de tal modo que cuando corramos el programa, comenzar la temporizacin y cuando se produzca la interrupcin, habrn transcurrido los 10 milisegundo y el programa quedar enclavado en BTFSS PORTB,0. Si siguieron bien las instruciones, daremos el ltimo paso de la simulacin... Vamos... que esto es mas fcil que ganarle a Argentina Haz click en Debug --

P.G.F.

> Run --> Run, y que sea lo que Dios diga...!!! Por suerte se clav donde deba, eso significa que el watch indica el tiempo programado para la temporizacin...

P.G.F.

A observar nuevamente para saber si todo est en su lugar... Lo primero que se me ocurre es ver si realmente pasaron los 10 ms ufaaaaa...!!! me pas con 242 microsegundos, supongo que debe ser por los decimales, aquellos que aparecieron en los clculos, pero bueno estamos ah no creen..??? Sigamos observando... como es lgico el TMR0 se desbord y est en puros ceros, el registro OPTION_REG no se altera en absoluto y como todava no encend el led, PORTB tambin est en ceros, un ltimo detalle, en el registro INTCON, GIE=0 (interrupciones deshabilitadas), y T0IF=1 (la bandera esta activa) Les parece si saltamos el Breack Point para dejar que el programa siga corriendo y ver que pasa luego...??? Bien, entonces coloca el cursor donde pusimos el Breack Point y haz click con el botn derecho y luego selecciona Run To Here eso har que el programa contine, y entonces quedars nuevamente en el punto de ruptura, as...

P.G.F.

Como notaran, pas lo mismo que hace un momento, slo que esta vez PORTB tiene encendido el LED o lo que es lo mismo RB0=1 y en Stopwatch, Time=20,50, eso significa que llevamos 2 temporizaciones de 10 ms, yo dira que vamos bien, eso me agrada, si haces Run To Here nuevamente, Time se incrementar en 10 ms ms y quedar en 30,75 y lo mejor de todo es que el LED se apagar, es decir RB0=0. Estimados...!!!, nos merecemos un aplauso no creen...???, despus de tanto despelote con frmulas, interrupciones y todo eso, estamos listos para temporizar. En resumidas cuentas... el lo de ecuaciones anterior, si trabajan con un XT de 4Mhz, se resume en... Temporizacin = (255-TMR0) * Divisor de Frecuencia

P.G.F.

Esta es la ecuacin que utilizar en todas las temporizaciones ya que siempre trabajo con un cristal de 4 Mhz. Se imaginan que pasara si utilizara un registro auxiliar y le cargara el valor 0x64 (100 en decimal) para luego decrementarlo cada vez que se desborda el TMR0...??? Muy sencillo, como el TMR0 se desbordar 100 veces tendremos lo siguiente... Temporizacin = 100 * 39 * 256= 998400 Siiii...!!!, prcticamente 1000000 de microsegundos, o sea 1 segundo Tericamente esto debera cumplirse, pero por una u otra razn, en la realidad no es tan as, y no queda otra que ajustar las cosas a mano (decimales). OK., hasta aqu llegamos...!!!, por cierto y para aquellos que no se convencen con simple teora, lean las guas y practiquen

CON LO DEMOSTRADO ANTERIORMENTE PUEDENE ENTENDER DE MEJOR MANERA LA TEMPORIZACION ************************************************** ;Programa que cambia el tiempo de encendido y apagado ;de dos leds conectados al PORTD segn la siguiente tabla: ; Tiempo de Encendido ; RB7 Descripcin ; 1 Led encendido por 1 segundo ; 0 Led encendido por 1/2 segundo ; ; Tiempo de Apagado ; RB6 Descripcin ; 1 Led apagado por 1 segundo ; 0 Led apagado por 2 segundo list p=16f877 include <p16f877.inc> __config (_WDT_OFF & _XT_OSC & _BODEN_OFF) errorlevel -302 ;ignorar errores al almacenar en banco 1

P.G.F.

;******************************************************* ;Definicin de Variables ;******************************************************* TEMPO1 equ 0x21 ;******************************************************* ;Vector de Reset ;******************************************************* org 0x0 ;Indica al ensamblador la direccin de memoria de la sig. instruccin goto inicio ;******************************************************* ;Configuracin de registros ;******************************************************* org 0x5 ;Salta interrupciones inicio clrf INTCON ;Borra interrupciones bcf STATUS,RP1 ;Cambio a Banco 1 bsf STATUS,RP0 movlw b'11000111' ;configura el TMR0 con pre-escaler a 256 movwf OPTION_REG ;--------------------------------------------------------------------------------;Descripcin del registro OPTION_REG ; ;Bit 7: Deshabilita las resistencias de pull-up, ya que estan conectadas a los pulsadores en forma externa ;Bit 6: No se ocupa para el TMR0, no importa el valor ;Bit 5 T0CS: Selecciona la fuente de Reloj para TMR0, 0 = Ciclo de instruccin interno (temporizador) ;Bit 4 T0SE: Flanco de incremento, 0 = Incremento en flanco ascendente ;Bit 3 PSA: Bit de asignacin del Prescaler, 0 = Divisor asignado al TMR0 ;Bit 2-0 PS2,PS1,PS0: en 1, Seleccin del prescaler en 256 ;--------------------------------------------------------------------------------clrf TRISE ;Habilita PORTD como I/O digital clrf TRISD ;PORTD como salida movlw b'11000000' ;Configura RB7 y RB6 como entradas movwf TRISB ;y los dems pines como salida bcf STATUS,RP0 ;vuelve a banco 0 ;******************************************************* ;Programa Principal ;******************************************************* ppal btfss PORTB,7 ;Comprueba RB7 goto RB7_0 ;Salta a rutina para encender 1/2 seg call TIME_1s goto LED_ON ;Salta a rutina que enciende el led RB7_0 movlw d'50' ;Carga TEMPO1 con el valor 50 movwf TEMPO1 ;para temporizar 1/2 segundo LED_ON movlw b'00000011' movwf PORTD ;enciende led call DELAY10 ;Llama a la rutina que ocupa el TMR0 btfss PORTB,6 ;Comprueba RB6

P.G.F.

goto RB6_0 ;Salta a rutina para encender 1/2 seg call TIME_1s goto LED_OFF;Salta a rutina que enciende el led RB6_0 movlw d'200' ;Carga TEMPO1 con el valor 200 movwf TEMPO1 ;para temporizar 2 segundo LED_OFF clrf PORTD ;Apaga los led's call DELAY10 ;Llama a la rutina que ocupa el TMR0 goto ppal ;**************************************************************** ;Rutina que carga TEMPO1 para temporizar 1 segundo ;**************************************************************** TIME_1s movlw d'100' ;Carga TEMPO1 con el valor 100 movwf TEMPO1 ;para temporizar 1 segundo return ;Vuelve al programa ;**************************************************************** ;Rutina de Temporizacin , que ocupa el TMR0, sin interrupciones ;**************************************************************** DELAY10 bcf INTCON,2 ;borra el flag de estado del TMRO movlw d'216' movwf TMR0 ;Carga TMRO para que cuente 39 (255-216) DELAY10_1 btfss INTCON,2 ;Espera overflow del TMRO goto DELAY10_1 decfsz TEMPO1,1 ;Repite TEMPO1 veces, depende del valor dado por RB7 y RB6 goto DELAY10 ;con lo que se logran 1/2, 1 y 2 segundos return ;Vuelve al programa end

ESTIMADOS ALUMNOS ESPERO QUE ESTA INFORMACIN LA UTILISEN DE LA MEJOR MANERA Y LES SEA PROVECHOSA. ATTE. Ing. Paul Glvez Docente Duoc UC Sede Valparaso

Disear un programa que escriba la siguiente secuencia:00011000 11000011 10000001 10000001

P.G.F.

11111111 10000001 10000001 10000001 Como material de apoyo; Uso de tablas.


Para que esta secuencia sea visible por el ojo humano. Realizar una temporizacin de 3.75 segundos al encender cada led y para separar ambas secuencias, apagar todos los led por 1.25 segundos. Dichas temporizaciones, deben efectuarse con los registros de temporizacin, (TMRO o TMR1).

Disea un programa que lea un dato del puerto B lo escriba en puerto C, y que ante cualquier corte de energa, la ltima informacin escrita en el puerto C quede respaldada, es decir, al volver alimentar o resetear el circuito este puerto indique el ltimo dato almacenado en memoria. Disear un programa que escriba la siguiente secuencia:00011000 11011011 10011001 10011001 11111111 10000001 11000011 10000001 Como material de apoyo; Uso de tablas.
Para que esta secuencia sea visible por el ojo humano. Realizar una temporizacin de 6.75 segundos al encender cada led y para separar ambas secuencias, apagar todos los led por 2.5 segundos. Dichas temporizaciones, deben efectuarse con los registros de temporizacin, (TMRO o TMR1) Que son las resistencias de pull up Que funcin cumple el registro OPTION_REG Que es el preescaler Como funciona el registro INTCON Que es un ciclo anidado

P.G.F.

Diferencias entre un retardo de tiempo y una temporizacin Que es rebalse en un registro de temporizacin y que sucede cuando sucede este evento Nombre los tipos de interrupciones que existen y cuantas son