olá desculpem voltar a este topico antigo mas estou precisando de ajuda
 a todos programadores,
tenho realizado um projeto de tcc, estou tendo algumas dificuldades .
Preciso criar um temporizador por timer a executar determinada funcao.
exemplo:
está executando hora();
depois de um tempo
chama funcao
data();

segue o codico
Código:

#include <16f627A.h>

#fuses intrc_io, nowdt, noprotect, put, nobrownout, mclr, nolvp, nocpd
#use delay(clock=4000000)
#use fast_io(b)

#define BOTAO1 PIN_a0                   //Boto de escolha de ajuste das funes.
#define BOTAO_INCREMENTO PIN_a1         //Boto incremento de variveis.
#define BOTAO_DECREMENTO PIN_a2
int conta_pulsos=0;
#byte porta = 0x05
#byte portb = 0x06

//Boto de decremento das variveis.
int  apagado = 0; //apagado
int a;
int n,i=0,valor;
int h=12;
int m=5;
int s=14;
int dezena, unidade, digito;
int seg=0,q;
int contador=0;
int dia=29;               //Variável dos dias do mês. 0 a 31.
int mes=6;
int ano=12;
//Tabela com os digitos
const unsigned char table[11][5] = {
0b01111110,0b01000010,0b01000010,0b01000010,0b01111110,//0
                  0b00000010,0b00100010,0b01111110,0b00000010,0b00000010,//1
                  0b01011110,0b01010010,0b01010010,0b01010010,0b01110010,//2
                  0b01010010,0b01010010,0b01010010,0b01010010,0b01111110,//3
                  0b01110000,0b00010000,0b00010000,0b00010000,0b01111110,//4
                  0b01110010,0b01010010,0b01010010,0b01010010,0b01011110,//5
                  0b01111110,0b01010010,0b01010010,0b01010010,0b01011110,//6
                  0b01100000,0b01000000,0b01000000,0b01000000,0b01111110,//7
                  0b01111110,0b01001010,0b01001010,0b01001010,0b01111110,//8
                  0b01110010,0b01010010,0b01010010,0b01010010,0b01111110,//9
                         0x00, 0x36, 0x36, 0x00, 0x00, // :
                                   
#int_TIMER1
void temp1s(void)
{
   q++;
   seg++;
   if(seg==4){
   seg=0;
   i++;
   }
   if(i==4){
   i=0;
   }
   set_timer1 (3036);    //Preload do Timer1
}


void caracter(digito) { //chr contem  2 digitos (hh,mm o ss)
   dezena = (digito/10); // dezenas
   unidade = (digito-(dezena*10)); //e as unidades
   
   for (n=0;n<5;n++) { //preparar a tabela para primeiro digito
      output_b(table[dezena][n]);
output_high(pin_b0);
output_high(pin_b7);

      delay_us(900) ;//160useg cada pixel horizontal
   }
  delay_us(700); //pausa entre digitost
output_high(pin_b0);
output_high(pin_b7);
   output_b(0x00);
output_high(pin_b0);
output_high(pin_b7);
   delay_us(700); //pausa entre digitos*/
   
   for (n=0;n<5;n++) {
      output_b(table[unidade][n]);
output_high(pin_b0);
output_high(pin_b7); //unidades
      delay_us(700);
output_high(pin_b0);
output_high(pin_b7);
   }
   delay_us(700); //pausa entre digitos
   output_b(0x00);
   delay_us(700); //pausa entre digitos*/
output_high(pin_b0);
output_high(pin_b7);
}

void doispontos()

{
   for (n=0;n<5;n++) { //preparar tabela para primeiro digito
      output_b(table[10][n]);
output_high(pin_b0);
output_high(pin_b7);
      delay_us(400); //160useg cada pixel horizontal
   }
   delay_us(400); //pausa entre digitost
   output_b(0x00);
output_high(pin_b0);
output_high(pin_b7);
   delay_us(400); //pausa entre digitos*/
}

void barra()

{
   for (n=0;n<5;n++) { //preparar tabela para primeiro digito
      output_b(table[32][n]);
      delay_us(100); //160useg cada pixel horizontal
   }
   delay_us(600); //pausa entre digitost
   output_b(0x00);
   delay_us(600); //pausa entre digitos
}




void hora()
{
caracter(h);
               doispontos();
               caracter(m);
               doispontos();
               caracter(s);
}

void data()
{
               caracter(dia);
               barra();
               caracter(mes);
               barra();
               caracter(ano);
}
void main() {  //bucle principal
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   setup_timer_1 (T1_INTERNAL | T1_DIV_BY_8);   //Configurao do Timer1 para clock interno = 1E6 dividido por 8
   set_timer1 (3036);
   enable_interrupts(INT_TIMER1);               //Habilita interrupo timer1
   enable_interrupts(global);                   //habilita interrupco global
   set_tris_b(0);
   
   a=0;

   while (1) {
     
      output_high(pin_b0);
output_high(pin_b7);
      if (!input(BOTAO1))        //Teste do boton.
      {
         delay_ms (300);        //Para evitar retorno.
         if (contador>2)       //Se maior q 11, zera o contador.
         {
            contador=0;
         }
         
         contador++;             //Incremento da varivel contador.
      }
     
      switch (contador)          //Depois de incrementada, a varivel CONTADOR
      {                          //assume um dos casos a seguir:
         case 1:                 //Menu de ajuste da HORA.
         {
            output_low(pin_b7);
           
            if (!input (BOTAO_INCREMENTO)) //Incrementa a varivel H(hora).
            {
               delay_ms (300);
               h++;
               
               if (h>23)                  //Se a hora for maior que 23, reset.
               {
                  h=0;
               }
            }
           
            if (!input (BOTAO_DECREMENTO)) //Decrementa a varivel H(hora).
            {
               delay_ms (300);
               h--;
               
               if (h==255)                //H  uma varivel inteira de 8 bits.
               {                          //Quando  decrementada para um valor
                  h=23;                   //menor que zero, se torna 255. Ou seja,
               }                          //deve voltar para 23.
            }
           
            q=0;                   //Quando se est em algum menu, Q  resetada.                            //Mantenha na tela.
           
            break;
         }
         
         case 2:                 //Menu de ajuste do MINUTO. Idem ao anterior.
         {
            output_high(pin_b7);
            output_low(pin_b7);
            output_high(pin_b7);
           
            if (!input (BOTAO_INCREMENTO))
            {
               delay_ms (300);
               m++;
               
               if (m>59)                     //Diferente aqui.
               {
                  m=0;
               }
            }
           
            if (!input (BOTAO_DECREMENTO))
            {
               delay_ms (300);
               m--;
               
               if (m==255)                   //Igual aqui.
               {
                  m=59;
               }
            }
           
            q=0;
           
            break;
         }
         
         default:                //Menu principal. Mostra todas as informações.
         {
            s=q/2;            //A variável Q incrementa a 2Hz, então os segundos
                             //devem ser a metade.
            if (s==60)        //Se for igual a 60, reset em Q e S. M incrementa.
            {
               q=0;     
               s=0;
               m++;
               
            }
         
           
            if (m>59)
            {
               m=0;
               h++;
            }
         
            if (h>23)         //Se H(horas) for maior q 23, reset. DIA DA SEMANA
            {                 //e DIA DO MÊS incrementam.
               
             
               h=0;
            }

           
           
           


while(input(pin_a3))  { //so rodoa se pinoa3 =1
               delay_ms(10);
output_high(pin_b0);
output_high(pin_b7);
  hora();

 
 
 
            }
         }

      }
   }
}

entendo amigo
mas se puder me da uma idea de como faria a logica em C poderia ser em qualquer ambiente.

bom, este é o "propeller Clock" relogio holografico, creio que ja deve ter visto a respeito... o port B esta ligado aos leds,
port a3 ao encoder  sempre k o encoder for interrompido uma sequencia binaria sera enviada aos leds.

Caro liniker,

Creio que a medida que forneça mais detalhes sobre a sua aplicação , a ajuda aparecerá...
Debugar o código pra vc vai ser mais difícil e não é muito justo... concorda?

Vamos dar um empurrãozinho....

Já fiz um propeller aqui, tipo "varinha mágica " , em assembly , mas o princípio é o mesmo.

Supondo , já que isso não ficou claro, que ser programa já está funcionando na parte do disparo do acendimento dos leds, através da interrupção externa no portA , acionado pelo encoder, correto ?
Você precisa alternar o que será mostrado nesse propeller , sendo um dado a data outro a hora , após intervalos de tempo.
Vem a questão :
Precisa ser por interrupção por tempo ? Isso está descrito no seu TCC ?
Pode ser por uma simples contagem ?
Se não for uma exigência do projeto , eu faria de uma maneira mais simples, criando um contador , pois vc já tem uma interrupção externa como referencia.
Por exemplo :  Se seu propeler tem uma rotação de 1800 RPM e você utiliza o zero do encoder para interrupção , contaria até 180 incrementado pela interrupção externa e mudaria o dado , isso daria aproximadamente 6 segundos entre cada valor apresentado nos leds.

Coloca mais detalhes se possível. 

Beto. 

Olá Liniker...

Onde você trata a interrupçao do pino portA que dispara os inicio da ligação dos leds ?
Não encontrei isso no que vc postou .

Seria esta parte aqui ?
Não é uma interrupção mas sim o  "main"... 

         
           
           


while(input(pin_a3))  { //so rodoa se pinoa3 =1
               delay_ms(10);
output_high(pin_b0);
output_high(pin_b7);
  hora();

 
 
 

A interrupção do timer 1 me parece estar relacionada ao relogio



Faz tempo que não programo nada em C ... MikroC na verdade ...

Vou te dizer o que eu faria em assembly nessa rotina ai acima ...


seto uma variavel com um numero que será o numero de voltas que eu quero contar

N=180
Cada vez que passar dentro dessa rotina decremento 1
Quando N=0 inverto um flag definido anteriormenre  TipoDado e recarrego a variavel com 180
Se TipoDado= 0 mostrar hora
Se TipoDado=1 mostar data

Captou ?

Vou dormir...hehehe


 

 

realmente esta comando case  esta ocupando todo espaco da memoria do MC, impedindo de colocar mais funcoes(interface)
oque farei??

Desculpe pela minha falta de compreensao
mas nao intendi o tua logica.
Esta sequencia de case seria o intervalo de segundos para hora e data
cada case seria 1 segundo
incrementado por j
foi a unica maneria que conseguir de mudar estas funcoes!.
Teria como ter mais um pouco de paciencia e me explicar novamente esta tua logica?
Tipo,assim que ligasse o circuito aparecesse hora ();
depois de 9 segundos esta funcao saia
e entrava data();
depois de 5 segundos hora();
sendo assim intermitente

Esta tua logica seria a seguinte?
 while(input(sensor))  { //so dispara os leds se pinoa3 =1
if(j >= 0 && j <=9)
hora();
if (j>=10 && j<=14)
data();