C comparing times that can overflow

Question

I need to detect the overflowing of an unsigned long.

This variable holds the amount of milliseconds since the device is running (it's an Arduino). Doing sizeof(unsigned long), I have come to see it's indeed a 32-bit number. Now, since it increments every millisecond, which means the device will run for about 49 days before this value overflows.

Since it's for a home system, it isn't really advisable. Now what I'm using the number for, is comparing if the current time is larger than the previous time plus an amount of debouncing.

if(timeChanged + amountOfMs < currentTime){ ... }

Needless to say, once overflow occurs this isn't going to work anymore. What's an efficient way to solve this? I've thought about also having a second-timer as well to check if the milliseconds one has overflowed, but in the end I'll have the same problem.

Answer 1

This rollover issue seems to cause quite a bit of confusion...

The right answer is that you need not worry about the millis() rollover, as long as you do your calculation properly.

This is bad:

if (timeChanged + amountOfMs < currentTime) { ... }

This is good (rollover-safe):

if (currentTime - timeChanged > amountOfMs) { ... }

The reason it works is that arithmetics with unsigned integers (unsigned long in your case) reliably works modulo max+1 (ULONG_MAX+1 is 2³²). Thus, currentTime, timeChanged and their difference always have the correct value, modulo 2³². As long as you test your button more often than once every 49 days (which is likely) the difference will be in the range of an unsigned long, and your test will be correct.

Let put it another way: if millis() rolls over between timeChanged and currentTime, then the difference currentTime - timeChanged will be negative. But since the difference is actually computed with unsigned numbers, it will underflow and roll-over to the correct result. I do not like this explanation though, as it sounds like an error compensating another error. The truth is: if you think of unsigned numbers in terms of modular arithmetics, there is no error anywhere.