Medición de 0 - 1 MHz (resolución de 0,25 Hz) de onda cuadrada mediante un MCU

Si es posible, sugeriría seleccionar un microcontrolador que admita una operación de contador utilizando las entradas del temporizador; en lugar de incrementar manualmente un contador dentro de un ISR (que a altas frecuencias rápidamente termina saturando la actividad del microcontrolador), permite que el hardware maneje el conteo. En este punto, su código simplemente se convierte en una cuestión de esperar su interrupción periódica y luego calcular la frecuencia.

Para extender el rango y hacer que el contador de frecuencia sea más generalizado (eliminando la necesidad de múltiples rangos a expensas de un poco más de trabajo para la MCU), puede usar la siguiente técnica.

Seleccione una tasa de interrupción periódica que permita la precisión de la medición en la frecuencia de entrada más alta; esto debe tener en cuenta el tamaño de su contador (debe seleccionar el período del temporizador de modo que el contador del temporizador no se desborde en la frecuencia de entrada máxima). Para este ejemplo, supondré que el valor del contador de entrada se puede leer desde la variable "timer_input_ctr".

Incluya una variable para contar interrupciones periódicas (debe inicializarse en 0 al inicio); para este ejemplo me referiré a esta variable como "isr_count". El período de interrupción está contenido en la constante "isr_period".

Su interrupción periódica debe implementarse como (pseudocódigo C):

void timer_isr()
{
  isr_count++;
  if (timer_input_ctr > 0)
  {
    frequency = timer_input_ctr / (isr_count * isr_period).
    timer_input_ctr = 0;
    isr_count = 0;
  }
}

Obviamente, este ejemplo aproximado se basa en algunas matemáticas de coma flotante que pueden no ser compatibles con los microcontroladores de gama baja, existen técnicas para superar esto, pero están fuera del alcance de esta respuesta.

Es posible que desee considerar tener dos (o más) rangos. Los problemas con la captura de frecuencias muy bajas son algo diferentes de los problemas con las más altas. Como ya ha notado, en el extremo superior de su rango tiene problemas de desbordamiento del contador.

Pero considere en el extremo inferior de su rango, su precisión se verá afectada por no tener suficientes conteos en el registro. No estoy seguro de si realmente desea discriminar entre 0,25 Hz y 0,5 Hz, pero si lo hace, tendrá que contar durante cuatro segundos para hacerlo.

Además, especificar una resolución plana de 0,25 Hz, estrictamente interpretada, significa que podrá distinguir 500 000,00 Hz de 500 000,25 Hz, que es un grado de precisión bastante alto.

Por esas razones, el diseño para distintos rangos podría aliviar el problema del tamaño del mostrador. Sacando números al azar por ejemplo, para el extremo inferior, digamos de 0 a 100 Hz, cuente durante intervalos de 10 segundos y obtendrá una resolución de 0,1 Hz, y su contador solo necesita subir a 1000, ni siquiera 10 bits. Luego, de 100 Hz a 10 kHz, cuente por intervalos de 1 segundo; solo obtiene una resolución de 1 Hz, pero su contador solo necesita ejecutar hasta 10,000 aún más pequeños que 16 bits. El rango superior de 10kHz a 1MHz podría contar por solo 0.01 segundos, y el conteo máximo aún sería de solo 10,000 y aunque su resolución sería de 100Hz, esta sería una precisión razonable.

Puede mezclar un contador de hardware y software contando los desbordamientos del contador de hardware en un ISR.

Contar cada flanco de la señal en una ISR será demasiado lento para una señal de 1 MHz. Creo que podrías hacer hasta unos 50kHz de esa manera.

Usando preescaladores, incluso se puede lograr la medición de GHz. Este es un medidor de frecuencia simple de 40 MHz con ATMEL AVR AT90S2313: http://www.myplace.nu/avr/countermeasures/index.htm

Aquí hay algunos otros proyectos similares:

http://www.ikalogic.com/freq_meter_2.php

http://www.saturn.dti.ne.jp/~khr3887/lfcd_e.html

http://www.circuitlake.com/rs232-frequency-meter-and-pulse-generator.html

http://www.ulrichradig.de/home/index.php/avr/frequenzcounter

http://www.triplespark.net/elec/analysis/FreqCnt/

http://www.cappels.org/dproj/30MHzfmeter/30MhzFmtr.html

http://www.qsl.net/pa3ckr/bascom%20and%20avr/rfcounter/index.html

http://www.sump.org/projects/counter

http://digilander.libero.it/alfred73/eprojects.htm#1300%20Mhz%20Frequencymeter%20with%20prescaler

En lugar de hacer un contador de 1 segundo, conviértalo en un contador de 0,1 segundos y multiplique el conteo por 10.

Si solo se trata de almacenar el número del contador, ¿no puede usar un código adicional para realizar un seguimiento de cuándo el contador está a punto de desbordarse y escribir en otra ubicación de la memoria para llevar la cuenta?

¿No puede simplemente usar la captura de entrada de un temporizador de 16 bits y las interrupciones de desbordamiento (más una variable) para hacer la medición? Así es como lo haría con el ATTiny24A con AVR-GCC (no probado y potencialmente defectuoso, por supuesto):

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#define TIMER1_BITS           16    // 16 bit timer
#define TIMER1_HZ             8.0e6 // 8MHz crystal
#define TIMER1_OVF_PERIOD_SEC (1.0 * (1 << TIMER1_BITS) / TIMER1_HZ)
#define TIMER1_SEC_PER_TICK   (1.0 / TIMER1_HZ)

//global variables for time keeping
double total_period_sec = 0.0;
uint16_t  num_overflows = 0;

void setup_timer1_capture(){
   // set the ICP (input caputure pin) to a floating input
   DDRA  &= ~_BV(7); // it's A7 on the ATTiny24A...
   PORTA &= ~_BV(7);

   TIMSK1 =   _BV(ICIE1)  // enable input pin capture interrupt
            | _BV(TOIE1); // enable overflow interrupt

   TCCR1B =   _BV(ICNC1)  // activate the input noise canceller
            | _BV(ICES1)  // capture on rising edge of ICP
            | _BV(CS10);  // run the timer at full speed

}

ISR(TIM1_CAPT_vect, ISR_NOBLOCK){ //pin capture interrupt
  uint16_t capture_value_ticks = ICR1; // grab the captured value
  // do some floating point math
  total_period_sec =   1.0 * num_overflows * TIMER1_OVF_PERIOD_SEC
                     + 1.0 * capture_value_ticks / TIMER1_SEC_PER_TICK; 

  num_overflows = 0; // clear helper variable to be ready for next time
}

ISR(TIM1_OVF_vect){   //timer overflow interrupt
    num_overflows++;
}

int main(int argc, char *argv[]){
   setup_timer1_capture();

   sei(); // enable interrupts!

   for(;;){ //forever
      // do whatever you want...
      // the most recently calculated period is available in the 
      // total_period_sec variable 
      // (obviously 1.0 / total_period_sec is the frequency in Hz)
   }

   return 0;
} 

... en cualquier caso, compila :)

EDITAR Miré la salida del archivo lss de mi código, y el código generado tiene demasiadas instrucciones para no tropezarse a 1 MHz con un reloj de 8 MHz... ¡incluso el simple incremento de una línea en TIM1_OVF_vect genera 19 instrucciones! Entonces, para manejar eventos de 1 MHz, definitivamente necesitaría optimizar, probablemente registrar, asignar algunas cosas (probablemente num_overflows y capture_value_ticks), usar ensamblador en línea (robar las cosas importantes del archivo lss) y mover el procesamiento fuera de las interrupciones al principal bucle siempre que sea posible.

Publicar este código como una alternativa según la sugerencia de @timrorr a mi publicación anterior. Esto se compila para ATTiny24A usando el estándar de lenguaje c99, pero en realidad no lo he probado de ninguna manera más allá de eso.

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/atomic.h>
#define TIMER0_PRELOAD   0x83 // for 8MHz crystal and overflow @ 1kHz
#define TIMER0_PRESCALE 0x03  // divide by 64
#define TASK_PERIOD_MS 4000   // execute task every 4 seconds

//global variables for time keeping
volatile uint16_t  global_num_overflows = 0;
volatile uint16_t  global_task_timer_ms = TASK_PERIOD_MS;

void setup_timers(){
    // set the T1 pin (PA.4) to a floating input (external event)
    DDRA  &= ~_BV(4);
    PORTA &= ~_BV(4);

    // set Timer1 to count external events
    TIMSK1 = _BV(TOIE1);      // enable overflow interrupt
    TCCR1B =   _BV(CS10)      // clock on external positive edge of T1 pin
        | _BV(CS11)
        | _BV(CS12);

    // set Timer0 for task timing (overflow once per ms)
    TCCR0B = TIMER0_PRESCALE;
    TCNT0  = TIMER0_PRELOAD;  // setup appropriate timeout
    TIMSK0 = _BV(TOIE0);      // enable timer0 overflow interrupt
}


ISR(TIM1_OVF_vect){   //timer1 overflow interrupt
    global_num_overflows++;
}

ISR(TIM0_OVF_vect){            //timer0 overflow interrupt @ 1kHz
    TCNT0 = TIMER0_PRELOAD;   // preload timer for 1kHz overflow rate
    if(global_task_timer_ms > 0){
        global_task_timer_ms--;
    }
}

int main(int argc, char *argv[]){
    double frequency_hz = 0;
    uint16_t num_overflows = 0;
    uint16_t num_positive_edges  = 0;
    setup_timers();
    sei(); // enable interrupts!
    for(;;){ //forever
        if(global_task_timer_ms == 0){ // wait for task to be scheduled
            ATOMIC_BLOCK(ATOMIC_FORCEON){
                num_overflows        = global_num_overflows; // copy the volatile variable into a local variable
                global_num_overflows = 0;                    // clear it for next time
                num_positive_edges   = TCNT1;                // copy num positive edge events to local variable
            }

            // calculate the 'average' frequency during this task period
            frequency_hz  = 1.0 * num_positive_edges;  // num edges since last overflow
            frequency_hz += num_overflows * 65536.0;   // edges per overflow of 16 bit timer
            frequency_hz /= (TASK_PERIOD_MS / 1000.0); // over the task interval in seconds

            global_task_timer_ms = TASK_PERIOD_MS;     // reschedule task
        }

        // use frequency_hz for whatever other processing you want to do
    }
    return 0;
}

Este es un buen uso de las capacidades de hardware del Timer1 y libera una tonelada de ciclos de procesamiento en comparación con mi publicación original.