Electronic – counter giving erratic results for frequency measurement using Atmega32

atmegacfrequency-measurementmicrocontroller

I am using a photosensor which gives output as a square wave. The frequency of this square wave is being measured using Atmega32A with 1MHz clock. The full scale output of sensor is 500kHz.

The output of the photosensor is connected to pin T1 and I'm using timer1 clock as a reference to determine the frequency. I have a 100 ms delay using software loop after which I read the timer value and multiply by 10 to get the photosensor output frequency.

The frequency values being obtained using oscilloscope are around 50-100kHz. However the frequency values being returned by this code are around 80Hz greater than value measured with an ocilloscope in one setting .If I change the location of the whole setup this constant extra value is changing to another constant . What am I doing wrong?

uint32_t MeasureFrequency()
{
uint32_t freq=0;
DDRB &= ~(1<<PINB1);uint32_t count=0;

TCCR1B |=(1<<CS12);
TCCR1B |=(1<<CS11);
TCCR1B &=~(1<<CS10);            //0.Initalize



TCNT1=0x0000;               //1.Clear timer 0 contents

TIFR &=~(1<<TOV1);          //2.Clear timer 0 flag

//count=TCNT1;
while(TCNT1<1)
{;}//count=TCNT1;}  


if(TCNT1>=1)                //3.Check if timer has incremented once
{_delay_ms(100);}           //4.100ms delay



TCCR1B &=~(1<<CS12);
TCCR1B &=~(1<<CS11);
TCCR1B &=~(1<<CS10);        //5.Disconnect timer clock from input

uint8_t i=TIFR;
i = i&(0b00000100);


if(i==4)
{Send_A_Character('v');}

count=TCNT1;            //6.Read Timer

return freq=count*10;   //7.Freq=timer*10

     }

Best Answer

_delay_ms() is a very unprecise function, besides it takes precessor time to call it and return back.

There are many ways you could use atmega's peripherals to measure frequency, if you want to go by feeding input frequency to T1, I would suggest using another timer to measure time. You could set up and start both timers simultaneously, then catch overflow interrupt of "time" timer which will happen exactly after 256*prescaler system clock ticks, then do your math.

On another note, I would suggest you to increase your processor clock frequency as 500KHz is only 2 times less than 1MHz (Nyquist theorem), that is enough, but you will not get much accuracy at the high end.

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.

Ideal Hardware Timer Setup Routine

First I would suggest using time instead of frequency, since the latter implies that the timer is of a continuous kind. The user is often interested in a certain "one-shot" delay, when waiting for some sort of hardware to become available.

Second, uint32_t is a big NO on 8-bit microcontrollers. As soon as you use 32-bit numbers, every 8-bitter on the market will create a flood of inefficient machine code, likely with internal subroutine calls. 16 bit numbers are bad enough. Though of course, there are cases where you need high resolution accuracy and then you might have to reluctantly use large integer types.

In this case, I very much doubt that your 8-bit MCU has a 32-bit timer peripheral. De facto standard for 8-bitters is to have 16-bit hardware timers. There is no point of specifying a resolution that doesn't correspond with the hardware.

Using floating point is even worse: if you ever find yourself needing floating point accuracy on a 8-bit MCU, you most likely picked the wrong MCU for your project to begin with. (The cost argument of 8-bit vs 32-bit has been obsolete forever.)

Based on the above argument, I would suggest something like:

void set_timer (uint16_t ms);

where ms is the time in miliseconds.

The ideal case is however to calculate the needed timing in the pre-processor, then show that into a constant, which is then directly read into the timer hardware registers.

Best Answer

Related Solutions

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

Ideal Hardware Timer Setup Routine

Related Topic