Time Off Delay (TOF) & Time On Delay (TON)

[okapi]

Estimado amigo Dogflu66.
He probado el código que tan gentilmente me proporcionaste, lo he revisado minuciosamente pero
por alguna razón no me funciona.
Puse un LED de testigo en la rutina de interrupción para ver si los contadores están decrementando y llegando a cero y si lo hacen, es decir funcionan.
El problema parece estar en la parte del bucle Inicio:
Sw1 enciende el LED, como un switch normal, sin retardo y lo mismo sucede con SW2 que lo apaga sin retardo.
Es como si en esa parte los contadores siempre estuvieran en cero.
Qué podrá ser?
Por si ayuda, adjunto imagen del código
Saludos!

[DominusDRR]

Este también te va a dar problemas porque se queda en lazos infinitos esperando el pulsador o la bandera. (Instrucciones While)

Deberías pensar en multitareas con procesos cooperativoss, y para tu caso no es necesario utilizar interrupciones, solamente un temporizador siempre activo para obtener su valor y generar retardos.

Si, amigo eso también pensé, al ver los While.
Por favor podrías ser más especifico con lo del temporizador siempre activo?
De ser posible un pequeño ejemplo que me guíe sería muy gentil de tu parte.
Saludos!

Con el microcontrolador que tienes y con un temporizador de 16 bits, con su máximo post escalamiento de 8 (asumiendo que el cristal es de 4MHz) me parece que máximo podrías conseguir 0.5 segundos de tiempo.

Por lo tanto necesitarías una variable auxiliar de 16 bits y con el código de don dogflu66, se podría hacer la siguiente parte solamente es para “aumentar” la capacidad del temporizador.

Código: QBasic/QuickBASIC

1. DIM VariableAuxiliar AS UShort
2.  
3. .....
4.  
5. ON Interrupt
6.         Save SYSTEM  'Guarda calculos intermedios y otros del sistema
7.         'Detecta interrupción Timer1
8.         IF PIR1.TMR1IF = 1 THEN
9.                 PIR1.TMR1IF = 0  'Flash dosborde a cero
10.                 VariableAuxiliar = VariableAuxiliar + 1;
11.         Endif
12. RESUME

Con esto tienes una variable (sin signo) que puede contar hasta 65.5 segundos

El siguiente paso es comprender la forma errónea de realizar un retardo, como tu mismo lo indicantes se apropia del CPU del microcontrolador y no puedes hacer otros procesos, salvo que sólo sea el único proceso.




Para evitar un apropiamiento del CPU se puede recurrir a una variable que captura el valor del temporizador (o en este caso, la variable auxiliar) y determinar si se ha determinado que ha transcurrido un tiempo determinado.



Un ejemplo para activar y apagar un led sería más o menos así:

Código: QBasic/QuickBASIC

1. DIM VariableAuxiliar AS UShort
2. DIM Retardo Ad Ushort
3.  
4. Main:
5.                 Low led1  ‘ apago el led
6.                 Retardo = VariableAuxiliar
7. Lazo:
8.                IF ((VariableAuxiliar - Retardo) > 2000) THEN
9.                              TOGGLE led1
10.                              Retardo = VariableAuxiliar’ Vuelvo a capturar un nuevo valor para otro retardo
11.                 Endif
12. GOTO Lazo

Como puedes ver, sólo se verifica si el IF se cumple, caso contrario podría pasar a realizar otro proceso.

Si comprendes esto, se podría intentar hacer tu proyecto de esta manera.

[okapi]

Con el microcontrolador que tienes y con un temporizador de 16 bits, con su máximo post escalamiento de 8 (asumiendo que el cristal es de 4MHz) me parece que máximo podrías conseguir 0.5 segundos de tiempo.

Por lo tanto necesitarías una variable auxiliar de 16 bits y con el código de don dogflu66, se podría hacer la siguiente parte solamente es para “aumentar” la capacidad del temporizador.

Código: QBasic/QuickBASIC

1. DIM VariableAuxiliar AS UShort
2.  
3. .....
4.  
5. ON Interrupt
6.         Save SYSTEM  'Guarda calculos intermedios y otros del sistema
7.         'Detecta interrupción Timer1
8.         IF PIR1.TMR1IF = 1 THEN
9.                 PIR1.TMR1IF = 0  'Flash dosborde a cero
10.                 VariableAuxiliar = VariableAuxiliar + 1;
11.         Endif
12. RESUME

Con esto tienes una variable (sin signo) que puede contar hasta 65.5 segundos

El siguiente paso es comprender la forma errónea de realizar un retardo, como tu mismo lo indicantes se apropia del CPU del microcontrolador y no puedes hacer otros procesos, salvo que sólo sea el único proceso.




Para evitar un apropiamiento del CPU se puede recurrir a una variable que captura el valor del temporizador (o en este caso, la variable auxiliar) y determinar si se ha determinado que ha transcurrido un tiempo determinado.



Un ejemplo para activar y apagar un led sería más o menos así:

Código: QBasic/QuickBASIC

1. DIM VariableAuxiliar AS UShort
2. DIM Retardo Ad Ushort
3.  
4. Main:
5.                 Low led1  ‘ apago el led
6.                 Retardo = VariableAuxiliar
7. Lazo:
8.                IF ((VariableAuxiliar - Retardo) > 2000) THEN
9.                              TOGGLE led1
10.                              Retardo = VariableAuxiliar’ Vuelvo a capturar un nuevo valor para otro retardo
11.                 Endif
12. GOTO Lazo

Como puedes ver, sólo se verifica si el IF se cumple, caso contrario podría pasar a realizar otro proceso.

Si comprendes esto, se podría intentar hacer tu proyecto de esta manera.

DominusDRR
Muchas gracias por tus explicaciones, son mu ilustrativas y valoro mucho tu ayuda desinteresada.
Si te fijas en el post #19 de la página dos, ahí publique un código donde utilizo variables auxiliares para, partiendo de los desbordes, generar segundos.
Reitero, mi problema no está en conseguir los retardos, eso ya lo he logrado.
Mi inconveniente está en que no soy capaz de colocarlos en el sitio que corresponden, no sé cómo hacerlo.
Quizás sea sencillo, pero para un inexperto como yo, no lo es.
Adjunto una imagen para ilustrar lo dicho.
Gracias nuevamente
 

[DominusDRR]

Si tu dices que te funciona bien el código que has realizado, como dice don  dogflu66, debes realizar un conteo mas preciso, digamos milisegundos, pero aceptemos tu código y utilicemos décimas de segundo, entonces tu código de la interrupción quedaría así:

Código: QBasic/QuickBASIC

1. ON Interrupt
2. IF PIR1.0 = 1 THEN        
3.     Pulsos=Pulsos+1  
4. EndIf

Pulsos se incrementan cada 0.1 segundos (por eso cuando es igual a 10 en tu anterior código, asumes que es 1 segundo.

Nota que nunca deshabilito la interrupción. es decir nunca utilizo Disable, similar a la interrupción de dogflu66

También declara a pulsos como una variable sin signo.

Ahora vamos a tu código:

Código: QBasic/QuickBASIC

1. ON Interrupt GOTO interpt
2.  
3. DIM Pulsos AS UShort
4. DIM ContadorPulsos AS UShort
5. EstadoTarea VAR BYTE
6. Segundos VAR BYTE
7. Bandera_seg VAR BIT
8.  
9. SW1 Var Bit
10. SW2 Var Bit
11. LED1 Var Bit
12.  
13.  
14. Main:
15.        EstadoTarea = 0x00;' Inicializo EstadoTarea
16.         LOWLED1' apago el led inicialmente
17. Lazo:
18.         SELECT CASE EstadoTarea
19.               CASE 0 ' en case 0, se espera a que presionen sw1
20.                  IF SW1=0  THEN
21.                      HIGH LED1    'Al presionar SW1 se enciende el LED
22.                     EstadoTarea = 1' voy al siguiente caso
23.                 Endif
24.               CASE 1' Espero a que presionen el pulsador SW2 para empezar el retardo
25.                    IF SW2=0  THEN
26.                     ContadorPulsos = Pulsos' Capturo el valor de pulsos
27.                     EstadoTarea = 2' voy al siguiente caso
28.                 Endif
29.               CASE 2' Espero que hayan pasado 20 pulsos (20 pulsos x 0.1s = 2 segundos)
30.                  IF ((Pulsos- ContadorPulsos) > 20) THEN
31.                               LOWLED' apago el led
32.                               EstadoTarea = 0' regreso al primer estado
33.                 Endif
34.         EndSelect
35. GOTO Lazo:

[dogflu66]

Entiendo que pulsas una tecla y pasado un tiempo se actualiza el estado del led.
Una tecla es para activarlo y la otra tecla para apagarlo.
Todo esto sin afectar al flujo del programa.
¿Estoy en lo cierto?.

[dogflu66]

Aparte de lo anterior, el código que pusiste antes está como imagen, por lo que no puedo copiarlo y pegarlo en mi IDE.
De todas formas lo he probado y si me funciona, aunque este código solo es un ejemplo y no hace exactamente lo que quieres.

Código: QBasic/QuickBASIC

1. #define CONFIG = 0x3f50
2. #define CLOCK_FREQUENCY = 4
3. CMCON = 7
4. DIM precarga AS Word
5. DIM _contador1 AS Word
6. DIM _contador2 AS Word
7. Symbol led1 = PORTB.0
8. Symbol led2 = PORTB.1
9. Symbol sw1 = PORTA.2
10. Symbol sw2 = PORTA.3
11.  
12. TRISA = %11111111
13. TRISB = %00000000
14.  
15. PORTB = 0
16. led1 = 0
17. led2 = 0
18. _contador1 = 0
19. _contador2 = 0
20.  
21. T1CON = %00111101
22. precarga = 0xfc17
23. TMR1H = precarga.HB
24. TMR1L = precarga.LB
25. PIE1.0 = 1
26. INTCON = %11000000
27.  
28. 'On itenrrupt Goto interrupcion
29.  
30. inicio:
31.  
32. IF sw1 = 0 AND _contador1 = 0 THEN
33.         High led1
34.         _contador1 = 1000
35. Endif
36.  
37. IF sw2 = 0 AND _contador2 = 0 THEN
38.         Low led1
39.         _contador2 = 2000
40. Endif
41.  
42. GOTO inicio
43. END                                              
44.  
45. ON Interrupt  '= a nombre subrutina interrupción y hace Disable
46. 'Disable
47.         IF PIR1.0 = 1 THEN
48.                 T1CON.0 = 0
49.                 TMR1H = precarga.HB
50.                 TMR1L = precarga.LB
51.                 T1CON.0 = 1
52.                 PIR1.0 = 0
53.                 IF _contador1 > 0 THEN _contador1 = _contador1 - 1
54.                 IF _contador2 > 0 THEN _contador2 = _contador2 - 1
55.         Endif
56. 'Resume = fin rutina interrupción y hace Enable
57. RESUME

Y este es el código segun tu esquema:

Código: QBasic/QuickBASIC

1. AllDigital
2. ConfigPin RB0 = OUTPUT
3. ConfigPin RB1 = OUTPUT
4. ConfigPin RA2 = INPUT
5. ConfigPin RA3 = INPUT
6. Symbol led1 = RB0
7. Symbol led2 = RB1
8. Symbol sw1 = RA2
9. Symbol sw2 = RA3
10.  
11. 'Contadores para generar las bases de tiempos.
12. DIM _contador1 AS LONG
13. DIM _contador2 AS LONG
14. _contador1 = 0
15. _contador2 = 0
16. 'Flag de control
17. DIM flag1 AS Bit
18. DIM flag2 AS Bit
19. flag1 = 0
20. flag2 = 0
21.  
22. Main:
23.  
24.         'Temporizador no redisparable, para redisparable quitar flag1 = 0
25.         'Para ser bloqueado por el anterior añadir "and flag2 = 0"
26.         IF sw1 = 0 AND flag1 = 0 THEN
27.                 _contador1 = 1000
28.                 flag1 = 1
29.         ELSE
30.                 IF _contador1 = 0 AND flag1 = 1 THEN
31.                         High led1
32.                         flag1 = 0
33.                 Endif
34.         Endif
35.         'Temporizador no redisparable, para redisparable quitar flag2 = 0
36.         'Para ser bloqueado por el anterior añadir "and flag1 = 0"
37.         IF sw2 = 0 AND flag2 = 0 THEN
38.                 _contador1 = 2000
39.                 flag2 = 1
40.         ELSE
41.                 IF _contador1 = 0 AND flag2 = 1 THEN
42.                         Low led1
43.                         flag2 = 0
44.                 Endif
45.         Endif
46.        
47. GOTO Main

[dogflu66]

Si tu dices que te funciona bien el código que has realizado, como dice don  dogflu66, debes realizar un conteo mas preciso, digamos milisegundos, pero aceptemos tu código y utilicemos décimas de segundo, entonces tu código de la interrupción quedaría así:

Código: QBasic/QuickBASIC

1. ON Interrupt
2. IF PIR1.0 = 1 THEN        
3.     Pulsos=Pulsos+1  
4. EndIf

Pulsos se incrementan cada 0.1 segundos (por eso cuando es igual a 10 en tu anterior código, asumes que es 1 segundo.

Nota que nunca deshabilito la interrupción. es decir nunca utilizo Disable, similar a la interrupción de dogflu66

También declara a pulsos como una variable sin signo.

Ahora vamos a tu código:

Código: QBasic/QuickBASIC

1. ON Interrupt GOTO interpt
2.  
3. DIM Pulsos AS UShort
4. DIM ContadorPulsos AS UShort
5. EstadoTarea VAR BYTE
6. Segundos VAR BYTE
7. Bandera_seg VAR BIT
8.  
9. SW1 Var Bit
10. SW2 Var Bit
11. LED1 Var Bit
12.  
13.  
14. Main:
15.        EstadoTarea = 0x00;' Inicializo EstadoTarea
16.         LOWLED1' apago el led inicialmente
17. Lazo:
18.         SELECT CASE EstadoTarea
19.               CASE 0 ' en case 0, se espera a que presionen sw1
20.                  IF SW1=0  THEN
21.                      HIGH LED1    'Al presionar SW1 se enciende el LED
22.                     EstadoTarea = 1' voy al siguiente caso
23.                 Endif
24.               CASE 1' Espero a que presionen el pulsador SW2 para empezar el retardo
25.                    IF SW2=0  THEN
26.                     ContadorPulsos = Pulsos' Capturo el valor de pulsos
27.                     EstadoTarea = 2' voy al siguiente caso
28.                 Endif
29.               CASE 2' Espero que hayan pasado 20 pulsos (20 pulsos x 0.1s = 2 segundos)
30.                  IF ((Pulsos- ContadorPulsos) > 20) THEN
31.                               LOWLED' apago el led
32.                               EstadoTarea = 0' regreso al primer estado
33.                 Endif
34.         EndSelect
35. GOTO Lazo:

Te salió un código muy elegante 

[DominusDRR]

Si tu dices que te funciona bien el código que has realizado, como dice don  dogflu66, debes realizar un conteo mas preciso, digamos milisegundos, pero aceptemos tu código y utilicemos décimas de segundo, entonces tu código de la interrupción quedaría así:

Código: QBasic/QuickBASIC

1. ON Interrupt
2. IF PIR1.0 = 1 THEN        
3.     Pulsos=Pulsos+1  
4. EndIf

Pulsos se incrementan cada 0.1 segundos (por eso cuando es igual a 10 en tu anterior código, asumes que es 1 segundo.

Nota que nunca deshabilito la interrupción. es decir nunca utilizo Disable, similar a la interrupción de dogflu66

También declara a pulsos como una variable sin signo.

Ahora vamos a tu código:

Código: QBasic/QuickBASIC

1. ON Interrupt GOTO interpt
2.  
3. DIM Pulsos AS UShort
4. DIM ContadorPulsos AS UShort
5. EstadoTarea VAR BYTE
6. Segundos VAR BYTE
7. Bandera_seg VAR BIT
8.  
9. SW1 Var Bit
10. SW2 Var Bit
11. LED1 Var Bit
12.  
13.  
14. Main:
15.        EstadoTarea = 0x00;' Inicializo EstadoTarea
16.         LOWLED1' apago el led inicialmente
17. Lazo:
18.         SELECT CASE EstadoTarea
19.               CASE 0 ' en case 0, se espera a que presionen sw1
20.                  IF SW1=0  THEN
21.                      HIGH LED1    'Al presionar SW1 se enciende el LED
22.                     EstadoTarea = 1' voy al siguiente caso
23.                 Endif
24.               CASE 1' Espero a que presionen el pulsador SW2 para empezar el retardo
25.                    IF SW2=0  THEN
26.                     ContadorPulsos = Pulsos' Capturo el valor de pulsos
27.                     EstadoTarea = 2' voy al siguiente caso
28.                 Endif
29.               CASE 2' Espero que hayan pasado 20 pulsos (20 pulsos x 0.1s = 2 segundos)
30.                  IF ((Pulsos- ContadorPulsos) > 20) THEN
31.                               LOWLED' apago el led
32.                               EstadoTarea = 0' regreso al primer estado
33.                 Endif
34.         EndSelect
35. GOTO Lazo:

Te salió un código muy elegante 

[okapi]

Aparte de lo anterior, el código que pusiste antes está como imagen, por lo que no puedo copiarlo y pegarlo en mi IDE.
De todas formas lo he probado y si me funciona, aunque este código solo es un ejemplo y no hace exactamente lo que quieres.

Dogflu66, gracias por estar pendiente con la resolución de este tema.
El código que mencionas que está como imagen, no es si no, el código que tu sugeriste en el post #23  y que yo solo lo adapté a PBP.

[okapi]

Entiendo que pulsas una tecla y pasado un tiempo se actualiza el estado del led.
Una tecla es para activarlo y la otra tecla para apagarlo.
Todo esto sin afectar al flujo del programa.
¿Estoy en lo cierto?.

Bien como he mencionado en el título de este tema, son dos  tareas:
1.-  On Delay, es decir, presiono el botón rápidamente una sola vez y después de unos segundos (1, 2 o n segundos) se enciende el LED.
2.- Off Delay, es decir, es decir presiono el botón rápidamente una sola vez y transcurridos  (1, 2 o n segundos) el LED que estaba encendido, se apaga.
Saludos!

[okapi]

Si tu dices que te funciona bien el código que has realizado, como dice don  dogflu66, debes realizar un conteo mas preciso, digamos milisegundos, pero aceptemos tu código y utilicemos décimas de segundo, entonces tu código de la interrupción quedaría así:

DominusDRR, Soy una persona adulta, y si digo que he logrado obtener retardos por desborde del timer, es porque es así.
No sé por qué tanta desconfianza en mi capacidad para lograr hacer un retardo con el timer del PIC.
Antes de lograrlo tuve que como muchos de ustedes, leer bastante teoría y con pruebas sucesivas y en orden de complejidad aprender a hacerlo.
He buscado mucho sobre los temas de retardos On Delay y Off Delay, pero hay poquísima información sobre el tema en lo que a lenguaje Basic para PICs se refiere, en cambio para lenguaje "C" logré encontrar algo pero como no estoy familiarizado con ese lenguaje, me resulta indescifrable.
Saludos!

[DominusDRR]

DominusDRR, Soy una persona adulta, y si digo que he logrado obtener retardos por desborde del timer, es porque es así.
No sé por qué tanta desconfianza en mi capacidad para lograr hacer un retardo con el timer del PIC.
Saludos!

No es desconfianza, solamente quería indicar lo que dice dogflu66, se debe contar milisegundos y en función de eso obtener tiempos más grandes como segundos.

Lamento mucho si hubo un mal entendido cultural. También tengo varios años trabajando en sistemas embebidos y comprendo que a veces toma tiempo comprender conceptos nuevos y/o complejos.

[Eduardo2]

...
Bien como he mencionado en el título de este tema, son dos  tareas:
1.-  On Delay, es decir, presiono el botón rápidamente una sola vez y después de unos segundos (1, 2 o n segundos) se enciende el LED.
2.- Off Delay, es decir, es decir presiono el botón rápidamente una sola vez y transcurridos  (1, 2 o n segundos) el LED que estaba encendido, se apaga.
Saludos!

Habiendo leido que no podías usar PAUSE , una manera de hacerlo es mediante una interrupción periódica que maneje contadores descendentes que al llegar a 0 ejecuten lo que corresponda.
Cuando se utilizan períodos de 1ms, 10ms etc , la cuenta inicial son el número de milisegiundos, centésimas de segundos etc. Pero cuando no lo es no pasa nada porque lo que se introduce es el número de períodos.

Por ejemplo:
Declaro un par de contadores para los contadores y las cuentas para 1,2 segundos (o mas)

Código: [Seleccionar]

T1s CON 1*61    ; Conteos para 1seg con interrupciones cada 16.384ms
                ; T2s : 1*(1000/16.384) = 61
T1 VAR WORD     ; Variable que lleva el conteo

T2s CON 2*61    ; Conteos para 2seg con interrupciones cada 16.384ms
                ; T2s : 2*(1000/16.384) = 122
T2 VAR WORD     ; Variable que lleva el conteo

Y mas adelante

Código: [Seleccionar]

............
Main:
    IF SW1=0  THEN T1=T1s  ;Con T1>0 se dispara el conteo
                           ;La cuenta es descendente y en 0 activa el led
   
    IF SW2=0  THEN T2=T2s  ;Con T2>0 se dispara el conteo
                           ;La cuenta es descendente y en 0 desactiva el led
    Goto Main
 
interpt: 
    disable   
   
    if T1>0 then               
        T1 = T1-1
        if T1=0 then HIgh LED1
    endif
   
    if T2>0 then               
        T2 = T2-1
        if T2=0 then LOW LED1
    endif
   
    INTCON.2 = 0    ' Reset timer interrupt flag
    resume


[okapi]

DominusDRR, Soy una persona adulta, y si digo que he logrado obtener retardos por desborde del timer, es porque es así.
No sé por qué tanta desconfianza en mi capacidad para lograr hacer un retardo con el timer del PIC.
Saludos!

No es desconfianza, solamente quería indicar lo que dice dogflu66, se debe contar milisegundos y en función de eso obtener tiempos más grandes como segundos.

Lamento mucho si hubo un mal entendido cultural. También tengo varios años trabajando en sistemas embebidos y comprendo que a veces toma tiempo comprender conceptos nuevos y/o complejos.

No hay Problema!
El caso es que estamos siendo redundantes con el asunto del retardo.
Bueno espero que con la siguiente información, ese asunto lo demos por sentado.
Bien, al emplear el  PIC 16F628A y su Timer1 de 16 bits, para obtener desbordes cada 100 milisegundos, deberé hacer una precarga de 53036 con oscilador de 4 MHz y un prescaler de 1:8.
Entonces si cuento diez desbordes de 100 ms obtendré 1sg.
Lo que a partir de este momento deberíamos tratar debería ser cómo ingeniarnos para valiendonos de los retardos obtenidos, implementar  los temporizadores On Delay y Off Delay que estoy seguro serán de utilidad para muchos.

[DominusDRR]

No había leído que necesitabas un ON delay al presionar SW1, en el caso que ocupes mi código, se necesita un estado adicional a la tarea

Código: QBasic/QuickBASIC

1. Main:
2.        EstadoTarea = 0x00;' Inicializo EstadoTarea
3.         LOWLED1' apago el led inicialmente
4. Lazo:
5.         SELECT CASE EstadoTarea
6.               CASE 0 ' en case 0, se espera a que presionen sw1
7.                  IF SW1=0  THEN
8.                     ContadorPulsos = Pulsos' Capturo el valor de pulsos
9.                     EstadoTarea = 1' voy al siguiente caso
10.                 Endif
11.               CASE 1
12.                      IF ((Pulsos- ContadorPulsos) > 10) THEN' espero ha que pase 1 segundo
13.                               HIGH LED1    
14.                               EstadoTarea = 2
15.                      Endif
16.               CASE 2' Espero a que presionen el pulsador SW2 para empezar el retardo
17.                    IF SW2=0  THEN
18.                     ContadorPulsos = Pulsos' Capturo el valor de pulsos, nuevamente
19.                     EstadoTarea = 3' voy al siguiente caso
20.                 Endif
21.               CASE 3' Espero que hayan pasado 20 pulsos (20 pulsos x 0.1s = 2 segundos)
22.                  IF ((Pulsos- ContadorPulsos) > 20) THEN
23.                               LOWLED' apago el led
24.                               EstadoTarea = 0' regreso al primer estado
25.                 Endif
26.         EndSelect
27. GOTO Lazo: