Running in background timer

Using Arduino Programming Questions
1

Hi there.

I've seen this type of feature for micro: bit. Just wondering if Arduino has it.

Feature: Get the number of milliseconds of time passed since the board was turned on.

I want to make a timer for the project.

Thanks.

2

Take a look at the millis() and micros() functions

3

Thanks for the immediate response. Do I need to add any extension for this?

4

Take a look at the IDE's BlinkWithoutDelay example to gain the knowledge.

5

Under what section?

6

No

Examples menu

These are incredibly basic questions, have you done some arduino beginner tutorials yet? (No, I can't recommend any, perhaps other forum members who were beginners more recently, or have contributed to or written tutorials themselves, can suggest)

7

Ok, thanks. BTW, I'm just a beginner.

8

Here is my personal variant that reduces the number of lines of code to write a timer
including an explanation how it works based on an everyday example

9

i just post this in another thread. the OP is working on an automatic bird feeder

# include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd (0x27, 16, 2);

const byte On  = LOW;
const byte Off = HIGH;

const byte IndicatorPin = 10;
int        indicatorSec;

unsigned long MsecSec  = 100;       // set low for testing 1000
unsigned long msecLast;

const long    TimerSec = 10 * 60;
      long    cntSec = TimerSec;


char s [90];

// -----------------------------------------------------------------------------
void loop ()
{
    unsigned long msec = millis ();

    if (msec - msecLast >= MsecSec)  {
        msecLast += MsecSec;

        int hour =  cntSec / 3600;
        int mins = (cntSec % 3600) / 60;
        int secs = (cntSec % 60);

        sprintf (s, "%2d:%02d:%02d\n", hour, mins, secs);
        lcd.print (s);

        cntSec--;
        if (0 > cntSec)  {
            cntSec = TimerSec;
            indicatorSec = 2;
            digitalWrite (IndicatorPin, On);
        }
        else if (0 == --indicatorSec)
            digitalWrite (IndicatorPin, Off);
    }
}

// -----------------------------------------------------------------------------
void setup ()
{
    Serial.begin (9600);

    pinMode (IndicatorPin, OUTPUT);
    digitalWrite (IndicatorPin, Off);

    lcd.init      ();
    lcd.backlight ();
    lcd.setCursor (4, 0);
}
10

Okay, that's nice @gcjr! I will try it out later.

11

Just beware of the limitations of Arduino/C++ arithmetic.

Perhaps better practice is to make this be
const long TimerSec = 10UL * 60UL;

That way, if you change it to be (say) 24 hours, you can just do this
const long TimerSec = 24UL * 60UL * 60UL;

and you will not run into the bug that would be created if you do this instead
const long TimerSec = 24 * 60 * 60;
because if you leave off the UL suffix, the arithmetic will overflow at 32767, and last time I checked, there were 86400 seconds in a day.

Also, be aware that millis() overflows and resets to zero after about 49 or 50 days, because an unsigned long can only count up to 4,294,967,295.

1 Like
12

Okay. What if I don't want to use millis()? Perhaps like seconds? Or minutes?

14

millis() counts up to 2^32 - 1 = 4294967295 milliseconds

4294967295 milliseconds are 4294967 seconds

4294967 seconds are 71582.79 minutes

71582.79 minutes are 1193 hours

1193 hours are 49.7 days

millis() can count up and up for 49.7 days

This should be long enough for almost any application

15 
uint32_t seconds = millis() / 1000UL;
uint32_t minutes = millis() / (1000UL*60);
1 Like
16

The official BWD uses mixed type math. Time variables should at least all be unsigned and best all the same length.

17

You asked for milliseconds of time passed. Why have you chnaged the mind and now asking for seconds or minutes?

Do you have an Arduino UNO Board? If yes, then you may learn the operation/application of the millis() function knowing its following definition. The function is widely used in UNO Platform for concurrent execution of many tasks.

When the uploading of a sketch is done in the Ardduino UNO, a 32-bit conuter (composed of four consecutive memory locations, which I call millisCounter) begins accmulating evevry millisecond passed on interrupt basis. You can use the millis() function at any time to read the content of the millisCounter on the fly (without disturbing the counting process) and save in an unsigned long type variable for later use.

18

const long is a signed integer.

const unsigned long MillisPerSec = 1000UL;
const unsigned long MillisPerMin = 60UL * MillisPerSec;
const unsigned long MillisPerHr = 60UL * MillisPerMin;
const unsigned long MillisPerDay = 24UL * MillisPerHr;

OP, with unsigned math this formula works across rollover, which ceases to be a problem. This works

elapsed time = end time - start time

19

With the caveat that due to the way millis is counted, the value is always +/-1.

When close timing really counts, use micros() and be aware that the micros clock 'ticks' every 4 microseconds, not every 1. Is close!

1 Like
20

The micros() function rollovers after about 70 minutes; whereas, millis() function rollovers after about 49+ days.

The micros() function provides more accurate timing than the millis() function. However, the majority of Arduino people are found to use millis() function, probably, to avoid unnecessary frequent interrupts.

21

Using micros() does not generate extra interrupts.
Without the micros counter, millis() can't run.

Yup, using 32-bit micros the longest interval that can be measure is a bit over 71 minutes. Most people don't delay as long as a minute!

If close timing matters, use micros(). Mostly, it doesn't.
Millis is fine for most uses.

1 Like