Medición de 0 - 1MHz (resolución de 0.25Hz) Squarewave usando una MCU

8

Necesito medir la frecuencia de onda cuadrada que puede variar entre 0 y 1MHz, y tiene una resolución de 0.25Hz.

Aún no he decidido qué controlador, pero probablemente será uno de los 20pin Attiny's.

Normalmente, la forma en que mediría las señales de frecuencia más baja sería mediante el uso de dos temporizadores, uno configurado en el modo de captura con temporizador para interrumpir, digamos los flancos ascendentes de la señal externa y otro programado para interrumpir cada segundo, por lo tanto, los contadores anteriores registran después de 1 segundo sería igual a la frecuencia de la señal.

Sin embargo, este método obviamente no funcionará para capturar señales que oscilan entre 0 y 1MHz con una resolución de 0.25Hz para esto. Necesitaría un contador de 22 bits (los micros AFAIK de 8 bits solo tienen contadores de 8/16 bits).

Una de las ideas que tuve fue dividir la señal antes de aplicarla al micro, pero esto sería impráctico, ya que la señal tendría que dividirse entre 61, por lo que la frecuencia solo podría actualizarse cada 61 segundos, donde me gustaría. cada pocos segundos.

¿Hay otro método que permita actualizar la frecuencia cada 4 segundos?

Actualizar:

La solución más sencilla es utilizar un uso de una interrupción externa o una captura con temporizador para interrumpir en el flanco ascendente de la señal y hacer que isr incremente una variable de tipo long int . Lea la variable cada 4 segundos (para permitir frecuencias de hasta 0.25Hz a las medidas).

Actualización 2:

Como señala JustJeff, una MCU de 8 bits no podrá mantenerse al día con una señal de 1 MHz, por lo que se descarta la interrupción en cada flanco ascendente y se incrementa un long int ...

He elegido el método sugerido por timororr. Una vez que llegue a implementarlo, volveré a publicar y compartiré los resultados. Gracias a todos por vuestras sugerencias.

Informe de progreso:

Iv'e comenzó a probar algunas de las ideas presentadas aquí. En primer lugar probé el código de vicatcu. Hubo un problema obvio de que TCNT1 no se solucionó después de calcular la frecuencia, no es un gran problema ...

Luego, al depurar el código, noté que aproximadamente cada 2 a 7 veces la frecuencia se calculaba el contador de desbordamiento del temporizador 1 (el temporizador configurado para contar eventos externos) se reduciría en dos. Puse esto a la latencia del temporizador 0 ISR y decidí mover el bloque if del bloque ISR al principal (vea el fragmento a continuación) y solo establezca una marca en el ISR. Algunos errores en la depuración mostraron que la primera medición estaría bien, pero con cada lectura posterior, el conteo de desbordamiento del Temporizador 1 terminaría en 2. lo cual no puedo explicar: hubiera esperado que no estuviera por debajo de ...

int main()
{
    while(1)
    {
        if(global_task_timer_ms > 0 && (T0_overflow == 1))
        {
            global_task_timer_ms--;
            T0_overflow = 0;
        }

        .....
    }
}

Luego decidí que intentaría implementar la sugerencia de timrorrs. Para generar el intervalo necesario (de aproximadamente 15 ms entre cada interrupción timer_isr) tendría que conectar en cascada los dos temporizadores de 8 bits. como el único temporizador de 16 bits en el Atmega16 se está utilizando para capturar los flancos ascendentes de la señal externa.

Pensé que esta solución funcionaría y sería mucho más eficiente, ya que la mayor parte de los gastos generales se desplazan a los temporizadores y solo queda un corto isr para que la CPU la maneje. Sin embargo, no fue tan preciso como esperaba, las mediciones se movieron de un lado a otro en aproximadamente 70Hz, lo cual no me importaría en las frecuencias altas, pero definitivamente no es aceptable en las frecuencias más bajas. No dediqué mucho tiempo a analizar el problema, pero supongo que la disposición en cascada del temporizador no es tan precisa ya que he implementado una disposición similar a la sugerencia de timrorrs en un controlador 8051 mucho más lento que tenía 2 temporizadores de 16 bits y los resultados fueron bastante precisos.

Ahora he vuelto a la sugerencia de vicatcu, pero moví el cálculo de frecuencia al temporizador 0 isr (vea el fragmento a continuación ), este código ha producido mediciones consistentes y razonablemente precisas. Con un poco de precisión, la precisión debería ser aproximadamente de +/- 10Hz.

ISR(TIMER0_OVF_vect)
{            

    TCNT0 = TIMER0_PRELOAD;         //Reload timer for 1KHz overflow rate

    if(task_timer_ms > 0)
    {
        task_timer_ms--;
    }
    else
    {     
        frequency_hz = 1.0 * TCNT1;
        TCNT1 = 0;
        frequency_hz += global_num_overflows * 65536.0;
        global_num_overflows  = 0;
        frequency_hz /= (TASK_PERIOD_MS / 1000.0);
        task_timer_ms = TASK_PERIOD_MS;
    }                                                 
}       

Si alguien tiene alguna otra sugerencia, estoy abierto a ellos, pero prefiero no usar rangos ... Tampoco tengo la intención de obtener una resolución del 0,25%, no parece tener mucho sentido con el nivel de precisión que tengo en este momento.

    
pregunta volting

7 respuestas

4

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 termina rápidamente 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 ampliar el rango y hacer que el contador de frecuencia sea más general (eliminando la necesidad de múltiples rangos a costa de un poco más de trabajo para la MCU), puede utilizar 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 para que el contador del temporizador no se desborde a la frecuencia de entrada máxima). Para este ejemplo, asumiré que el valor del contador de entrada se puede leer desde la variable "timer_input_ctr".

Incluir una variable para contar interrupciones periódicas (debe inicializarse a 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 (pseudo-có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 punto 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.

    
respondido por el timrorr
7

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 señalado, en el extremo superior de su rango tiene problemas de desbordamiento de contador.

Pero considere en el extremo inferior de su rango, su precisión se verá afectada por no tener suficientes cuentas en el registro. No estoy seguro si realmente quieres discriminar entre 0.25Hz y 0.5Hz, pero si lo haces, entonces tendrás que contar durante cuatro segundos para hacerlo.

Además, la especificación de una resolución plana de 0.25Hz, interpretada estrictamente, significa que sería capaz de discernir 500,000.00Hz desde 500,000.25Hz, lo cual 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 contador. Al sacar los números al azar por ejemplo, para el extremo bajo, digamos de 0 a 100Hz, cuente para intervalos de 10 segundos, y obtiene una resolución de 0.1Hz, y el contador solo necesita subir hasta 1000, no incluso 10 bits. Luego, de 100Hz a 10kHz, cuente por intervalos de 1 segundo; solo obtiene una resolución de 1Hz, pero su contador solo necesita correr hasta 10,000 aún más pequeños que 16 bits. El rango superior de 10kHz a 1MHz podría contar solo por 0.01 segundos, y el conteo máximo aún sería de 10,000, y aunque su resolución sea de 100Hz, esta sería una precisión razonable.

    
respondido por el JustJeff
5

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

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

    
respondido por el starblue
2

En lugar de hacer un contador de 1 segundo, ¿es un contador de 0,1 segundos y multiplica la cuenta por 10?

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

respondido por el endolith
2

¿No puede simplemente usar una captura de entrada del temporizador de 16 bits e interrupciones de desbordamiento (más una variable) para realizar 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, se compila :)

EDIT Observé la salida del archivo lss de mi código, y el código generado tiene demasiadas instrucciones para no tropezar con 1MHz con un reloj de 8MHz ... incluso el simple incremento en uno La línea en el TIM1_OVF_vect genera 19 instrucciones! Así que para manejar eventos de 1MHz, 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 hacia la principal bucle siempre que sea posible.

    
respondido por el vicatcu
2

Publicar este código como una alternativa según la sugerencia de @ timrorr a mi publicación anterior. Esto se compila para el ATTiny24A utilizando el estándar de lenguaje c99, pero en realidad no lo he probado 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.

    
respondido por el vicatcu
2

Usando preescaladores, incluso la medición de GHz se puede lograr. Este es un medidor de frecuencia simple de 40MHz con ATMEL AVR AT90S2313: enlace

Aquí hay otros proyectos similares:

enlace

enlace

enlace

enlace

enlace

enlace

enlace

enlace

enlace

    
respondido por el avra

Lea otras preguntas en las etiquetas