Arduino millis() rollover-safe timing patterns without core helpers

Minimal Standards-Compliant Pattern

The core insight is that unsigned subtraction handles rollover naturally. The pattern if (millis() - start >= interval) is correct because when millis() wraps to zero, the subtraction still yields the proper elapsed time due to modular arithmetic.

Implementation

Use a header-only template class for maximum inlining and zero code bloat:

template<typename T = unsigned long> class ElapsedTimer {
public:
    explicit ElapsedTimer(T interval) : interval_(interval), start_(millis()) {}
    
    bool expired() const {
        return (millis() - start_) >= interval_;
    }
    
    void reset() { start_ = millis(); }
    void reset(T interval) { interval_ = interval; start_ = millis(); }
    
private:
    T interval_;
    T start_;
};

Usage

ElapsedTimer<> timer(5000); // 5 second interval
if (timer.expired()) {
    // handle timeout
    timer.reset();
}

Why This Works

The key is that unsigned long subtraction wraps correctly. When millis() rolls over from 0xFFFFFFFF to 0, the difference millis() - start_ still computes the correct elapsed time as long as the interval is less than ~49.7 days. This behavior is guaranteed by C++ unsigned arithmetic, not dependent on Arduino core implementation.

Architecture Compatibility

All three target architectures (AVR, SAMD, ESP32) implement millis() as a simple read of a 32-bit counter updated by timer0 ISR. The rollover behavior is identical: a clean wrap to zero. No documented differences exist that would affect the unsigned subtraction pattern.

Design Choice: Template Class Over Macro

A template class provides:

• Inlining - Modern compilers inline all methods
• Type safety - No macro side effects
• Reset capability - Macros cannot maintain state
• Zero overhead - No virtual functions or heap allocation

Verification Requirements

Test on actual hardware near the rollover boundary using a long-running sketch that logs timing values. The pattern is mathematically sound; empirical verification confirms behavior on Uno, Zero, and ESP32.