keep track of system time

[djdisodo]

static mut SYSTEM_TIME: Duration = Duration::from_secs(0);

const CLOCKS_PER_SECOND: u128 = 16000000;
const PRESCALER: u128 = 8;
const CLOCKS_PER_COUNT: u128 = PRESCALER * 256;
const DURATION_PER_COUNT: Duration = {
    // assert_eq!(
    //     (CLOCKS_PER_COUNT * Duration::from_secs(1).as_nanos()) % CLOCKS_PER_SECOND,
    //     0,
    //     "leftover in division, this may cause error accumulation"
    // );
    let duration_per_count = Duration::from_nanos(((CLOCKS_PER_COUNT * Duration::from_secs(1).as_nanos()) / CLOCKS_PER_SECOND) as u64);
    // assert_eq!(
    //     duration_per_count <= Duration::from_millis(1),
    //     true,
    //     "time precision too low"
    // );
    duration_per_count
};

#[avr_device::interrupt(atmega328p)]
unsafe fn TIMER0_OVF() {
    avr_device::interrupt::free(|_| {
        SYSTEM_TIME += DURATION_PER_COUNT;
    });
}

pub unsafe fn init_system_time(tc: &mut TC0) {
    avr_device::interrupt::enable();
    avr_device::interrupt::free(|_| {
        SYSTEM_TIME = Duration::from_secs(0);
        tc.tccr0b.write(|w| w.cs0().prescale_8());
        tc.timsk0.write(|w| w.toie0().bit(true));
        tc.tcnt0.write(|w| w.bits(0));
    });
}

pub fn system_time() -> Duration {
    unsafe {
        avr_device::interrupt::free(|_| {
            SYSTEM_TIME
        })
    }
}

/// embedded-hal countdown implementation
/// you can create this counter as many as you want
/// and these won't add any processor load
#[derive(Default)]
struct Counter {
    target_system_time: Duration
}

impl CountDown for Counter {
    type Time = Duration;

    fn start<T>(&mut self, count: T) where T: Into<Self::Time> {
        self.target_system_time = system_time() + count.into();
    }

    fn wait(&mut self) -> nb::Result<(), avr_hal_generic::void::Void> {
        if self.target_system_time < system_time() {
            Ok(())
        } else {
            Err(nb::Error::WouldBlock)
        }
    }
}

this code is for uno and values came out of nowhere
(not great, not terrible precision-inturruptFrequency balance)
how do you think?
would it be better to have library for this?

[Rahix]

Just as another data point, I implemented something similar in https://blog.rahix.de/005-avr-hal-millis/ with the code in https://github.com/Rahix/avr-hal/blob/main/examples/arduino-uno/src/bin/uno-millis.rs.

But in the long run, I agree that it would be nice to provide a generic implementation of this that others can use. Not sure whether this fits into the HAL (due to the interrupt) or a separate crate...