millis() Tutorial: Arduino Multitasking

Shortly after learning how to flash one LED, most new Arduino users move on to flashing two or more LEDs.

The millis() function is one of the most powerful functions of the Arduino platform. This function returns the number of milliseconds the current sketch has been running since the last reset. This may not seem to be highly useful until you consider it as a replacement for the delay() function. Now millis() itself cannot cause a delay, but you can use it create a virtual delay.

Example #1: Basic Delay

Before getting into that, look at the following delay() based example.

void setup() {
   pinMode(13, OUTPUT);
}

void loop() {
   digitalWrite(13, HIGH);   // set the LED on
   delay(1000);              // wait for a second
   digitalWrite(13, LOW);    // set the LED off
   delay(1000);              // wait for a second
}

This is the “Blink” example included with the Arduino IDE. Reading each line in sequence, the sketch turns on Pin 13′s LED, waits 1 second, turns off Pin 13′s LED, and waits 1 second. Then the entire sequence repeats. An issue arises if you want to do something during that 1 second the Arduino is doing nothing.

Example #2: Basic Delay with for() loops

Now let’s change the code to the following instead.

void setup() {
   pinMode(13, OUTPUT)
}

void loop() {
   digitalWrite(13, HIGH);   // set the LED on
   for (int x=0; x < 1000; x++) {     // Wait for 1 second
      delay(1);
   }
   digitalWrite(13, LOW);   // set the LED on
   for (int x=0; x <; 1000; x++) {     // Wait for 1 second
      delay(1);
   }
}

This new sketch will accomplish the same sequence as Example #1. The difference is that the Arduino is only “delayed” for 1 millisecond at a time. So you could put other commands inside of the for statement. Those command would get executed while leaving the Pin 13 LED on for 1 second.

Example #3: for() loops with 2 LEDs

This example adds a 2nd LED and flashes it in sequence with the first. It is based on the for() loops in Example #2.

void setup() {
   pinMode(13, OUTPUT);
   pinMode(12, OUTPUT);
}

void loop() {
   digitalWrite(13, HIGH);   // set the LED on
   for (int x=0; x < 1000; x++) {             // wait for a secoond
      delay(1);
      if (x==500) {
         digitalWrite(12, HIGH);
      }
   }
   digitalWrite(13, LOW);    // set the LED off
   for (int x=0; x < 1000; x++) {             // wait for a secoond
      delay(1);
      if (x==500) {
            digitalWrite(12, LOW);
      }
   }
}

After 500 times through the for loop, Pin 12 gets turned on. It stays on until 500 times through the second loop. If there was a LED (with current limiting resistor) attached to this pin, it would appear that Pin 13 and Pin 12 were flashing in Sequence.

This example has some significant issues. First, it is still relying on the delay() function, which means the Arduino is doing (almost) nothing else. Second, because of the overhead of the loop and the call to delay, we aren’t really delaying for 1 second. It will actually delay for slightly longer. The millis() function allows the sketch to get around these limitations.

The millis() Function

Going back to the definition of the millis() function: it counts the number of milliseconds the sketch has been running. Hey, that’s exactly what we are doing here! Each “wait for a second” section counts 1000 milliseconds. In fact, while counting we do something at a certain time. Since the Arduino already does this work for us, why not use it instead?

By using the millis() function, we will be setting up a simple state machine in our sketch. This first example code duplicates the same as the very first blink example. When using the millis() function, code will generally need to get a little more complex.

Example #4: Blink with millis()

In this example, a BOOLEAN variable is created to track the state of the LED on Pin 13 and an variable called waitUntil of long type is added to count time.

long waitUntil=0;
boolean LED13state = true;

void setup() {
   pinMode(13, OUTPUT);
}
void loop() {
   // Each time through loop(), set Pin 13 to the same value as the state variable
   digitalWrite(13, LED13state);
  // Nothing will change until millis() increments by 1000
   if (millis() >= waitUntil) {
      LED13state = !(LED13state);        // Toggle the LED's state
      waitUntil += 1000;   // Make sure we wait for another 1000 milliseconds.
   }
}

A useful feature of the Arduino digitalWrite() function is that it checks the state of a pin before applying a change. So if you use digitalWrite() to “write” a HIGH and the pin is already HIGH, then nothing happens. This means it is possible to constantly write a HIGH (or LOW) each time loop() iterates.

Example #5: Adding a 2nd LED with millis()

To add a second flashing LED, the code needs to be made just a little bit smarter. In this example a second waitUntil and LEDstate variable have been added.

long sequenceDelay = 500;
long flashDelay = 1000;

boolean LED13state = false;     // the LED will turn ON in the first iteration of loop()
boolean LED12state = false;     // need to seed the light to be OFF
long waitUntil13 = 0;
long waitUntil12 = sequenceDelay;         // the seed will determine time between LEDs
void setup() {
   pinMode(13, OUTPUT);
   pinMode(12, OUTPUT);
}
void loop() {
   digitalWrite(13, LED13state);     // each iteration of loop() will set the IO pins,
   digitalWrite(12, LED12state);
   // checking to see if enough time has elapsed
   if (millis() >= waitUntil13) {
      LED13state = !(LED13state);
      waitUntil13  += flashDelay;
      // this if-statement will not execute for another 1000 milliseconds
   }
  // keep in mind, waitUntil12 was already seeded with a value of 500
   if (millis() >= waitUntil12) {
      LED12state = !(LED12state);
      waitUntil12 += flashDelay;
   }
}

This code has some small changes from the previous example. There are now variables for the LED state and wait time on Pin12. Additionally two new variables have been added: sequenceDelay and flashDelay. The variable sequenceDelay will determine how long it takes each LED to visually react to each other. While the variable flashDelay is the amount of time each LED stays on.

Visually it will appear the LEDs are chasing each other. Programmatically, each LED is flashing for the amount of time defined in flashDelay. In other words, as shown here each LED will individually flash for 1 second.

Other Example

Police Light Strobe Effect:  http://www.cmiyc.com/tutorials/arduino-example-police-lights-with-millis/

Conclusion

At first it seems that using the millis() function will make a sketch more complicated than using delay(). In some ways, this is true. However, the trade off is that the sketch becomes significantly more flexible. Animations become much simpler. Talking to LCDs while reading buttons becomes no problem. Virtually, you can make your Arduino multitask.