Alternative methods after disabling millis() and micros()?

[dattasaurabh82]

HW setup:

uC: ATTINY1607-MFR clocked at 5MHz (necessary freq. for my main application later)
Operating Voltage: 3.7V from 120mAH LiPo Battery.
BOD disabled in Fuse (From IDE's tools Menu)

I have a code blocks where I use millis() as well in another, micros() to watch some timing, like below (very typical application):

unsigned long startMillis;
unsigned long currMillis;
const unsigned long period = 1000; 

void setup(){
  startMillis = millis();
}

void loop(){
  if (currentMillis - startMillis >= period) {
    // Every 1 sec, toggle something ....
    startMillis = currentMillis;
  }
}

Statement 1:

I want to disable millis() and micros() from the "Tools" dropdown, to possibly save some flash as well as, later to compliment some power saving, if disabling millis() and micros() does contribute to some runtime power saving (if implemented along side the methods described in the PowerSave.md) - Don't know ?

1. What timers are controlling millis(), micros(), (Got lost in documentation)?
2. Can we also disable those timers in void setup(){}?
3. In void setup(){}, is there a need to disable millis() and micros() if they were disabled from "Tools"? If so, how to do that?

Statement 2:

Let's say after successful disabling of millis() and micros(), I want to use something similar for time keeping. So I want to create my custom millis() and micros().

1. RTC method? (Which Timers can be disabled ?)
2. Timer Method? (If some specific timers are used, which others can be disabled ?)

Either way, example to create own functions like millis() and micros() using either RTC or some specific timers would be very helpful.

May be looking to wiring.c:

#include "wiring_private.h"

// the prescaler is set so that timer0 ticks every 64 clock cycles, and the
// the overflow handler is called every 256 ticks.
#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256)) 
// ** May be we can use 32 KHz here as well

// the whole number of milliseconds per timer0 overflow
#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)

// the fractional number of milliseconds per timer0 overflow. we shift right
// by three to fit these numbers into a byte. (for the clock speeds we care
// about - 8 and 16 MHz - this doesn't lose precision.)
#define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
#define FRACT_MAX (1000 >> 3)

volatile unsigned long timer0_overflow_count = 0;
volatile unsigned long timer0_millis = 0;
static unsigned char timer0_fract = 0;


unsigned long millis(){
	unsigned long m;
	uint8_t oldSREG = SREG;
	// disable interrupts while we read timer0_millis or we might get an
	// inconsistent value (e.g. in the middle of a write to timer0_millis)
	cli();
	m = timer0_millis;
	SREG = oldSREG;
	return m;
}

unsigned long micros() {
	unsigned long m;
	uint8_t oldSREG = SREG, t;
	cli();
	m = timer0_overflow_count;
#if defined(TCNT0)
	t = TCNT0;
#elif defined(TCNT0L)
	t = TCNT0L;
#else
	#error TIMER 0 not defined
#endif

#ifdef TIFR0
	if ((TIFR0 & _BV(TOV0)) && (t < 255))
		m++;
#else
	if ((TIFR & _BV(TOV0)) && (t < 255))
		m++;
#endif

	SREG = oldSREG;
	return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
}

How to transform this for ATTINY-1604, say if I wanted to create some functions?
Some help here would be very much appreciated

[grandaspanna]

The RTC is pretty good for this. Set it up to run as often as you like by setting the prescaler and period, activate the PIT interrupt and will invoke your interrupt code each time the cycle period is up. At a bare minimum, it could even just wake up your microcontroller, which just resumes from where you put it to sleep, or you can set a flag for your main loop to check.

I've used Start to generate the skeleton code for this stuff and it works fine. So, here's a simple example that fires the interrupt every millisecond.

void RTC_0_init()
{
  // Set up the RTC to trigger an interrupt every 1ms
    while (RTC.STATUS > 0)
  {
    /* Wait for all register to be synchronized */
  }
    RTC.CTRLA = RTC_PRESCALER_DIV1_gc   /* 1 */
    | 1 << RTC_RTCEN_bp     /* Enable: enabled */            
    | 0 << RTC_RUNSTDBY_bp; /* Run In Standby: disabled */
    
  
  // RTC.CLKSEL = RTC_CLKSEL_INT32K_gc; /* 32KHz Internal Ultra Low Power Oscillator (OSCULP32K) */
    while (RTC.PITSTATUS > 0) { 
    /* Wait for all register to be synchronized */
    }
   
  RTC.PITCTRLA = RTC_PERIOD_CYC32_gc  /* RTC Clock Cycles 32 */
  | 1 << RTC_PITEN_bp; /* Enable: enabled */
  
  RTC.PITINTCTRL = 1 << RTC_PI_bp; /* Periodic Interrupt: enabled */
  }

That sets up the RTC with a 1ms period

Setup your interrupt:

ISR(RTC_PIT_vect)
{
  /* This code is called every time the RTC PIT interrupt is triggered */
  do_thing = true;
  
  /* The interrupt flag has to be cleared manually */
  RTC.PITINTFLAGS = RTC_PI_bm;
}

I will not claim this is best practice, but works pretty well for my use-cases.

[dattasaurabh82]

Dumb question, Can I run more than one RTC instances at the same time with different timings?
So that diff ISRs can watch diff flags from each RTC instance, for example.

[grandaspanna]

Best start with the documentation on the RTC. There's only one RTC, so it would come down to a bit of cleverness in your ISR to work out what to do.

[SpenceKonde]

The millis and micros timer can be selected from the menu, defaults to TCA0 on parts with neither TCB1 nor TCD0 (like 1607). Parts with a TCD0 use that (since someone is unlikely to want to reprogram it because it;s nasty to work with), 2-series has a TCB1 and uses that (you don't want to use TCB0 if that's your only type B timer,because then tone, servo and some other basic libraries don't work)

Disabling millis likely saves a tiny amount of power while the chip is in active mode only, if it's in sleep power down or standby without run standby set, it makes no difference because it's turned off

If you want to implement your own versions of the timing functions, the only way to do that is to disable millis from the start, because you can only have one ISR defined for each vector.

You get the RTC/PIT combo (note that on 0/1-series with 16k or less flash, you need to enable the PIT and RTC together or they don't work right, see errata - you don't need to enable the PIT interrupt, but you need to enable the PIT in RTC.PITCTRLA.

[dattasaurabh82]

So if the power saving is not much during runtime with disabled millis() and micros() ( even though it occupies a tiny bit of flash - that I see as the main advantage), it would be then a good compromise to keep it rather than going the route and hassle of alternate methods.
Just being lazy 😕