contador descendente de 24 seg

[kikecon]

hola amigos estoy haciendo una pequeña prueba de un tablero de que contabilizara 24 segundos de forma descendente bueno he hecho algo pero no me resulto como lo esperaba no se si aya alguna forma de hacer que mientras muestro las unidades tambien muestre el numero de las decenas por ejemplo arranco en 24 pero solo se enciende el 2 en un diplay mientras que el otro esta apagado como podria hacer a mi se me ocurre usar otro pic mas grande pero me han dado el 16f84a ojala me puedan apoyar adjunto mi codigo y mi diagrama en proteus

Código: [Seleccionar]

#include <16f84a.h>
#FUSES xt,NOWDT,NOPROTECT,NOPUT //funcionamiento
#use delay (clock=4000000)
#use fast_io(a)
#use fast_io(b)

byte CONST seg_u[10]={0x5b,0x06,0x3f};
byte CONST seg_d[10]={0x66,0x4f,0x5b,0x06,0x3f};
byte CONST seg_d2[10]={0x67,0x7f,0x07,0x7d,0x6d,0x66,0x4f,0x5b,0x06,0x3f};

void main()
{
   //inicializacion
   byte unid=0,dec=0;
   set_tris_a(0b00000000);
   set_tris_b(0x00);
   output_a(0);
   output_b(0);
   //procesp
   
   for(;;)
   {
      for(dec=0;dec<3;dec++)
      {
         output_a(0b00001000);
         output_b(seg_u[dec]);
         delay_ms(500);
         if(seg_u[dec]==0x5b)
         {
            for(unid=0;unid<5;unid++)
            {
                  output_a(0b00000100);
                  output_b(seg_d[unid]);
                  delay_ms(500);
            }
         } 
         else
         if(seg_u[dec]==0x06)
         {
            for(unid=0;unid<10;unid++)
            {
                output_a(0b00000100);
                output_b(seg_d2[unid]);
                delay_ms(500);
            }
          }
         }
      }
}


[AngelGris]

  Para lograr visualizar tanto las decenas como las unidades "al mismo" tiempo tendrías que generar un loop infinito mostrando primero uno y luego otro con poco delay entre ambos, tal vez 10 ms. Y a su vez usar algún contador que te decremente los segundos basándote en la cantidad de veces que pasas por el lopp.

Código: C

1. while (1)
2. {
3.   muestro_unidad();
4.   delay 10 ms;
5.   muestro_decena();
6.   delay 10 ms;
7.  
8.   incremento un contador;
9.   if (contador == 50)  // 50 * 20 ms = 1s  (tengo dos veces delay de 10 ms y lo multiplico por las veces del contador)
10.   {
11.      cambias valor de unidad;
12.      si es necesario cambias valor de decena;
13.      contador = 0;
14.   }
15. }

[kikecon]

hola angelgris beuno no he implementado tu respuesta xq me quedan algunas dudas por el ejemplo en la funcion que dice muestra unidad iria algun for o algo parecido a lo que tengo en mi programa, tambein en donde pones incremento contador es un comentario que pones al entrar al if o en realidad tengo que poner un contador y beuno lo del if me supongo que cuando tomo y llamo la funcion muestra unidad activo el catodo correspondiente a ese display y lo mismo hago con e muestra decena mm mi pregunta es al hacer eso no se me apagaria el otro display ya que despues entro al if y demoro mas de lo previsto (1 seg) gracias por la colaboracion

[AngelGris]

hola angelgris beuno no he implementado tu respuesta xq me quedan algunas dudas por el ejemplo en la funcion que dice muestra unidad iria algun for o algo parecido a lo que tengo en mi programa,

 No, un for no podría ser. Tendría que ser directamente el output_b(xxx). Si pones un for te vas a quedar colgado en ese lugar.

tambein en donde pones incremento contador es un comentario que pones al entrar al if o en realidad tengo que poner un contador y beuno lo del if me supongo que cuando tomo y llamo la funcion muestra unidad activo el catodo correspondiente a ese display y lo mismo hago con e muestra decena

  Exacto, en realidad es un contador que tenés que utilizar. Claro, en las funciones "muestro_unidad()" y "muestro_decena()" tenés que activar los cátodos correspondientes.

mm mi pregunta es al hacer eso no se me apagaria el otro display ya que despues entro al if y demoro mas de lo previsto (1 seg) gracias por la colaboracion

  No, en el if que está después de incrementar el contador no te vas a quedar por mucho tiempo. Es simplemente cambiar el estado de un par de variables.
  Obviamente que los tiempos van a cambiar un poco. De hecho un sistema implementado así en C no es demasiado preciso ya que las rutinas de delay son aproximadas y uno no sabe con exactitud cuanto tiempo demora cada instrucción.