Obrigado pelas dicas .. Terei que fazer o meu mesmo. Realmente reconheço que é importante saber assembler, mas nunca tive aula sobre essa linguagem ...

Herbert, Jorge e demais. Saudações.
Quanto às dúvidas do nosso amigo, vamos por partes. Herbert, você quer o projeto pronto ou realmente aprender configurar o pic para este e muitos outros projetos?
Pelo que vi nas mensagens, vc quer trabalhar com velocidade baixa, algumas voltas por segundo. É possível implementar em C, mas não descarto o que o Jorge disse. Apesar de não ter conhecimento, serei obrigado aprender o assembly também.
Se aprender é sua resposta para continuar com mais projetos, recomendo que comece aqui
Use o código seguinte para descompactar: robo3001
É um excelente material (em inglês), que vai te ensinar como funciona os periféricos internos de um pic com desenhos ilustrativos. Grandioso trabalho da mikroe. Apesar dos exemplos serem para um pic maior, para seu projeto, terá que ler atentamente o datasheet do pic no esquema.
Outra coisa, sugiro não multiplexar os displays, pois pode perder pulsos na contagem do tempo.

A imagem acima é um projeto que terminei. A saída que pude encontrar, foi colocar os decodificadores BCD pois entre uma leitura e outra no sensor, um delay de 600ms é necessário, e a cintilação nos displays foi reprovada.
Com isso tenho um briho forte nos displays e o programa apenas se preocupa em monitorar a temperatura, escrevendo no display a cada 1seg.
Seu projeto só necessita de uma fonte de interrupção que é a do timer0.

qual das duas formas seria mais conveniente: Contar pulsos em um periodo de tempo ou contar o tempo entre dois pulsos?

Esta é uma questão interessante, pedra de tropeço para incautos ... eu pretendia comentar isto e acabei esquecendo ...

A resposta é: depende da frequência do sinal. Para sinais de frequências razoavelmente elevadas, é preferível medir a frequência, ou seja, contar o número de eventos dentro de um intervalo de tempo definido. Para frequências muito baixas, é preferível medir o período, ou seja, o tempo decorrido entre dois eventos consecutivos.

No que se refere à aplicação discutida aqui, temos que:

raio: 0,33 m ==> perímetro: 2,07 m

velocidade: 60 km/h

velocidade tangencial: 60.000 / 3.600 = 16,66 m/s

16,66 / 2,07 = 8,04 Hz

Frequência bastante baixa, o que recomenda a mensuração pelo período.

... Eu já fiz isso num projeto de foto...

Olá Gil. No projeto acima, tentei a multiplexação. No período de leitura do sensor DS1820, um dos displays chegava a apagar, pois eu era obrigado a desligar o bit de interrupções globais.
Como o pic possui o latch para o portB (configurados como digitais), o valor da última leitura é sempre exibido, mesmo durante a leitura do sensor, atualizado após esta rotina. O CD4511 ficou perfeito nesta combinação. Com LCD também concordo, uma vez que ele só vai mostrar novos parametros, quando receber comandos. Neste caso, pode-se até utilizar qualquer pino ligado ao lcd para receber os pulsos de entrada, basta apenas mudar a direção do tris durante a execução do código (entrada quando lê os pulsos, saída quando escreve no lcd).
Quanto à multiplexar, aí apóio o Jorge com assembly, mas neste caso fico limitado, pois aprendi somente C
Vou me dedicar ao assembly, em algumas aplicações, é melhor colocar códigos direto em asm dentro de um programa em C. Já faço isto, mas não tenho domínio.
Abraço.

Com relação a cintilação, é importante ressaltar que os displays (todas as posições) devem ser atualizados a cada 1/24 s ou menos. Pois o olho humano pode ser enganado nessas taxas (como no cinema, na TV analógica, ...). Se forem 4 algarismos, entre um digito e outro devem ser gastos menos do que 1/96 s!!! O que dá 1/24 para os 4 algarismos...

 

è muito facil de fazer no miKroC , dê mais detalhes sobre os dois pinos a serem controlados , se será uma logica E por exemplo .

Depois que aciona a saída , como irá resetar ?

Sempre coloque o máximo de detalhes e entao a ajuda vêm mais rápido ...

Beto.

Então pedrorose acho que isso deve dar pra começar alguma coisa...
Fiz um esboço usando um PIC 16f877A em 4MHz , já que vc não definiu qual Pic está usando .
Rb0 e Rb1 são as duas entradas , considerando ligadas quando são colocadas a nivel zero , ou seja , use resistores de Pull up .
 
Rc0 terá um led que liga quando as duas entradas forem pulsadas quatro vezes dentro de 15 segundos .

Rc1 terá um led que liga quando o tempo chega a 15 segundos , mesmo nao acionando nenhuma entrada , só para monitorar o funcionamento do temporizador .

Ficou faltando um reset da saída , pois nao ficou muito claro como vai fazer isso , apenas coloquei um reset dos contadores de pulsos de entrada caso chegar a 15 segundos e as entradas nao totalizarem os quatro pulsos cada . Para reset desligar e ligar o simulador ou o circuito.

Ainda :  a interrupção do timer 1 fica continuamente ligada , apenas criei um flag que é ligado ao primeiro pulso tanto na entrada 1 ou 2 que habilita o contador de 15 segundos.

Espero que sirva de ponto de partida .
MP com  arquivo que simulei no proteus , se vc usar aí .
Também o .hex e o .cof necessários para simularno proteus



// programa MikroC

unsigned short in1 = 0;   //flags das entradas
unsigned short in2 = 0;   // flags das entradas
unsigned counter, tmp;
unsigned T1_count=0;                      // counter variable, temporary variable
unsigned short f_inc;        // Timer1 counter, Usart Send flag
unsigned short f_temporizador ;// flag liga temporizador
unsigned  contador_in1=0;      // inicializa os contadores
unsigned contador_in2=0;
unsigned  temporizador=0; // inicializa temporizador

void interrupt() {

  if (PIR1.TMR1IF) {
    T1_count++;                              // increment T1_count
     TMR1H = 11;                            // write values to Timer1 registers
      TMR1L = 220;
    if (T1_count == 2) {                  // valor original =4 !!!!!!!!! para  clock 8 Mhz
      T1_count = 0;
    if (f_temporizador)
      f_inc = 1;              // se o temporizador estiver ligado seta f_inc
      }
    PIR1.TMR1IF = 0;
    }

  PIE1.TMR1IE = 1;            // Enable Timer1 interrupt
  INTCON = 0xC0;              // Enable GIE, PIE
}//~

void main() {
  ADCON1   = 0;               // Set AN pins to digital I/O
  TRISA    = 0;               // PORTA is output
  TRISD    = 0;               // PORTD is output
  TRISB    = 0XFF;               // PORTB.0 IN
  TRISC    = 0;                //PORTC OUT
  PORTC    = 0;

  T1_count = 0;
           // initialize T1_count

  TMR1H = 23;                 // Values are calculated for 8MHz
  TMR1L = 184;
  T1CON = 0b00110001;               // Set internal clock, start timer, prescaler 1:8


  PIE1.TMR1IE = 1;            // Enable Timer1 interrupt
  INTCON = 0xC0;              // Enable GIE, PIE

      do {


//  TESTE BOTOES PORT B DE 1 A 2
     if (Button(&PORTB, 0, 1, 0))  {

     in1 = 1;
     }
      if (Button(&PORTB, 0, 1, 1))
      if (in1) {
      f_temporizador=1 ; // liga flag temporizador
      contador_in1= contador_in1+1;    // incrementa o contador se rbo acionado
      in1 = 0;
      }
      if (Button(&PORTB, 1, 1, 0)) {

        in2 = 1;
        }
         if (Button(&PORTB, 1, 1, 1))
         if (in2) {
         f_temporizador=1; // liga  temporizador
         contador_in2=contador_in2+1;    // incrementa o contador se rb1 acionado
         in2=0;
         }
 // se os contadores das entradas ja chegaram a quatro
 
    if (contador_in1>=4 && contador_in2>=4) {
    PortC.F0 = 1   ;  // liga a saida indicando que os dois contadores
                      // chegarama quatro antes dos 15 segundos
    temporizador=0 ; // zera o contador de temporizador
    f_temporizador=0 ; // desliga o temporizador
    contador_in1=0 ; // zera o contador de entrada 1
    contador_in2=0 ; // zera o contador de entrada 2
    }
   
 // incrementando o contador
         
    if (f_inc) {
    temporizador=temporizador+1; // incrementa os segundos
    f_inc=0 ; // limpa o flag que foi foi setado na interuupçao
    if (temporizador==15) {
    PortC.F1 =1 ; // liga um led só pra saber que totalizou  os 15 segundos
    f_temporizador=0;  // desliga a temporizaçao até uma das entradas ser acionada novamente
    temporizador=0;    // reinicializa o contador do temporizador
    contador_in1=0;
    contador_in2=0;
                   }
    }
   
   
   
                                         // negates value on PORTD
    } while (1);                         // endless loop
 }

O timer 1 tem mais recursos que o timer 0 , pois opera com dois registradores
TMR1H - registrados do byte alto
TMR1L - registrador do Byte baixo
Totalizando 16 bits no contador ( contra 8 bits do timer0 ).

Para setar estes dois registradores de maneira correta devemos levar alguns pontos em consideração .
O cristal utilizado ou a frequencia do oscilador interno.
O preescaler selecionado em T1CON
Outros divisores que tenham sido implementados dentro ou fora da prórpia interrupção.

Utilizando o exemplo que escrevi:

Xtal utilizado no PIC = 4 Mhz
Lembrando que o ciclo de máquina devido a arquitetura interna do Pic é igual Fosc/4 .
Ciclo de máquina = 1us ( 0,000001s)

Preescaler selecionado em T1CON = 1:8 ou seja (T1CON = 0b00110001;    // Set internal clock, start timer, prescaler 1:

O nosso timer1 sera incrementado a cada 8 ciclos de máquina = 0,000008 = 8us.

Como a interrupção se dá no estouro dos registradores de TMR1 , na passagem de 65535 para 0 , ou de FFFF em hexadecimal
para 0000 , temos mais uma conta para fazer.
O valor que temos que escrever nos registradores será a diferença entre o valor total possível e o tempo que queremos medir.

Como ainda criei um outro divisor dentro da interrupçao ( T1_count==2) , a interrupçao ocorrerá duas vezes para que o flag f_int seja setado.
Isto é útil quando queremos colocar um led piscando a cada 0,5 segundos , por exemplo, mas queremos ter um temporizador com a unidade em segundos.

O valor a ser escrito nos registradores será :

ciclo desejado =  1 segundo
ciclo desejado / t1_count= 0,5 segundos
como nosso preescaler é de 1:8 o nosso Timer 1 será incrementado a cada 8us.
0,5 s / 8us =   62500

Aqui temos que prestar atenção , pois devemos escrever a DIFERENÇA nos registradores :

65536 - 62500 = 3036

Temos que escrever 3036 ( numero decimal) , em dois registradores separados( que juntos formam um hexadecimal de 16 bits)  .
Então :

3036 ( decimal)  = BDC (hexadecimal )

TMR1H = 0X0B 
TMR1L = 0XDC 

transformando novamente em decimal ,
TMR1H = 11 ( decimal)   
TMR1L =   220 (decimal)

Poderiamos escrever os valores diretamente em hexadecimal no compilador, mas acredito que assim fica mais fácil de fixar estas informações. Bastaria observar a sintaxe 0X00 ...
Ficou meio extenso , mas servirá para aqueles que estão iniciando também.

 

Falha minha, bem observado.
Aproveitei uma rotina que já tinha pra outra função, outro cristal etc...
Esse valores sao carregados na inicialização do PIC , seria o config  numa rotina ASM .
Vão servir apenas até ocorrer a primeira interrupção .
A partir da primeira interrupção os valores carregados são 11(dec) e 220 (dec) , dentro da propria interrupçao . 
No seu caso poderia alterar para os valores acima já na inicialização e a partir do momento que a interrupçao é habilitada , ela passa a ocorrer de 0,5s em 0,5s .