.: Más formas de Temporizar

Puedes hacer la misma temporización sin utilizar interrupciones, es decir sin habilitarlas, y luego sólo chequear la bandera T0IF, ya que ésta cambiará siempre que se desborde el registro TMR0, y para analizar la bandera nuevamente la vuelves a limpiar, veamos un ejemplo

Haz el código que quieras y luego llama (Call) a una rutina de retardo, que la puedes etiquetar retardo, y cuando la temporización termine le colocas un RETURN, así...

	.
	.
	Call	retardo
	.
	.

retardo	BCF	INTCON,2 		; limpias bandera
	MOVLW	0XD8		; cargas w con 216
	MOVWF	TMR0		; lo pasas a TMR0
chequear	BTFSS	INTCON,2		; chequeas T0IF
	GOTO	chequear		; hasta que TMR0 desborde, y entonces
	RETURN			; retornas del retardo
	.
	.

En este ejemplo no fue configurado INTCON (para evitar las interrupciones) pero sí, el registro OPTION y del mismo modo que lo hicimos anteriormente, con el mismo prescaler, el resto lo dejo en tus manos, que más...!!!, esto sirve de práctica, y el que lo haga, lo manda y en la próxima actualización lo incluimos en la web.

Para seguir con el tema, vamos a tomar de ejemplo una rutinas similar a la que hemos utilizado en la mayoría de los programas que se encuentran en la web y que cumplen la función de generar un retardo cualquiera sin hacer uso del registro TMR0, sino más bien utilizando dos registros alternativos. La idea es averiguar cual es el tiempo que consume esa rutina...

Y aquí la tenemos en vivo...

;----------- Inicia Rutina de Retardo -----------

retardo	MOVLW	0x10	; Aquí se cargan los registros
	MOVWF	reg1	; reg1 y reg2 con 0x10 y 0x20
dos	MOVLW	0x20
	MOVWF	reg2

uno	DECFSZ	reg2,1	; Aquí se comienza a decrementar
	GOTO	uno	; Cuando reg2 llegue a 0 
	DECFSZ	reg1,1	; le quitare 1 a reg1
	GOTO	dos	; iré a cargar reg2 nuevamente
	RETURN		; Si reg1 termino de decrementar, regreso del retardo

;------------- Fin Rutina de Retardo -------------

Lo que hace este código es lo siguiente; primero carga ambos registros reg1 y reg2, luego comienza a decrementar reg2, cuando éste llega a cero, resta 1 a reg1 y carga nuevamente reg2 y lo decrementa, y cuando llega a cero nuevamente, vuelve a restarle 1 a reg1, en síntesis reg1 se decrementará en 1 cada vez que se vacíe reg2, si te das cuenta reg1 es igual a 0x10 (0x10 = d'16'), por lo tanto reg2 se decrementará 16 veces antes de que reg1 llegue a cero.

Bien, veamos ahora cuanto tiempo consume esta rutina de retardo, y para poder hacerlo deberemos tener en cuenta la cantidad de ciclos de instrucción de cada una de las instrucciones que se encuentran en esta rutina, por lo general la mayoría de las rutinas consumen un ciclo de instrucción salvo cuando realizan un salto, bueno pues en ese caso consume dos ciclos de instrucción. Aquí tienes una tabla con los ciclos de instrucción por si te hace falta.

De las instrucciones que están en rojo; la primera consume un ciclo mientras no se realice el salto y no saltará por lo menos 14 veces (d'14' = 0x20) hasta que reg2 se haga cero, pero la segunda consume dos ciclos y también se repite 14 veces, entonces...

rutina uno = 3 * 14 ciclos = 42 ciclos

De las instrucciones que están en verde; la primera y la segunda instrucción consumen un ciclo y se repiten 16 veces (d'16' = 0x10) es decir reg2 se carga 16 veces antes de que se vacíe reg1, las dos instrucciones restantes consumen 1 y 2 ciclos de instrucción respectivamente y también se repiten 16 veces.

Por tanto tenemos 5 ciclos de instrucción que se repiten 16 veces mas la rutina uno que se encuentra incluida dentro de la rutina 2, es decir...

rutina dos y uno = (42 + 5) * 16 = 752 ciclos

Hasta aquí diría que ya estamos, pero el tema es que, cada vez que sales de la rutina que está en rojo e ingresas a la que está en verde, lo haces con un salto es decir 2 ciclos de instrucción y lo haces 16 veces, es decir 32 ciclos más, y por otro lado, desde que la rutina de retardo se inicia, pasaron 4 instrucciones, antes de entrar a la etiqueta uno, eso significa que al total de ciclos de instrucción, hay que agregarle 36 ciclos más, y tendrás en total 788 ciclos.

Si trabajas con un XT de 4 Mhz cada instrucción se ejecuta en un microsegundo, por lo tanto esta rutina de retardo demora 788 microsegundos

La verdad es que no se cual de las dos temporizaciones es más precisa, si haciendo uso del TMR0, o del modo que acabamos de ver, lo que si creo, es que debes tener en cuenta todos los detalles posibles al hacer los cálculos, tanto en uno como en otro tipo de temporización, lo mejor es evitar los decimales y trabajar en lo posible con números enteros, esto lo digo por las temporizaciones con el registro TMR0, respecto a lo último que acabamos de ver, debes tener mucha precaución en todas las instrucciones utilizadas, para que así no se te escape ninguna.

A demás, con esta última forma de temporizar puedes utilizar el TMR0 para otra cosa, no se... queda a tu criterio, de todos modos ya lo viste y sabes como utilizarlo

Viste Cesar...??? Tarea cumplida...!!!

Bien mis queridos amigos, este tutorial está a punto de dar sus últimos respiros...

Espero haber dado respuesta a muchas de sus dudas, y recuerden que soy un simple terrícola, y que si en algo la erré... sería bueno saberlo, para así corregir los errores y continuar aprendiendo todos juntos.