Creando una libreria de retardos

Buenas a todos:

Estoy creandome una pequeña pero completa libreria de retardos y creo haberme quedado y creo haberme estancado.

El siguiente codigo es el que he creado, esta pensado para una frecuencia de reloj de 20Mhz:

; ********************************************************************************************************
; Retardos desde 10useg a 50 useg
; ********************************************************************************************************
CBLOCK
R_ContA
ENDC


Wait_50useg
movlw d'XXX'
goto Bucle_Microseg

Wait_40useg
movlw d'XXX'
goto Bucle_Microseg

Wait_20useg
movlw d'XXX'
goto Bucle_Microseg

Wait_10useg
movlw d'XXX'


; ********************************************************************************************************
; Bucle de Retardo Simple
; ********************************************************************************************************

Bucle_Microseg
movwf R_ContA

Bucle_Interno
decfsz R_ContA,F
goto Bucle_Interno
return

Teoricamente esta seria la manera de crear una mini-libreria de retardos de entre 10 y 50 microsegundos. ¿Como puedo calcular el valor de XXX para obtener los retardos deseados?. Todo esto teniendo en cuenta que funcionaria a una frecuencia de 20Mhz por lo que 1 ciclo maquina duraria 200 nanosegundos.


La llamada CALL al retardo 2 Ciclos Maquina
movimiento de XXX a W 1 Ciclo Maquina
El salto goto al bucle 2 Ciclos Maquina
movimiento de W a R_ContA 1 Ciclo Maquina
decremento R_ContA 1 Ciclo Maquina
El salto o bien a Bucle_Interno o bien el return 2 Ciclos Maquina

En total 9 ciclos Maquina = 1,8 microseg


Por lo que deduzco que la constante XXX vendria dada por la formula

XXX= (TIEMPO-9)/0,2


Ejemplo, para obtener el valor de XXX para un retardo de 10microsegunos

XXX =(10-9)/0,2=5

¿Seria correcta esta deduccion?


Un saludo

Hola:
No se si es la respuesta que buscas, pero para el calculo de temporizaciones se usa la siguiente formula:

Temporizacion[ms] = 4 . Tclock . valor de cuenta del TMR0 . prescaler

Como ves, la temporizacion buscada es un multiplo del ciclo de instruccion.

En la formula:

4 . Tclock = 1 ciclo de instruccion. Tclock = 1/fclock; donde, fclock, es la frecuencia del oscilador que estas usando.

valor de cuenta del TMR0: es el valor que pretendes que cuente el TMR0 para lograr la temprizacion buscada. Recuerda que el timer funcionando como contador sincronico, cuenta de 0 a 255 y desborda produciendo overflow. Pero, si le cargo un valor al inicio, puedo hacer que cuente a partir de alli hasta 255.

prescaler: es el divisor programable con que cuenta el PIC. Esta ubicado en el registro OPTION. Ejemplo, si escribes en los tres primeros bits de dicho registro 000, logras dividir la frecuencia por 2. Si escribes 001, la divides por 4...., asi hasta 111, donde divides por 256

Por lo tanto, para lograr una temporizacion determinada, por ej. 1ms trabajando a fclock= 4MHz, haces lo siguiente:

1/4MHz= 250ns, y por lo tanto, 4 . 250ns= 1 us de ciclo de instruccion.

Te queda entonces 1ms = 1us . X

Luego, determinas el valor de X. En este caso, X=1000. Es el multiplo del ciclo de instruccion que buscas.

Lo que debes hacer ahora es el "ajuste fino" y el "ajuste grueso" para lograr de la forma mas exacta el multiplo de ciclo de intruccion calculado recien. Esto la haces ajustando el prescaler (ajuste grueso) y el valor de cuenta del TMR0 (ajuste fino).

En este caso, puedes hacer valor de cuenta= 125 y prescaler=8. (8.125=1000).
Es decir, debes escribir 010 en los bits PS2-PS1-PS0 de OPTION. Esto equivale a prescaler=8.
Luego cargar al inicio en el TMR0, el valor 131 (256 - 125), para que cuente a partir de alli hasta su desborde.

Para determinar el overflow del TMR0, testeas el bit T0IF (bandera de desborde de TMR0) del registro INTCON.

Espero te sirva.

Un saludo cordial.