AVR Freaks

Thanks for the link. That looks better. Too bad that "any exit path" doesn't include the return statement, so this doesn't seem to be possible (generates a compiler warning):

    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        return timerMillis;
    }

(The code editor in this forum is broken today.)

I like to use such syntax in C# but the C macros (which I didn't understand when looking at their definition) don't seem to provide the same level of comfort.

I'm already using the less capable TCB timer for other functions that I'll keep in production code (countdowns and callbacks at millisecond resolution). I couldn't figure out how to employ the TCD timer for this job, so I went back to the TCA timer. I'm also using that for PWM output, but not everywhere and I don't need these timer functions in production for now. I just wrote this to learn about the timing behaviour of the code. When I know that, I can write the code so that it works best for the timings I observed. I don't think I'll need generic microsecond measurements for real applications.

Also, from what I've seen, all 1-series chips have the same amount and types of timers. There's especially no more than 3 16-bit PWM outputs which severely limits this platform for my intended use as multi-channel LED dimmer (up to 8 channels). For that application I'll probably use an ESP32 that has many more (16) such outputs.

Hm, as I understand it, when the counter overflows, an interrupt is generated. That doesn't mean that the ISR is immediately called though. What if the following happens:

1. The micros() function is entered
2. The interrupts are disabled
3. The counter increments, and at this time overflows. This also sets the overflow interrupt flag
4. CNT is read (meanwhile it's somewhere between 0 and 20 because it increments with every CPU cycle)
5. timerMillis is read (which hasn't been updated yet because interrupts are disabled)
6. CNT is read again (it's greater than before) and the loop is left

Now we've got wrong data because we were using an outdated timerMillis and didn't notice it. The root issue is that we never know whether timerMillis is current or outdated related to CNT, and that's from the moment we disable interrupts. The only thing we know is that if the OVF flag is set, timerMillis was scheduled for incrementing, but hasn't yet.

Based on my update comment 3 I figured it might be the best compromise to look at the actual CNT value that was used for the calculation (only read that once). If the overflow interrupt is set and CNT was low, then timerMillis wasn't updated but the counter has already overflown. Should CNT still be high, it likely hasn't overflown yet so no correction is required. Here's the new code for that:

timer.cpp:

#include "config.h"
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/atomic.h>
#include "timer.h"

volatile static uint32_t timerMillis;

#define TIMER_TOP (F_CPU / 1000 - 1)   // Overflow after 1 ms

// Initializes the use of the timer functions by setting up the TCA timer.
void initTimer()
{
	TCA0.SINGLE.PER = TIMER_TOP;
	TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;   // Enable overflow interrupt
	TCA0.SINGLE.CTRLA = TCA_SINGLE_ENABLE_bm;   // Start without prescaler, at full CPU clock speed
}

// TCA overflow handler, called every millisecond.
ISR(TCA0_OVF_vect)
{
	timerMillis++;
	// Clear the interrupt flag (to reset TCA0.CNT)
	TCA0.SINGLE.INTFLAGS |= TCA_SINGLE_OVF_bm;
}

// Gets the milliseconds of the current time.
uint32_t millis()
{
	uint32_t m;
	ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
	{
		m = timerMillis;
	}
	return m;
}

// Gets the microseconds of the current time.
uint32_t micros()
{
	uint32_t ms;
	uint16_t cnt;
	uint8_t flags;
	ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
	{
		ms = timerMillis;
		cnt = TCA0.SINGLE.CNT;
		flags = TCA0.SINGLE.INTFLAGS;
	}
	// If the timer has overflowed, and the ISR hasn't run yet (it clears the overflow flag),
	// and CNT is in its first half (read CNT after overflow is more likely than overflow after
	// read CNT), then add 1 ms to compensate that timerMillis wasn't updated yet
	if ((flags & TCA_SINGLE_OVF_bm) && cnt < TIMER_TOP / 2)
		ms++;
	// First convert milliseconds to microseconds
	// Then add timer value converted to microseconds
	return ms * 1000 + cnt / (F_CPU / 1000000L);
}

The following has changed:

• #define TIMER_TOP, to use the same value at init and for calculation
• micros() implementation changed as described

I've tested this function to measure the time between two received bytes on UART. It provides consistently good values which are around the expected rate (for 9600 and 115 200 baud), ±5 µs, most are ±1 µs. I don't know whether I've actually hit an overflow though.