We ended up just counting the number of reads in a specified time and found that they averaged out as they should.

Many thanks for your help,

Donal.

sorry, I was confused – of course you’re right, the code uses interrupts (I somehow thought of my first version of the sketch from which I remembered this behaviour, sorry). The interrupts itself are highly accurate. I would guess that the variations in the timing are a result of the calls to the Serial.println(…) method which is pretty heavyweight. This would explain the milliseconds variation. I don’t have an Arduino here, but you can test this simply by precomputing the values to be printed before the Serial.println calls. I’m thinking of something like

if (oldsecond != second) {
long difference=millis() – starttime;
Serial.print(second);
Serial.print(“. ->”);
Serial.print(difference);
Serial.println(“.”);
}

Please let me know whether this explains the behaviour. If not you can also adjust the timing settings of the interrupt. Please note that Timer2 is used here which has an 8-bit resolution. You could also try to use Timer1 instead which is a 16-bit timer. Depending on your problem you should also read the ATMega168 datasheet – for example, you can built a simple hardware frequency generator based on the timers. Atmel has also a nice introduction to the timer hardware, google for “AVR130: Setup and Use the AVR Timers”.

HTH
-Mathias

many thanks for your reply… I must apologise in advance as I’m a bit of a newbie here… but I was under the impression that this code does use ‘timer interrupts’. I thought it was working off an internal timer that overflows every 256 clock cycles and that when it does the ISR would be triggered. The code I’m using is actually adapted for the atmega168 chip and I have included it below.

My main question now is… is there a more appropriate ‘type’ of interrupt to be using here?

Many thanks,

Donal.

#include
#include

#define INIT_TIMER_COUNT 6
#define RESET_TIMER2 TCNT2 = INIT_TIMER_COUNT

int ledPin = 13;
int int_counter = 0;
volatile int second = 0;
int oldSecond = 0;
long starttime = 0;
//unsigned long m = millis();

// Aruino runs at 16 Mhz, so we have 1000 Overflows per second…
// 1/ ((16000000 / 64) / 256) = 1 / 1000
ISR(TIMER2_OVF_vect) {
RESET_TIMER2;
int_counter += 1;
if (int_counter == 4) {
second+=1;
int_counter = 0;
}
};

void setup() {
Serial.begin(9600);
Serial.println(“Initializing timerinterrupt”);
//so we just hard code this for now.
//Timer2 Settings: Timer Prescaler /64,
TCCR2A |= (1<<CS22);
TCCR2A &= ~((1<<CS21) | (1<<CS20));
// Use normal mode
TCCR2A &= ~((1<<WGM21) | (1<<WGM20));
// Use internal clock – external clock not used in Arduino
ASSR |= (0<<AS2);
//Timer2 Overflow Interrupt Enable
TIMSK2 |= (1<<TOIE2) | (0<<OCIE2A);

sei();
//Timer2 Overflow Interrupt Enable
TIMSK2 = 1<”);
Serial.println(millis() – starttime, DEC);
//Serial.println(“.”);
//digitalWrite(ledPin, HIGH);
//delay(100);
//digitalWrite(ledPin, LOW);
oldSecond = second;
starttime = millis();
}
}

I don’t think this code is appropriate for measuring time in the millisecond range. Basically it uses busy waiting in order to detect the time interval between two DCF77 signals. If you want to measure time exactly, I suggest you take a look at interrupts. The ATMega168 chip provides three programmable timer interrupts which can be used to sample something with high accuracy.

HTH,
-Mathias

when i run this code on my arduino the ms print out has a variation of about 2 – 3 ms, i.e. i see

1 – 1001
2 – 2004
3 – 3002
etc…

is this expected? I am looking for something that can guarantee a consistent 4 ms sampling rate. Is that possible do you think?

I haven’t tested the code with recent Arduino versions – but your problem has something to do with the naming of control registers. Do you use an ATMega168-based Arduino? There are some differences in register naming.

For example, for my DCF77 library I had to define things differently, see

http://gonium.net/md/2007/04/18/tweaking-the-code/

Try to adjust the code accordingly.

HTH,
-Mathias