sompong industrial: พุทโธ

วันศุกร์ที่ 24 พฤศจิกายน พ.ศ. 2560

พุทโธ

Gammon Forum

See www.mushclient.com/spam for dealing with forum spam. Please read the MUSHclient FAQ!

Entire forum

Electronics

Microprocessors

Timers and counters

Home \| Users \| Search \| FAQ
Username:	Register forum user name
Password:	Forgotten password?

Timers and counters

Postings by administrators only.

Refresh page

Pages: 1 2

Posted by Nick Gammon Australia (21,297 posts) bio Forum Administrator

Date Tue 17 Jan 2012 01:17 AM (UTC)Amended on Sat 04 Jul 2015 04:40 AM (UTC) by Nick Gammon

Message

This page can be quickly reached from the link: http://www.gammon.com.au/timers

The Atmega328 (as on the Arduino Uno) has three timers/counters on-board the chip.

Timer 0 is set up by the init() function (which is automatically called by the code generated by the IDE, before setup() is called). This is used to count approximately every millisecond. This provides you with the figure that the millis() function returns.

You can use these timers easily enough by using the analogWrite function - that just generates a PWM (pulse width modulated) output on the various pins that the timer hardware supports.

But for a more in-depth analysis, let's look at using the timers/counters in our own way. :)

The example code below provides a "frequency counter" which counts the number of events which cause a rising edge on digital pin D5 during a specified interval.

For example, if you put a 5 kHz signal on pin D5, and time it for one second, the count will be 5000. You could also time it for 1/10 of a second (giving you a count of 500) and then multiply the result by 10, again giving you a figure of 5 kHz.

A longer timing period will give higher accuracy, and also average out any small variations during the sample time. However, of course, a longer timing period takes longer to execute.

Counter 1 - used to count pulses

In the code below Timer 1 is configured to count the number of times that a leading edge (rising pulse) is detected on D5. Each event increments the internal counter in the timer. When the 16-bit timer overflows an overflow interrupt is executed which counts the number of overflows.

When the time is up, the number of counts is the current counter contents of timer 1, plus the number of overflows multiplied by 65536.

Timer 2 - used to work out a timing interval

The counts are meaningless unless we know over what interval they occurred, which is what we use Timer 2 for. It is set up to take the internal clock (normally 16 MHz on a Uno), and "pre-scale" it by dividing it by 128. The pre-scaled clock will then "tick" every 8 microseconds (since the clock itself runs with a period of 1/16000000 or 62.5 ns).

So we configure Timer 2 to count up to 125 and then generate an interrupt. This interrupt gives us a chance to see if our counting period is up. Since 8 µs times 125 gives 1000 µs, that means we get interrupted exactly every 1 ms.

Note that Timer 2 has a higher priority than Timers 0 and 1, so neither the millis() timer, nor the Timer 1 counter will take precedence over this interrupt.

In the Timer 2 interrupt we see if time is up (basically whether the required number of milliseconds is up). Is not, we just keep going. If time is up, we turn off both Timers 1 and 2, calculate the total count (by multiplying the number of overflows by 65536 and adding in the remaining counts) and exit.

Frequency Counter sketch for Atmega328


// Timer and Counter example
// Author: Nick Gammon
// Date: 17th January 2012

// Input: Pin D5

// these are checked for in the main program
volatile unsigned long timerCounts;
volatile boolean counterReady;

// internal to counting routine
unsigned long overflowCount;
unsigned int timerTicks;
unsigned int timerPeriod;

void startCounting (unsigned int ms) 
  {
  counterReady = false;         // time not up yet
  timerPeriod = ms;             // how many 1 ms counts to do
  timerTicks = 0;               // reset interrupt counter
  overflowCount = 0;            // no overflows yet

  // reset Timer 1 and Timer 2
  TCCR1A = 0;             
  TCCR1B = 0;              
  TCCR2A = 0;
  TCCR2B = 0;

  // Timer 1 - counts events on pin D5
  TIMSK1 = bit (TOIE1);   // interrupt on Timer 1 overflow

  // Timer 2 - gives us our 1 ms counting interval
  // 16 MHz clock (62.5 ns per tick) - prescaled by 128
  //  counter increments every 8 µs. 
  // So we count 125 of them, giving exactly 1000 µs (1 ms)
  TCCR2A = bit (WGM21) ;   // CTC mode
  OCR2A  = 124;            // count up to 125  (zero relative!!!!)

  // Timer 2 - interrupt on match (ie. every 1 ms)
  TIMSK2 = bit (OCIE2A);   // enable Timer2 Interrupt

  TCNT1 = 0;      // Both counters to zero
  TCNT2 = 0;     

  // Reset prescalers
  GTCCR = bit (PSRASY);        // reset prescaler now
  // start Timer 2
  TCCR2B =  bit (CS20) | bit (CS22) ;  // prescaler of 128
  // start Timer 1
  // External clock source on T1 pin (D5). Clock on rising edge.
  TCCR1B =  bit (CS10) | bit (CS11) | bit (CS12);
  }  // end of startCounting

ISR (TIMER1_OVF_vect)
  {
  ++overflowCount;               // count number of Counter1 overflows  
  }  // end of TIMER1_OVF_vect


//******************************************************************
//  Timer2 Interrupt Service is invoked by hardware Timer 2 every 1 ms = 1000 Hz
//  16Mhz / 128 / 125 = 1000 Hz

ISR (TIMER2_COMPA_vect) 
  {
  // grab counter value before it changes any more
  unsigned int timer1CounterValue;
  timer1CounterValue = TCNT1;  // see datasheet, page 117 (accessing 16-bit registers)
  unsigned long overflowCopy = overflowCount;

  // see if we have reached timing period
  if (++timerTicks < timerPeriod) 
    return;  // not yet

  // if just missed an overflow
  if ((TIFR1 & bit (TOV1)) && timer1CounterValue < 256)
    overflowCopy++;

  // end of gate time, measurement ready

  TCCR1A = 0;    // stop timer 1
  TCCR1B = 0;    

  TCCR2A = 0;    // stop timer 2
  TCCR2B = 0;    

  TIMSK1 = 0;    // disable Timer1 Interrupt
  TIMSK2 = 0;    // disable Timer2 Interrupt
    
  // calculate total count
  timerCounts = (overflowCopy << 16) + timer1CounterValue;  // each overflow is 65536 more
  counterReady = true;              // set global flag for end count period
  }  // end of TIMER2_COMPA_vect

void setup () 
  {
  Serial.begin(115200);       
  Serial.println("Frequency Counter");
  } // end of setup

void loop () 
  {
  // stop Timer 0 interrupts from throwing the count out
  byte oldTCCR0A = TCCR0A;
  byte oldTCCR0B = TCCR0B;
  TCCR0A = 0;    // stop timer 0
  TCCR0B = 0;    
  
  startCounting (500);  // how many ms to count for

  while (!counterReady) 
     { }  // loop until count over

  // adjust counts by counting interval to give frequency in Hz
  float frq = (timerCounts *  1000.0) / timerPeriod;

  Serial.print ("Frequency: ");
  Serial.print ((unsigned long) frq);
  Serial.println (" Hz.");
  
  // restart timer 0
  TCCR0A = oldTCCR0A;
  TCCR0B = oldTCCR0B;
  
  // let serial stuff finish
  delay(200);
  }   // end of loop

[EDIT] Amended 25 April 2012 to make more accurate by allowing for overflows in Timer 1 during the interrupt service routine, and by stopping Timer 0.

[EDIT] Amended 28 June 2013 to fix bug where I was testing for TIFR1 & TOV1 rather than TIFR1 & _BV (TOV1).

[EDIT] Amended 31 August 2013 to change _BV() to bit().

Accuracy

Pumping in a 5 MHz signal from a signal generator, the sketch outputs around 5001204 (give or take a couple of counts). The error (assuming the signal generator is accurate) is therefore 1204/500000 or about 0.02% error.

Trying with a 5 kHz signal, the sketch outputs around 5000 to 5002, an error of 2/5000 or 0.04% error.

So, pretty accurate. Tests on my Arduino clock showed that the clock itself was around 0.2% wrong, so we can't really expect better accuracy than that.

Range

I measured up to 8 MHz with about 0.5% error. At 5 MHz the error was down to 0.02% as described above. At the other end of the scale, it measured down to 10 Hz without any obvious error. Below that errors crept in, particularly as the sample period is only 500 ms.

More examples of timers and interrupts here:

http://gammon.com.au/interrupts

Frequency Counter sketch for Atmega2560


// Timer and Counter example for Mega2560
// Author: Nick Gammon
// Date: 24th April 2012

// input on pin D47 (T5)

// these are checked for in the main program
volatile unsigned long timerCounts;
volatile boolean counterReady;

// internal to counting routine
unsigned long overflowCount;
unsigned int timerTicks;
unsigned int timerPeriod;

void startCounting (unsigned int ms) 
  {

  counterReady = false;         // time not up yet
  timerPeriod = ms;             // how many 1 ms counts to do
  timerTicks = 0;               // reset interrupt counter
  overflowCount = 0;            // no overflows yet

  // reset Timer 2 and Timer 5
  TCCR2A = 0;
  TCCR2B = 0;
  TCCR5A = 0;             
  TCCR5B = 0;  

  // Timer 5 - counts events on pin D47
  TIMSK5 = bit (TOIE1);   // interrupt on Timer 5 overflow

  // Timer 2 - gives us our 1 ms counting interval
  // 16 MHz clock (62.5 ns per tick) - prescaled by 128
  //  counter increments every 8 µs. 
  // So we count 125 of them, giving exactly 1000 µs (1 ms)
  TCCR2A = bit (WGM21) ;   // CTC mode
  OCR2A  = 124;            // count up to 125  (zero relative!!!!)

  // Timer 2 - interrupt on match (ie. every 1 ms)
  TIMSK2 = bit (OCIE2A);   // enable Timer2 Interrupt

  TCNT2 = 0;     
  TCNT5 = 0;      // Both counters to zero

  // Reset prescalers
  GTCCR = bit (PSRASY);        // reset prescaler now
  // start Timer 2
  TCCR2B =  bit (CS20) | bit (CS22) ;  // prescaler of 128
  // start Timer 5
  // External clock source on T4 pin (D47). Clock on rising edge.
  TCCR5B =  bit (CS50) | bit (CS51) | bit (CS52);

}  // end of startCounting

ISR (TIMER5_OVF_vect)
{
  ++overflowCount;               // count number of Counter1 overflows  
}  // end of TIMER5_OVF_vect


//******************************************************************
//  Timer2 Interrupt Service is invoked by hardware Timer 2 every 1 ms = 1000 Hz
//  16Mhz / 128 / 125 = 1000 Hz

ISR (TIMER2_COMPA_vect) 
{
  // grab counter value before it changes any more
  unsigned int timer5CounterValue;
  timer5CounterValue = TCNT5;  // see datasheet, (accessing 16-bit registers)

  // see if we have reached timing period
  if (++timerTicks < timerPeriod) 
    return;  // not yet

  // if just missed an overflow
  if (TIFR5 & TOV5)
    overflowCount++;

  // end of gate time, measurement ready

  TCCR5A = 0;    // stop timer 5
  TCCR5B = 0;    

  TCCR2A = 0;    // stop timer 2
  TCCR2B = 0;    

  TIMSK2 = 0;    // disable Timer2 Interrupt
  TIMSK5 = 0;    // disable Timer5 Interrupt

  // calculate total count
  timerCounts = (overflowCount << 16) + timer5CounterValue;  // each overflow is 65536 more
  counterReady = true;              // set global flag for end count period
}  // end of TIMER2_COMPA_vect


void setup () {
  Serial.begin(115200);       
  Serial.println("Frequency Counter");
} // end of setup


void loop () {

  // stop Timer 0 interrupts from throwing the count out
  byte oldTCCR0A = TCCR0A;
  byte oldTCCR0B = TCCR0B;
  TCCR0A = 0;    // stop timer 0
  TCCR0B = 0;    
  
  startCounting (500);  // how many ms to count for

  while (!counterReady) 
     { }  // loop until count over

  // adjust counts by counting interval to give frequency in Hz
  float frq = (timerCounts *  1000.0) / timerPeriod;

  // restart timer 0
  TCCR0A = oldTCCR0A;
  TCCR0B = oldTCCR0B;

  Serial.print ("Frequency: ");
  Serial.println ((unsigned long) frq);
  
  // let serial stuff finish
  delay(200);

}   // end of loop

[EDIT] Amended 25 April 2012 to make more accurate by allowing for overflows in Timer 1 during the interrupt service routine, and by stopping Timer 0.

[EDIT] Amended 4 September 2013 to change _BV() to bit().

Timer ready reckoner

To help work out what prescaler/count you need for setting up timers, consult this table:

All these figures assume a 16 MHz clock, and thus a clock period of 62.5 ns.

The "count" column is the number of counts you use for the Output Compare Register (eg. for OCR2A, OCR2B and so on) when counting up to a "compare" value. The count of 256 can also be used to see how long until Timer 0 and Timer 2 overflow (Timer 1 is a 16-bit timer and overflows after 65536 counts).

Remember that the count registers are zero-relative, so to get 100 counts, you actually put 99 into the register.

So for example, with a prescaler of 64, Timer 0 will overflow every 1.024 ms (which in fact it normally does for use by the millis() function).

To set some other frequency choose a prescaler which appears reasonably close, and then apply this formula:


count = frequency_from_table / target_frequency

For example, if we wanted to flash an LED at 50 Hz using a prescaler of 1024:


count = 15625 / 50 = 312.5

Since 312.5 is greater than 256 we could only do that with Timer 1 which is a 16-bit timer. Note that 312.5 has a decimal place, and therefore the flash would not occur every 50 Hz (as it would be rounded down). You could choose a prescaler of 256 instead:


count = 62500 / 50 = 1250

Now, we have a whole number, so the frequency would be accurate.

Bear in mind, too, that if you are using the hardware to toggle a pin, it needs to get toggled at twice the target frequency (because 100 Hz is counting 100 times a complete cycle, not half a cycle).

Timer hardware input/output

The table below shows the relationship between various pins (with the Arduino pin number in brackets) and the respective timers.

For example, to count an external source with Timer 1, you connect that to Arduino pin D5 (pin 11 on the Atmega328).


Timer 0

input     T0     pin  6  (D4)

output    OC0A   pin 12  (D6)
output    OC0B   pin 11  (D5)

Timer 1

input     T1     pin 11  (D5)

output    OC1A   pin 15  (D9)
output    OC1B   pin 16  (D10)

Timer 2

output    OC2A   pin 17  (D11)
output    OC2B   pin  5  (D3)

- Nick Gammon

www.gammon.com.au, www.mushclient.com

วันศุกร์ที่ 24 พฤศจิกายน พ.ศ. 2560

พุทโธ

Gammon Forum

ไม่มีความคิดเห็น:

แสดงความคิดเห็น