Electronic – arduino – Determine input frequency of square wave w/ ICR in Atmega328p

arduinoatmelavrinterruptsmicrocontroller

I'm trying to obtain the input frequency of a square wave using the input capture register of an Atmega328p. So far, it works sporadically — which is to say, when I input a 75 kHz square wave, the output looks like this:

244
244
75117
74766
75117
75117
79207
80402
82051
82901
84656
85561
87431
244
244
244
88888
90395
244
244
244
-941176
-271186
244
-246153
244
244
244

Does anyone know why this might be the case? I've tried messing with the data types, but otherwise I'm not really sure what the problem could be. The code I've written is below.

// # of overflows
volatile long T1Ovs;

// timestamp variables (store TCNT at time of input capture interrupt)
volatile long Capt1, Capt2;

// capture flag
volatile uint8_t Flag;

volatile long ticks;
volatile double period;
volatile long frequency;

void initTimer1(void)
{
  TCNT1 = 0;
  // initialize timer to 0

  //timer/counter1 control register b
  TCCR1B |= (1<<ICES1);
  // input capture edge select; rising edge triggers capture

  //timer/counter1 interrupt mask register
  TIMSK1 |= (1<<ICIE1);
  // ICIE1: input capture interrupt enable

  TIMSK1 |= (1<<TOIE1);
  // timer/counter1 overflow interrupt enable
}

void startTimer1(void)
{
  TCCR1B = (1<<CS10);
  //start timer with pre-scaler = 1

  sei();
  //enable global interrupts

}

ISR(TIMER1_CAPT_vect) // interrupt handler on input capture match (rising edge in this case)
{
  if (Flag == 0)
  {
    Capt1 = ICR1;
    // save timestamp at interrupt (input capture is updated with the counter (TCNT1)
    // value each time an event occurs on the ICP1 pin (digital pin 8, PINB0)

    T1Ovs = 0;
    // reset overflows
  }

  if (Flag ==1)
  {
    Capt2 = ICR1;
  }

  Flag ++;
}

ISR(TIMER1_OVF_vect) // interrupt handled on timer1 overflow
{
  T1Ovs++; // increment number of overflows
}


void setup()
{
  Serial.begin(9600);


  initTimer1();
  startTimer1();
}

void loop()
{
  if (Flag == 2)
  {
    ticks = Capt2 - Capt1 + T1Ovs * 0x10000L;
    // (second timestamp) - (first stamp) + (# of overflows) * (ticks/overflow = 65535)

    frequency = 16000000/ticks;
    // ticks * seconds/ticks = seconds
    // 1/seconds = Hz

    Flag = 0;
    // reset flags

    T1Ovs = 0;
    // reset overflow count

    TIFR1 = 0b00000000; // clear interrupt registers

    Serial.println(frequency);


    TIMSK1 |= (1 << ICIE1); // enable capture interrupt
    TIMSK1 |= (1 << TOIE1); // enable overflow interrupt

  }
}

Thanks in advance!

UPDATE***********************************

The second iteration of code, using enumerated types to make a state machine:

  typedef enum {
      CAPTURE_1,
      CAPTURE_2,
      WAIT
  } timer_state_t;

  timer_state_t flag = WAIT;
   volatile long Capt1, Capt2;

  volatile long T1Ovs;

  void InitTimer1(void)
  {
     //Set Initial Timer value
     TCNT1=0;
     //First capture on rising edge
     TCCR1B|=(1<<ICES1);
     //Enable input capture and overflow interrupts
     TIMSK1|=(1<<ICIE1)|(1<<TOIE1);
  }
  void StartTimer1(void)
  {
  //Start timer without prescaler
  TCCR1B|=(1<<CS10);
  //Enable global interrutps
     sei();
  }

  ISR(TIMER1_CAPT_vect) {
   switch(flag) {
   case CAPTURE_1:
       Capt1 = ICR1;

       flag = CAPTURE_2;
       break;
   case CAPTURE_2:
       Capt2 = ICR1;

       flag = WAIT;
                    Serial.println(flag);

       break;
      }



  }

  ISR(TIMER1_OVF_vect)
  {
    T1Ovs++;
  }

  void setup()
  {
    Serial.begin(9600);

    InitTimer1();
    StartTimer1();
  }

  void loop() {
    flag = CAPTURE_1;

    while (flag != WAIT);
     Serial.println("loop");

    Serial.println(Capt2 - Capt1 + T1Ovs * 0x10000);
  }

Best Answer

Here is your code updated to work, with comments starting with "J:" explaining the changes...

  typedef enum {
      CAPTURE_1,
      CAPTURE_2,
      WAIT
  } timer_state_t;

  volatile timer_state_t flag = WAIT;

  // J:This is a 16-bit timer, so these values will always fit into an unsigned int
  volatile unsigned int Capt1, Capt2, CaptOvr;

  // J:Mind as well make this unsigned and give it 2x range since it can never be negative. 
  volatile unsigned long T1Ovs;

  void InitTimer1(void)
  {
     //Set Initial Timer value
     // J:All measurements against TCNT are relative, so no need to reset
     // TCNT1=0;

     // J: Note we need to set up all the timer control bits because we do not know what state they are in
     // J: If, for example, the WGM bits are set to a PWM mode then the TCNT is going to be resetting out from under us rather than monotonically counting up to MAX

     TCCR1A = 0x00;

     //First capture on rising edge
     TCCR1B =(1<<ICES1);
     //Enable input capture and overflow interrupts
     TIMSK1|=(1<<ICIE1)|(1<<TOIE1);
  }

 // J: Note that it would be ok to start the timer when we assign TCCR1B in InitTimer since nothing will happen when the ISR is called until we set flag to CAPTURE1

  void StartTimer1(void)
  {
  //Start timer without prescaler

  // J: Note that we know that the other CS bits are 0 becuase of the Assignment in InitTimer
  TCCR1B |= (1<<CS10);  

  //Enable global interrutps
  // J: Interrupts are turned on by  Arduino platform startup code
  //  sei();
  }

  ISR(TIMER1_CAPT_vect) {

   switch(flag) {
   case CAPTURE_1:
       Capt1 = ICR1;

       // J: Reset the overflow to 0 each time we start a measurement
       T1Ovs=0;
       doubleOverflowError=0;
       flag = CAPTURE_2;
       break;

   case CAPTURE_2:
       Capt2 = ICR1;

       // J: Grab a snap shot of the overflow count since the timer will keep counting (and overflowing);
       CaptOvr = T1Ovs;    
       flag = WAIT;

       //J: Generally bad to print in ISRs
       //Serial.println(flag);

       break;
      }
  }


  ISR(TIMER1_OVF_vect)
  {
    T1Ovs++;

    // J: Just to be correct, check for overflow of the overflow, otherwise if it overflows we would get an incorrect answer.
    if (!T1Ovs) {
      doubleOverflowError=1;
    }
  }

  void setup()
  {

    Serial.begin(9600);

    InitTimer1();
    StartTimer1();
  }

  void loop() {
    // J: No need to bracket this set with cli() becuase the counter will not be counting until wait is updated

    flag = CAPTURE_1;

    while (flag != WAIT);


    // J: Parenthesis and explicit cast for good luck! ( and to ensure correct size and order for operations) 


     if (doubleOverflowError) {
         Serial.println( "Double Overflow Error! Use a bigger prescaller!");
     } else {
         Serial.println( ( (unsigned long) (Capt2) + (CaptOvr * 0x10000UL) )-Capt1 );
     } 
}

Related Solutions

Electronic – Measuring 0 – 1MHz ( 0.25Hz resolution) Squarewave using an MCU

If possible I'd suggest selecting a microcontroller that supports a counter operation using the timer inputs; rather than manually incrementing a counter inside an ISR (which at high frequencies quickly ends up saturating the microcontroller activity) you allow the hardware to handle the counting. At this point your code simply becomes a matter of waiting for your periodic interrupt then calculating the frequency.

To extend the range and make the frequency counter more generalised (removing the need for multiple ranges at the expense of a little more work for the MCU) you could use the following technique.

Select a periodic interrupt rate that allows for measurement accuracy at the highest input frequency; this should take into account your counter size (you need to select the timer period such that the timer counter will not overflow at the maximum input frequency). For this example I'll assume that the input counter value can be read from the variable "timer_input_ctr".

Include a variable for counting periodic interrupts (should be initialised to 0 at startup); for this example I'll refer to this variable as "isr_count". The interrupt period is contained in the constant "isr_period".

Your periodic interrupt should be implemented as (C pseudo-code):

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;
  }
}

Obviously this rough example relies on some floating point math that may not be compatible for low-end microcontrollers, there are techniques to overcome this but they are outside of the scope of this answer.

Electronic – arduino – dynamically change the input clock frequency of the AT91SAM3X8E

I don't know anything about the AT91SAM3X8E specifically, but I'll guess an answer based on my knowledge of ICs.

Theoretically, there's no reason why you wouldn't be able to dynamically change the master clock frequency in a digital circuit. What you have to be careful of is that during the switching you cannot have any two successive rising edges that violate the maximum frequency of the device. If you imagine switching from one waveform to another when the 'switched from' clock is falling and the 'switched to' clock is rising, then you could get a clock period for one cycle which could be much less than the period of either clock. This would blow the timing on several of the paths and leave your micro in an illegal state.

If you have some way to guarantee that you can properly synchronize the transition between the clocks without creating such a pulse, I can't think of any problem with it.

Best Answer

Related Solutions

Electronic – Measuring 0 – 1MHz ( 0.25Hz resolution) Squarewave using an MCU

Electronic – arduino – dynamically change the input clock frequency of the AT91SAM3X8E

Related Topic