Unable to port `millis()` implementation to Arduino Micro

[PlesleronTepryos]

Steps to replicate

1. Generate fresh project for Arduino Micro as per the README

2. Add avr-device = "0.8.1" as a dependency in Cargo.toml (the same version depended on by arduino-hal)

3. Put this code in main.rs (adapted almost verbatim from the millis() example but simplified to just toggle the LED each second)

Code

/*!
 * A basic implementation of the `millis()` function from Arduino:
 *
 *     https://www.arduino.cc/reference/en/language/functions/time/millis/
 *
 * Uses timer TC0 and one of its interrupts to update a global millisecond
 * counter.  A walkthough of this code is available*9e:
 *
 *     https://blog.rahix.de/005-avr-hal-millis/
 */
#![no_std]
#![no_main]
#![feature(abi_avr_interrupt)]

use core::cell;
use panic_halt as _;

// Possible Values:
//
// ╔═══════════╦══════════════╦═══════════════════╗
// ║ PRESCALER ║ TIMER_COUNTS ║ Overflow Interval ║
// ╠═══════════╬══════════════╬═══════════════════╣
// ║        64 ║          250 ║              1 ms ║
// ║       256 ║          125 ║              2 ms ║
// ║       256 ║          250 ║              4 ms ║
// ║      1024 ║          125 ║              8 ms ║
// ║      1024 ║          250 ║             16 ms ║
// ╚═══════════╩══════════════╩═══════════════════╝
const PRESCALER: u32 = 1024;
const TIMER_COUNTS: u32 = 125;

const MILLIS_INCREMENT: u32 = PRESCALER * TIMER_COUNTS / 16000;

const TOGGLE_INTERVAL: u32 = 1000;

static MILLIS_COUNTER: avr_device::interrupt::Mutex<cell::Cell<u32>> =
    avr_device::interrupt::Mutex::new(cell::Cell::new(0));

fn millis_init(tc0: arduino_hal::pac::TC0) {
    // Configure the timer for the above interval (in CTC mode)
    // and enable its interrupt.
    tc0.tccr0a().write(|w| w.wgm0().ctc());
    tc0.ocr0a().write(|w| w.set(TIMER_COUNTS as u8));
    tc0.tccr0b().write(|w| match PRESCALER {
        8 => w.cs0().prescale_8(),
        64 => w.cs0().prescale_64(),
        256 => w.cs0().prescale_256(),
        1024 => w.cs0().prescale_1024(),
        _ => panic!(),
    });
    tc0.timsk0().write(|w| w.ocie0a().set_bit());

    // Reset the global millisecond counter
    avr_device::interrupt::free(|cs| {
        MILLIS_COUNTER.borrow(cs).set(0);
    });
}

#[avr_device::interrupt(atmega32u4)]
fn TIMER0_COMPA() {
    avr_device::interrupt::free(|cs| {
        let counter_cell = MILLIS_COUNTER.borrow(cs);
        let counter = counter_cell.get();
        counter_cell.set(counter + MILLIS_INCREMENT);
    })
}

fn millis() -> u32 {
    avr_device::interrupt::free(|cs| MILLIS_COUNTER.borrow(cs).get())
}

// ----------------------------------------------------------------------------

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);

    millis_init(dp.TC0);

    let mut led = pins.d13.into_output();

    // Enable interrupts globally
    unsafe { avr_device::interrupt::enable() };

    let mut next_toggle = 0;

    loop {
        let time = millis();

        if time >= next_toggle {
            led.toggle();

            next_toggle += TOGGLE_INTERVAL;
        }
    }
}

4. Upload to genuine Arduino Micro

5. Observe that LED fails to blink

What I know and why

• My installation of avr-hal/ravedude/avrdude/etc is okay because the unmodified example works correctly when uploaded to my genuine Arduino Uno
• My edits are okay because the modified code also works as intended on my Uno with #[avr_device::interrupt(atmega328p)]
• My Micro is okay because the blink example works correctly and all code written and uploaded using the Arduino IDE works as well
• Porting this code is theoretically sound because the names and layouts of relevant registers on the atmega328p and atmega32u4 are identical according to their datasheets
• The memory locations of relevant registers are correct in avr-device because they match the locations used in the original C implementation of millis()

At this point, I am at a loss as to why this doesn't work and I have done my very best in ruling out the possibility that this is a problem on my end

[stappersg]

and I have done my very best

I'm doing my best to spend human energy the in the support request that is presented as bug report.

Thing I would like to see: diff -u between "known good" and "porting effort".

The "ruling out the possibility that this is a problem on my end" of @PlesleronTepryos might be true. Surely true is "no obligation on others".

[PlesleronTepryos]

I'm doing my best to spend human energy the in the support request that is presented as bug report.

I apologize if my intention was unclear; this issue is meant to be a bug report as this code should work, at least based on the datasheet of the 32u4 and the fact that the C implementation already works via the Arduino IDE

Thing I would like to see: diff -u between "known good" and "porting effort".

"Known good" is line-by-line identical to the port, just with #[avr_device::interrupt(atmega328p)] instead of #[avr_device::interrupt(atmega32u4)]. That's why I'm under the impression that this is a bug, even though I haven't been able to determine a root cause

Surely true is "no obligation on others".

I'm not sure I understand what you mean here

[stappersg]

On Sun, Feb 01, 2026 at 01:25:43PM -0800, Grey Tabatabai wrote: I'm not sure I understand what you mean here

Acknowledge

[PlesleronTepryos]

Update: I have gathered further evidence that this issue is being caused by a bug

Minimal example of millis() implementation using Timer0: works on Arduino Uno

#![no_std]
#![no_main]
#![feature(abi_avr_interrupt)]

use core::cell;
use panic_halt as _;

static MILLIS_COUNTER: avr_device::interrupt::Mutex<cell::Cell<u32>> =
    avr_device::interrupt::Mutex::new(cell::Cell::new(0));

fn millis_init(tc0: arduino_hal::pac::TC0) {
    tc0.tccr0a().write(|w| w.wgm0().ctc());
    tc0.ocr0a().write(|w| w.set(250));
    tc0.tccr0b().write(|w| w.cs0().prescale_64());
    tc0.timsk0().write(|w| w.ocie0a().set_bit());

    avr_device::interrupt::free(|cs| {
        MILLIS_COUNTER.borrow(cs).set(0);
    });
}

#[avr_device::interrupt(atmega328p)]
fn TIMER0_COMPA() {
    avr_device::interrupt::free(|cs| {
        let counter_cell = MILLIS_COUNTER.borrow(cs);
        let counter = counter_cell.get();
        counter_cell.set(counter + 1);
    })
}

fn millis() -> u32 {
    avr_device::interrupt::free(|cs| MILLIS_COUNTER.borrow(cs).get())
}

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);

    millis_init(dp.TC0);

    let mut led = pins.d13.into_output();

    unsafe { avr_device::interrupt::enable() };

    let mut next_toggle = 0;

    loop {
        let now = millis();

        if now >= next_toggle {
            led.toggle();

            next_toggle += 1000;
        }
    }
}

Identical Timer0 millis() implementation: fails on Arduino Micro

#![no_std]
#![no_main]
#![feature(abi_avr_interrupt)]

use core::cell;
use panic_halt as _;

static MILLIS_COUNTER: avr_device::interrupt::Mutex<cell::Cell<u32>> =
    avr_device::interrupt::Mutex::new(cell::Cell::new(0));

fn millis_init(tc0: arduino_hal::pac::TC0) {
    tc0.tccr0a().write(|w| w.wgm0().ctc());
    tc0.ocr0a().write(|w| w.set(250));
    tc0.tccr0b().write(|w| w.cs0().prescale_64());
    tc0.timsk0().write(|w| w.ocie0a().set_bit());

    avr_device::interrupt::free(|cs| {
        MILLIS_COUNTER.borrow(cs).set(0);
    });
}

#[avr_device::interrupt(atmega32u4)]
fn TIMER0_COMPA() {
    avr_device::interrupt::free(|cs| {
        let counter_cell = MILLIS_COUNTER.borrow(cs);
        let counter = counter_cell.get();
        counter_cell.set(counter + 1);
    })
}

fn millis() -> u32 {
    avr_device::interrupt::free(|cs| MILLIS_COUNTER.borrow(cs).get())
}

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);

    millis_init(dp.TC0);

    let mut led = pins.d13.into_output();

    unsafe { avr_device::interrupt::enable() };

    let mut next_toggle = 0;

    loop {
        let now = millis();

        if now >= next_toggle {
            led.toggle();

            next_toggle += 1000;
        }
    }
}

---

Direct port of vanilla Arduino millis() implementation which uses TIMER0_OVF interrupt: works on Arduino Uno

#![no_std]
#![no_main]
#![feature(abi_avr_interrupt)]

use arduino_hal::{clock::Clock, DefaultClock};
use avr_device::interrupt::Mutex;
use core::cell::Cell;
use panic_halt as _;

const MICROS_PER_SECOND: u32 = 1_000_000;
const CYCLES_PER_MICRO: u32 = DefaultClock::FREQ / MICROS_PER_SECOND;
const MICROS_PER_OVF: u32 = 64 * 256 / CYCLES_PER_MICRO;

const MILLIS_INC: u32 = MICROS_PER_OVF / 1000;

const FRACT_INC: u32 = MICROS_PER_OVF.rem_euclid(1000) >> 3;
const FRACT_MAX: u32 = 1000 >> 3;

static OVERFLOWS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0));
static MILLIS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0));
static FRACT: Mutex<Cell<u32>> = Mutex::new(Cell::new(0));

fn millis_init(tc0: arduino_hal::pac::TC0) {
    tc0.tccr0a().write(|w| w.wgm0().pwm_fast());
    tc0.tccr0b().write(|w| w.cs0().prescale_64());
    tc0.timsk0().write(|w| w.toie0().set_bit());

    avr_device::interrupt::free(|cs| {
        MILLIS.borrow(cs).set(0);
    });
}

#[avr_device::interrupt(atmega328p)]
fn TIMER0_OVF() {
    avr_device::interrupt::free(|cs| {
        let millis_cell = MILLIS.borrow(cs);
        let fract_cell = FRACT.borrow(cs);
        let mut millis = millis_cell.get();
        let mut fract = fract_cell.get();

        millis += MILLIS_INC;
        fract += FRACT_INC;
        if fract >= FRACT_MAX {
            fract -= FRACT_MAX;
            millis += 1;
        }

        fract_cell.set(fract);
        millis_cell.set(millis);
        OVERFLOWS.borrow(cs).update(|x| x + 1);
    })
}

fn millis() -> u32 {
    avr_device::interrupt::free(|cs| MILLIS.borrow(cs).get())
}

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);

    millis_init(dp.TC0);

    let mut led = pins.d13.into_output();

    unsafe { avr_device::interrupt::enable() };

    let mut next_toggle = 0;

    loop {
        let now = millis();

        if now >= next_toggle {
            led.toggle();

            next_toggle += 1000;
        }
    }
}

Identical TIMER0_OVF millis() implementation: fails on Arduino Micro

#![no_std]
#![no_main]
#![feature(abi_avr_interrupt)]

use arduino_hal::{clock::Clock, DefaultClock};
use avr_device::interrupt::Mutex;
use core::cell::Cell;
use panic_halt as _;

const MICROS_PER_SECOND: u32 = 1_000_000;
const CYCLES_PER_MICRO: u32 = DefaultClock::FREQ / MICROS_PER_SECOND;
const MICROS_PER_OVF: u32 = 64 * 256 / CYCLES_PER_MICRO;

const MILLIS_INC: u32 = MICROS_PER_OVF / 1000;

const FRACT_INC: u32 = MICROS_PER_OVF.rem_euclid(1000) >> 3;
const FRACT_MAX: u32 = 1000 >> 3;

static OVERFLOWS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0));
static MILLIS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0));
static FRACT: Mutex<Cell<u32>> = Mutex::new(Cell::new(0));

fn millis_init(tc0: arduino_hal::pac::TC0) {
    tc0.tccr0a().write(|w| w.wgm0().pwm_fast());
    tc0.tccr0b().write(|w| w.cs0().prescale_64());
    tc0.timsk0().write(|w| w.toie0().set_bit());

    avr_device::interrupt::free(|cs| {
        MILLIS.borrow(cs).set(0);
    });
}

#[avr_device::interrupt(atmega32u4)]
fn TIMER0_OVF() {
    avr_device::interrupt::free(|cs| {
        let millis_cell = MILLIS.borrow(cs);
        let fract_cell = FRACT.borrow(cs);
        let mut millis = millis_cell.get();
        let mut fract = fract_cell.get();

        millis += MILLIS_INC;
        fract += FRACT_INC;
        if fract >= FRACT_MAX {
            fract -= FRACT_MAX;
            millis += 1;
        }

        fract_cell.set(fract);
        millis_cell.set(millis);
        OVERFLOWS.borrow(cs).update(|x| x + 1);
    })
}

fn millis() -> u32 {
    avr_device::interrupt::free(|cs| MILLIS.borrow(cs).get())
}

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);

    millis_init(dp.TC0);

    let mut led = pins.d13.into_output();

    unsafe { avr_device::interrupt::enable() };

    let mut next_toggle = 0;

    loop {
        let now = millis();

        if now >= next_toggle {
            led.toggle();

            next_toggle += 1000;
        }
    }
}

---

Adapted millis() implementation using Timer1: works on Arduino Uno

#![no_std]
#![no_main]
#![feature(abi_avr_interrupt)]

use core::cell;
use panic_halt as _;

static MILLIS_COUNTER: avr_device::interrupt::Mutex<cell::Cell<u32>> =
    avr_device::interrupt::Mutex::new(cell::Cell::new(0));

fn millis_init(tc1: arduino_hal::pac::TC1) {
    tc1.tccr1a().write(|w| w.wgm1().set(0b00)); // CTC lower two bits
    tc1.ocr1a().write(|w| w.set(250));
    tc1.tccr1b().write(|w| {
        w.wgm1().set(0b01); // CTC upper two bits
        w.cs1().prescale_64()
    });
    tc1.timsk1().write(|w| w.ocie1a().set_bit());

    avr_device::interrupt::free(|cs| {
        MILLIS_COUNTER.borrow(cs).set(0);
    });
}

#[avr_device::interrupt(atmega328p)]
fn TIMER1_COMPA() {
    avr_device::interrupt::free(|cs| {
        let counter_cell = MILLIS_COUNTER.borrow(cs);
        let counter = counter_cell.get();
        counter_cell.set(counter + 1);
    })
}

fn millis() -> u32 {
    avr_device::interrupt::free(|cs| MILLIS_COUNTER.borrow(cs).get())
}

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);

    millis_init(dp.TC1);

    let mut led = pins.d13.into_output();

    unsafe { avr_device::interrupt::enable() };

    let mut next_toggle = 0;

    loop {
        let now = millis();

        if now >= next_toggle {
            led.toggle();

            next_toggle += 1000;
        }
    }
}

Identical Timer1 millis() implementation: fails on Arduino Micro

#![no_std]
#![no_main]
#![feature(abi_avr_interrupt)]

use core::cell;
use panic_halt as _;

static MILLIS_COUNTER: avr_device::interrupt::Mutex<cell::Cell<u32>> =
    avr_device::interrupt::Mutex::new(cell::Cell::new(0));

fn millis_init(tc1: arduino_hal::pac::TC1) {
    tc1.tccr1a().write(|w| w.wgm1().set(0b00)); // CTC lower two bits
    tc1.ocr1a().write(|w| w.set(250));
    tc1.tccr1b().write(|w| {
        w.wgm1().set(0b01); // CTC upper two bits
        w.cs1().prescale_64()
    });
    tc1.timsk1().write(|w| w.ocie1a().set_bit());

    avr_device::interrupt::free(|cs| {
        MILLIS_COUNTER.borrow(cs).set(0);
    });
}

#[avr_device::interrupt(atmega32u4)]
fn TIMER1_COMPA() {
    avr_device::interrupt::free(|cs| {
        let counter_cell = MILLIS_COUNTER.borrow(cs);
        let counter = counter_cell.get();
        counter_cell.set(counter + 1);
    })
}

fn millis() -> u32 {
    avr_device::interrupt::free(|cs| MILLIS_COUNTER.borrow(cs).get())
}

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);

    millis_init(dp.TC1);

    let mut led = pins.d13.into_output();

    unsafe { avr_device::interrupt::enable() };

    let mut next_toggle = 0;

    loop {
        let now = millis();

        if now >= next_toggle {
            led.toggle();

            next_toggle += 1000;
        }
    }
}

---

From all this, it looks like there's a general issue with interrupt-dependent atmega32u4 code when uploaded using avr-hal. At least that's the case for me, I'd love to see if someone else could replicate these results. With my current understanding of how all this works, I don't know how to investigate further, but if someone more familiar with the inner workings can point me toward some tests to narrow down the problem, I'd be happy to run them and report back

[PlesleronTepryos]

I figured out the problem. By default, avr_device disables interrupts entirely unless avr_device::interrupt::enable() is called. This would be fine in isolation, but on 32u4 boards, calling this function enables all interrupts, including those generated by the builtin USB controller

Despite USB currently being unsupported on the 32u4 by avr-hal, the USB controller is not disabled, causing it to generate spurious interrupts, which, according to the disassembly output of avr-objdump, resets the chip with jmp 0 after a bit of indirection. This can be solved by adding dp.USB_DEVICE.usbcon().write(|w| w.usbe().clear_bit()); before the main loop, and ideally before enabling interrupts at all

In short, enabling interrupts without explicitly (and quickly) disabling the USB controller puts the application into a permanent reset loop, rendering any interrupt-dependent code written for the 32u4 nonfunctional

---

As it turns out, as it often does, my problem was in fact already solved by @Rahix in this comment on #75, only found by retroactively searching for USBCON in the issue history. This uses dp.USB_DEVICE.usbcon().reset(); but the effect is the same

With that in mind, I'll try making a PR with a working version of the millis() example for the Arduino Micro (obviously not using the serial interface as that doesn't work yet), but I'll leave this issue open in the meantime until I get that sorted