TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: iNoXSteeL en 24 de Septiembre de 2009, 12:29:58

Título: Cuenta atrás programable
Publicado por: iNoXSteeL en 24 de Septiembre de 2009, 12:29:58
Hola a todos,

Estoy intentando hacer una cuenta atrás programable de 4 dígitos con 7 segmentos, al estilo temporizador de microondas.

El problema viene cuando intento preseleccionar el tiempo, es decir, lo tengo hecho para 1 hora, programo los minutos y segundos que quiero contar atrás y... hace cosas muy raras, si programo 4 sec y 2 min, la cuenta atrás la hace solo de 2 sec, no pasa por el 9..

Os expongo el código a ver si me podéis aclarar en donde estoy cometiendo el fallo:

Código: C
  1. #include <16f876.h>
  2. #fuses XT,NOPUT,NOWDT,NOLVP,NOPROTECT
  3. #use delay(clock=4000000)
  4. #use fast_io(a)
  5. #use fast_io(b)
  6. #use fast_io(c)
  7. #byte portb = 0x06
  8. #byte portc = 0x07
  9.  
  10.  
  11.  
  12. int numeros[10]={0b00111111,0b00000110,
  13.                  0b01011011,0b01001111,
  14.                  0b01100110,0b01101101,
  15.                  0b01111101,0b00000111,
  16.                  0b01111111,0b01100111};
  17.  
  18. int minutos,segundos,segundosd,minutosd,start,rep;
  19.  
  20. signed int sec,min,sec2,min2;
  21.  
  22. void main()
  23. {
  24. set_tris_a(0b111111);
  25. set_tris_b(0x00);
  26. set_tris_c(0x00);
  27.  
  28. start=0;
  29. minutos=0; segundos=0;
  30. minutosd=0; segundosd=0;
  31. portb=0x00; portc=0x00;
  32.  
  33.  
  34. while(true){
  35.  
  36. if (input(pin_a2)) start=1;
  37. if (input(pin_a1)) {delay_ms(500); minutos++; }               //Aquí se supone que es la forma de preseleccionar                      
  38. if (input(pin_a3)) {delay_ms(500); segundos++; }              //El tiempo que quiero contar atrás
  39. if (segundos>9){segundos=0; segundosd++;}                     //Como mucho 59 sec y 59 minutos
  40. if (segundos>9 && segundosd>5) {segundos=0;segundosd=0;}
  41. if (minutos>9){ minutos=0; minutosd++;}
  42. if (minutosd>5 && minutos>9){minutos=0; minutosd=0;}
  43.  
  44.            portb =0b00001111;                                 //Aquí muestro que tiempo tengo seleccionado
  45.            portc=numeros[segundos];
  46.            delay_ms(10);
  47.            portb=0b00010111;
  48.            portc=numeros[segundosd];
  49.            delay_ms(10);
  50.            portb=0b00011011;
  51.            portc=numeros[minutos];
  52.            delay_ms(10);    
  53.            portb=0b00011101;
  54.            portc=numeros[minutosd];
  55.            delay_ms(10);
  56.  
  57.  
  58. if (start==1){                                         //empiezo a contar cuando pulso start...
  59. portb=0x00; portc=0x00;
  60. for (min2=minutosd ; min2>=0 ;  min2--){                
  61.   for (min=minutos ; min>=0 ; min--){
  62.       for (sec2=segundosd;sec2>=0 ; sec2--){
  63.          for (sec=segundos;sec>=0;sec--){
  64.            for (rep=0 ; rep <25; rep++){
  65.            portb =0b00001111;
  66.            portc=numeros[sec];
  67.            delay_ms(10);
  68.            portb=0b00010111;
  69.            portc=numeros[sec2];
  70.            delay_ms(10);
  71.            portb=0b00011011;
  72.            portc=numeros[min];
  73.            delay_ms(10);    
  74.            portb=0b00011101;
  75.            portc=numeros[min2];
  76.            delay_ms(10);
  77.            if (min2==0 && min == 0 && sec2==0 && sec==0)
  78.            {portb=0x00; portc=0x00; start=0;}
  79. }}}}}}}}

Si uso el bucle normalmente, funciona:

Código: C
  1. for (min2=5 ; min2>=0 ;  min2--){                
  2.   for (min=9 ; min>=0 ; min--){
  3.       for (sec2=5 ;sec2>=0 ; sec2--){
  4.          for (sec=9 ;sec>=0 ; sec--){
  5.            for (rep=0 ; rep <25; rep++){
  6.            portb =0b00001111;
  7.            portc=numeros[sec];
  8.            delay_ms(10);
  9.            portb=0b00010111;
  10.            portc=numeros[sec2];
  11.            delay_ms(10);
  12.            portb=0b00011011;
  13.            portc=numeros[min];
  14.            delay_ms(10);    
  15.            portb=0b00011101;
  16.            portc=numeros[min2];
  17.            delay_ms(10);

Gracias de antemano

Un saludo.
Título: Re: Cuenta atrás programable
Publicado por: KALLITOS en 24 de Septiembre de 2009, 13:19:19
Hola ALF  :mrgreen:, de primera el problema que veo es que usas signed int cuando no es necesario, signed int es para usar numeros  entre -127 y +127 (corriganme si me equivoco), cambialo por solo int8 y sigu probando.
Justo en estas fechas estoy trabajando con un timer tal cual explicas pero solo minutos y segundos, asi que llegando a casa (domingo mas o menos) subire un poco de codigo para que observes.

saludos
Título: Re: Cuenta atrás programable
Publicado por: iNoXSteeL en 24 de Septiembre de 2009, 13:36:53
Hola Kallitos,

El caso es que si no uso signed int no funciona la cuenta atrás, y eso me ha pasado con otros más sencillos, creo que es porque cuando decrementa, para mostrar nuevamente el 0 tiene que pasar por -1 y sin el signed int no funciona, al menos en los casos que he tenido. Quizá lo haga yo mal  :oops:

Un saludo.
Título: Re: Cuenta atrás programable
Publicado por: MLO__ en 24 de Septiembre de 2009, 14:50:27
Hola.

Si la cuenta es regresiva si necesitas que sea signed int para validar el dato cuando es menor que cero.

Respecto a tu código, yo haría el despliegue de los 7 segmento mediante interrupción y, con unos flags, separaría los dos ciclos de trabajo, el de configuración de tiempo y el de conteo regresivo. No se si la precisión de la cuenta de tiempo sea determinante, pero si sería bueno hacer la cuenta con un timer.

7 Segmentos con int_TIMER0 (http://www.todopic.com.ar/foros/index.php?topic=21738.0)

Saludos
Título: Re: Cuenta atrás programable
Publicado por: KALLITOS en 24 de Septiembre de 2009, 15:53:02
Hola, cuando hago cuenta regresiva uso el siguiente codigo:

Código: C
  1. int minutos_u,minutos_d,segundos_u,segundos_d;
  2.  
  3. if(interrupcion_1_seg == 1)
  4. {
  5. interrupcion_1_seg = 0;
  6. segundos_u--;
  7. if(segundos_u > 9)
  8.   {
  9.    segundos_u = 9;
  10.    segundos_d--;
  11.    if(segundos_d > 5)
  12.      {
  13.      segundos_d = 5;
  14.      minutos_u--;
  15.      if (minutos_u > 9)
  16.         {
  17.          minutos_u = 9;
  18.          minutos_d--;
  19.          if(minutos_d > 5)
  20.            {
  21.             minutos_d = 5;
  22.            }
  23.          }
  24.       }
  25.    }
  26. }
Claro esta que este codigo solo se ejecutara cuando el flag de interrupcion de 1_seg sea activo.
Saludos
Título: Re: Cuenta atrás programable
Publicado por: MLO__ en 24 de Septiembre de 2009, 22:38:23
Hola.

Es una muy buena solución, aprovechar el desborde de la variable como 255. El flag se podria controlar con un Timer o incluso esa rutina puede ir directamente en la función de interrupción ya que no toma mucho tiempo.

Saludos
Título: Re: Cuenta atrás programable
Publicado por: iNoXSteeL en 25 de Septiembre de 2009, 12:56:39
Hola a todos,

MLO, agradezco tu ayuda, pero me queda grande tu código, es demasiado avanzado para mis novatos conocimientos  :oops:

Aunque creo que te refieres a usar el timer 0 como contador más preciso y llevar una variable que se encargaría del conteo de los números, no?

El caso es que lo he hecho funcionar, pero misteriosamente... no soy capaz de entender su funcionamiento...

Añadí el código que puso KALLITOS y además, añadí el decremente de la variable segundos... pero no lo entiendo, y de poco me sirve que funcione si no lo entiendo...  :(

Código: C
  1. while(true){
  2.  
  3. if (input(pin_a2)) start=1;
  4.  
  5. if (input(pin_a1)) {delay_ms(500); minutos++; }
  6. if (minutos>9){ minutos=0; minutosd++;}
  7. if (minutosd==6) minutosd=0;      
  8.  
  9. if (input(pin_a3)) {delay_ms(500); segundos++;}            
  10. if (segundos>9){segundos=0; segundosd++;}                    
  11. if (segundosd==6) segundosd=0;
  12.  
  13.            portb =0b00001110;                                
  14.            portc=numeros[segundos];
  15.            delay_ms(10);
  16.            portb=0b00010110;
  17.            portc=numeros[segundosd];
  18.            delay_ms(10);
  19.            portb=0b00011010;
  20.            portc=numeros[minutos];
  21.            delay_ms(10);    
  22.            portb=0b00011100;
  23.            portc=numeros[minutosd];
  24.            delay_ms(10);
  25.  
  26. if (start==1){                                        
  27.  
  28. for (min2=minutosd; min2>-1 ; min2--){
  29.   for (min=minutos; min>-1;  min--){
  30.     for (sec2=segundosd ; sec2>-1 ;sec2-- ){
  31.        for (sec=segundos; sec>-1 ; sec--){
  32.          segundos--;                                                   //EL AÑADIDO
  33.            for (rep=0 ; rep <25; rep++){
  34.  
  35.            portb =0b00101110;
  36.            portc=numeros[sec];
  37.            delay_ms(10);
  38.            portb=0b00110110;
  39.            portc=numeros[sec2];
  40.            delay_ms(10);
  41.            portb=0b00111010;
  42.            portc=numeros[min];
  43.            delay_ms(10);    
  44.            portb=0b00111100;
  45.            portc=numeros[min2];
  46.            delay_us(9300);
  47.        
  48.            if(segundos > 9){                                 //El codigo de KALLITOS modificado
  49.            segundos = 9; segundosd--;
  50.            if(segundosd > 5) {
  51.            segundosd = 5; minutos--;
  52.            if (minutos > 9){
  53.            minutos = 9; minutosd--;
  54.            if(minutosd > 5) {
  55.            minutosd = 5;}}}}
  56.            
  57.            if (min==0 && sec==0 && min2==0 && sec2==0) reset();
  58. }}}}}}}}

Gracias por vuestra atención

Un saludo
Título: Re: Cuenta atrás programable
Publicado por: KALLITOS en 25 de Septiembre de 2009, 13:20:03
Hola ALF  :mrgreen:, el codigo que coloque esta por demas de sencillo, analiza un poco y entenderas el funcionamiento. Esta muy facil ;-).

Saludos
Título: Re: Cuenta atrás programable
Publicado por: iNoXSteeL en 25 de Septiembre de 2009, 13:26:52
Hola KALLITOS,

No me refería a como funciona tu código, eso está claro, lo que no acabo de entender es como funciona tu código dentro del mío y hace que funcione .... estoy intrigadísimo por más vueltas que le doy...

Título: Re: Cuenta atrás programable
Publicado por: KALLITOS en 25 de Septiembre de 2009, 23:11:36
Hola ALF  :D.

Sacando cuentas, si sumas 9300 uS + 10 mS + 10 mS + 10 mS = 40 mS (teniendo en cuentas mas o menos las demoras por el codigo mismo), y esto con el for de 25 se obtiene 40 mS x 25 = 1000 mS o 1 S.

Por lo demas es un lio  :lol:, entiendo lo que quieres hacer pero creo no concuerda con lo que hace tu codigo; esto:
Código: C
  1. for (min2=minutosd; min2>-1 ; min2--){  
  2. for (min=minutos; min>-1;  min--){    
  3. for (sec2=segundosd ; sec2>-1 ;sec2-- ){      
  4. for (sec=segundos; sec>-1 ; sec--){
Creo que hace lo mismo que esto:
Código: C
  1. if (min==0 && sec==0 && min2==0 && sec2==0) reset();
supongo que el reset(); es para que puedas preguntar si se inicia el conteo nuevamente.

Que tal chongo  :D
Título: Re: Cuenta atrás programable
Publicado por: iNoXSteeL en 26 de Septiembre de 2009, 11:14:19
Bueno... si que es un lio, el caso es que funciona  :mrgreen:, pero como no entendía como, escribí un nuevo código  :D

Esta vez, hago como me recomendó MLO, con el timer0 y una variable..

Código: C
  1. #include <16f876.h>                            
  2. #fuses XT,NOPUT,NOWDT,NOLVP,NOPROTECT          
  3. #use delay(clock=4000000)
  4. #use fast_io(a)
  5. #use fast_io(b)
  6. #use fast_io(c)
  7. #byte portb = 0x06
  8. #byte portc = 0x07
  9.  
  10. int numeros[10]={0b00111111,0b00000110,
  11.                  0b01011011,0b01001111,
  12.                  0b01100110,0b01101101,
  13.                  0b01111101,0b00000111,
  14.                  0b01111111,0b01100111};
  15.  
  16. signed int minutos,segundos,segundosd,minutosd;
  17.  
  18. int start,contador,cuenta;
  19.  
  20.  
  21. void reset(){
  22. start=0;
  23. minutos=0; segundos=0;
  24. minutosd=0; segundosd=0;
  25. portb=0x00; portc=0x00;
  26. cuenta=0; contador=0;
  27. }
  28.  
  29. #int_timer0
  30. void timer0_isr(void)
  31. {
  32. contador++;
  33. if (contador=250) cuenta=1; contador=0;
  34. set_timer0(0x06);
  35. }
  36.  
  37. void main()
  38. {
  39. set_tris_a(0b111111);
  40. set_tris_b(0x00);
  41. set_tris_c(0x00);
  42.  
  43. reset();
  44.  
  45. setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
  46. setup_timer_0(0x06);
  47. enable_interrupts(int_timer0);
  48. enable_interrupts(GLOBAL);
  49.  
  50.  
  51. while(true){
  52.  
  53. if (input(pin_a2)) start=1;
  54.  
  55. if (input(pin_a1)) {delay_ms(500); minutos++; }
  56. if (minutos>9){ minutos=0; minutosd++;}
  57. if (minutosd==6) minutosd=0;      
  58.  
  59. if (input(pin_a3)) {delay_ms(500); segundos++;}            
  60. if (segundos>9){segundos=0; segundosd++;}                    
  61. if (segundosd==6) segundosd=0;
  62.  
  63.            portb =0b00001110;                                
  64.            portc=numeros[segundos];
  65.            delay_ms(10);
  66.            portb=0b00010110;
  67.            portc=numeros[segundosd];
  68.            delay_ms(10);
  69.            portb=0b00011010;
  70.            portc=numeros[minutos];
  71.            delay_ms(10);    
  72.            portb=0b00011100;
  73.            portc=numeros[minutosd];
  74.            delay_ms(10);
  75.  
  76. if (start==1){                                        
  77.  
  78. while(true){
  79.  
  80.            portb =0b00101110;
  81.            portc=numeros[segundos];
  82.            delay_ms(10);
  83.            portb=0b00110110;
  84.            portc=numeros[segundosd];
  85.            delay_ms(10);
  86.            portb=0b00111010;
  87.            portc=numeros[minutos];
  88.            delay_ms(10);    
  89.            portb=0b00111100;
  90.            portc=numeros[minutosd];
  91.            delay_us(9800);
  92.        
  93. if (cuenta=1) segundos--;
  94. if (segundos<0) {segundosd--; segundos=9;}
  95. if (segundosd<0) {minutos--; segundosd=5;}
  96. if (minutos<0) {minutosd--; minutos=5;}
  97.  
  98. if (minutosd==0 && minutos==0 && segundosd==0 && segundos==0) reset();
  99. }}}}

Con 250 veces timer0, más o menos lo hace bien... segundo arriba, segundo abajo... :o

El código del final, KALLITOS, es para que cuando esté todo a 0 haga un reset, se pare y vuelva al inicio.

Un saludo.
Título: Re: Cuenta atrás programable
Publicado por: KALLITOS en 26 de Septiembre de 2009, 11:52:51
Hola ALF :D, bueno mira ya vas bien, estas usando interrupcion para manejar el tiempo, pero hay otro inconveniente, las interrupciones con los delays no se llevan bien, asi que te recomendaria que para el barrido de los displays tambien uses la interrupcion. Te comento como tengo trabajando un circuito, con el Timer0 realizo el barrido de los displays cada 5ms, y con el Timer1 con desborde a 500 ms sumo 2 y tengo 1 segundo, asi cuando salta el Timer0 realizo el barrido y cuando salta Timer1 decremento las variables del reloj.
Otra recomendacion es que antes de sacar el valor a mostrar por el puerto, apagues todos los displays y cuando el valor ya esta en el puerto enciendas el display a mostrar, esto para evitar que en los displays se vean un poco iluminados el resto de segmentos.

Ya mañana estare en casa y podre subir un poco de codigo para que observes ;-).

Saludos
Título: Re: Cuenta atrás programable
Publicado por: KALLITOS en 28 de Septiembre de 2009, 02:27:58
Hola, bueno te pego un poco de codigo para que observes como tengo un ckto parecido al que quieres.
Código: C
  1. #int_rtcc
  2. void timer0(void)               ///CODIGO PARA REALIZAR BARRIDO
  3.    {
  4.    int digito;
  5.    set_timer0(100);             ///TIMER0 CON PREESCALER DE 16 TENGO ALGO DE 2.5 mS
  6.    portb = 255;                   ///APAGO LOS DISPLAYS PARA EVITAR SE ENCIENDAS EL RESTO DE SEGMENTOS
  7.    tecla++;       //para realizar aumento rapido
  8.       switch(digito++)                ///PARA SELECCIONAR QUE DISPLAY SE MOSTRARA
  9.       {
  10.       case 1:                           ///MOSTRAR DISPLAY 1
  11.          {
  12.          mostrar(seg_unid);        ///ENVIO DE DATOS
  13.          portb = 0b00001110;     /// ACTIVO SOLO EL DISPLAY DE LA CIFRA
  14.          break;                        ///SALGO DEL BUCLE
  15.          }
  16.       case 2:
  17.          {
  18.          mostrar(seg_dece);
  19.          portb = 0b00001101;        
  20.          break;
  21.          }
  22.       case 3:
  23.          {
  24.          mostrar(minu_unid);
  25.          portb = 0b00001011;        
  26.          break;
  27.          }
  28.       case 4:
  29.          {
  30.          mostrar(minu_dece);
  31.          portb = 0b00000111;        
  32.          digito = 0;
  33.          break;
  34.          }
  35.       }
  36.    }  
  37.  
  38. void mostrar (int8 valor_mostrar)    ///CODIGO PARA ENVIAR DATOS A MOSTRAR
  39. {
  40.    int veces;
  41.  
  42.    for (veces=0;veces<7;veces++)      ///UTILIZO ESTE CODIGO YA QUE USO UN IC 74LS164
  43.        {            
  44.        output_bit(DATA,bit_test(tab7seg[valor_mostrar],veces));
  45.        output_high(CLOCK);
  46.        output_low(CLOCK);
  47.        }  
  48. }
  49.  
  50. ////CODIGO PARA AUMENTAR VALORES SETEADOS
  51.       if((!input(UP))&&(tecla_up))
  52.          {
  53.          tecla_up = 0;                ///PARA EVITAR REBOTES EN LAS TECLAS
  54.          minu_unid++;
  55.          if (minu_unid > 9)
  56.            {
  57.             minu_unid = 0;
  58.             minu_dece++;
  59.             if(minu_dece > 5)
  60.              {
  61.               minu_dece = 0;
  62.              }
  63.            }
  64.  
  65.          }
  66. ///CODIGO PARA DISMINUIR VALORES SETEADOS
  67.       if((!input(DOWN))&&(tecla_down))
  68.          {
  69.          tecla_down = 0;                ///PARA EVITAR REBOTES EN LAS TECLAS
  70.          minu_unid--;
  71.          if (minu_unid > 9)
  72.            {
  73.             minu_unid = 9;
  74.             minu_dece--;
  75.             if(minu_dece > 5)
  76.               {
  77.                minu_dece = 5;
  78.               }
  79.            }        
  80.          }
  81.  
  82. ///CODIGO QUE REALIZA EL CONTEO DESCENDENTE
  83. {
  84. flag_timer1 = 0;       ///FLAG QUE INDICA EL TRANSCURSO DE 1SEG
  85. seg_unid--;
  86. if(seg_unid > 9)
  87.    {
  88.    seg_unid = 9;
  89.    seg_dece--;
  90.    if(seg_dece > 5)
  91.       {
  92.       seg_dece = 5;
  93.       minu_unid --;
  94.       if(minu_unid > 9)  
  95.          {
  96.          minu_unid = 9;
  97.          minu_dece--;
  98.          if(minu_dece>9)
  99.             {
  100.             minu_dece = 9;
  101.             }
  102.          }
  103.       }
  104.    }
  105. }

Esto es lo casi lo basico para que mi ckto funcione, revisalo y si tienes condultas por aqui estare :).
Saludos
Título: Re: Cuenta atrás programable
Publicado por: iNoXSteeL en 28 de Septiembre de 2009, 13:52:56
Kallitos, gracias por tu aclaración, creo entenderlo bien, el switch lo dispara TIMER0, esto sería el equivalente a los delay entre dígitos, y luego, el timer1 es el encargado del flag que mueve el tiempo, es decír varía los dígitos cada segundo...

Una cosa que veo, se supone que 1 minutos son 60 segundos, tu contador lo hace con 99??

Salu2
Título: Re: Cuenta atrás programable
Publicado por: KALLITOS en 28 de Septiembre de 2009, 14:12:23
Es cierto es de 60 segundos, copie codigo de otra variable :mrgreen:, ya llo modifico.

Saludos