#include "millisDelay.h"
int led1 = 2;
int led2 = 3;
// Pin 13 has an LED connected on most Arduino boards.
bool led1On = false; // keep track of the led state
bool led2On = false; // keep track of the led state
millisDelay led_1_Delay;
millisDelay led_2_Delay;
void setup()
{
  // initialize the digital pin as an output.
  pinMode(led1, OUTPUT);   // initialize the digital pin as an output.
  pinMode(led2, OUTPUT);   // initialize the digital pin as an output.

  // start delay
  led_1_Delay.start(700);
  led_2_Delay.start(5000);
}
void loop()
{
  // check if delay has timed out
  if (led_1_Delay.justFinished())
  {
    led_1_Delay.repeat(); // start delay again without drift
    // toggle the led
    led1On = !led1On;
    digitalWrite(led1, led1On);

  }

  if (led_2_Delay.justFinished())
  {
    led_2_Delay.repeat(); // start delay again without drift
    // toggle the led
    led2On = !led2On;
    digitalWrite(led2, led2On);

  }



}

sketch.ino

diagram.json

// millisDelay.cpp
// see the tutorial https://www.forward.com.au/pfod/ArduinoProgramming/TimingDelaysInArduino.html

/*
 * (c)2018 Forward Computing and Control Pty. Ltd.
 * NSW Australia, www.forward.com.au
 * This code is not warranted to be fit for any purpose. You may only use it at your own risk.
 * This generated code may be freely used for both private and commercial use
 * provided this copyright is maintained.
 */

// include Arduino.h for millis()
#include <Arduino.h>
#include "millisDelay.h"

millisDelay::millisDelay() {
 running = false; // not running on start
 startTime = 0; // not started yet
 finishNow = false; // do not finish early
}

/**
 Start a delay of this many milliseconds
 @param delay in millisconds, 0 means justFinished() will return true on first call
*/
void millisDelay::start(unsigned long delay) {
 ms_delay = delay;
 startTime = millis();
 running = true;
 finishNow = false; // do not finish early
}

/**
 Stop the delay
 justFinished() will now never return true
 until after start(),restart() or repeat() called again
*/
void millisDelay::stop() {
 running = false;
 finishNow = false; // do not finish early
}

/**
 repeat()
 Do same delay again but allow for a possible delay in calling justFinished()
*/
void millisDelay::repeat() {
 startTime = startTime + ms_delay;
 running = true;
 finishNow = false; // do not finish early
}

/**
 restart()
 Start the same delay again starting from now
 Note: use repeat() when justFinished() returns true, if you want a regular repeating delay
*/
void millisDelay::restart() {
 start(ms_delay);
}

/**
 Force delay to end now
*/
void millisDelay::finish() {
 finishNow = true; // finish early
}

/**
 Has the delay ended/expired or has finish() been called?
 justFinished() returns true just once when delay first exceeded or the first time it is called after finish() called
*/
bool millisDelay::justFinished() {
 if (running && (finishNow || ((millis() - startTime) >= ms_delay))) {
 stop();
 return true;
 } // else {
 return false;
}

/**
 Is the delay running, i.e. justFinished() will return true at some time in the future
*/
bool millisDelay::isRunning() {
 return running;
}

/**
 Returns the last time this delay was started, in ms, by calling start(), repeat() or restart()
 Returns 0 if it has never been started
*/
unsigned long millisDelay::getStartTime() {
	return startTime;
}

/**
 How many ms remaining until delay finishes
 Returns 0 if justFinished() returned true or stop() called
*/
unsigned long millisDelay::remaining() {
 if (running) {
 unsigned long ms = millis(); // capture current millis() as it may tick over between uses below
 if (finishNow || ((ms - startTime) >= ms_delay)) { // check if delay exceeded already but justFinished() has not been called yet
 return 0;
 } else {
 return (ms_delay - (ms - startTime));
 }
 } else { // not running. stop() called or justFinished() returned true
 return 0;
 }
}

/**
 The delay set in ms set in start
*/
unsigned long millisDelay::delay() {
 return ms_delay;
}

millisDelay.cpp

// millisDelay.h
// see the tutorial https://www.forward.com.au/pfod/ArduinoProgramming/TimingDelaysInArduino.html

#ifndef MILLIS_DELAY_H
#define MILLIS_DELAY_H

/*
 * (c)2018 Forward Computing and Control Pty. Ltd.
 * NSW Australia, www.forward.com.au
 * This code is not warranted to be fit for any purpose. You may only use it at your own risk.
 * This generated code may be freely used for both private and commercial use
 * provided this copyright is maintained.
 */
 
/**************
 **millisDelay** implements a non-blocking, repeatable delay, see the detailed description. 
 
 To use **millisDelay**, create a global instance for each delay you need e.g. 
 <code>millisDelay ledDelay;</code> 
 Then start the delay running with with say a 1sec (1000ms) delay i.e. 
 <code>ledDelay.start(1000);</code> 
 This is often done in setup() 
 Then in loop() check if the delay has timed out with 
 <code>if (ledDelay.justFinished()) { 
 . . . do stuff here when delay has timed out 
 }</code> 
 
 The **justFinished()** method only returns true once the first time it is check after the delay has timeout. 
 NOTE: It is very important that <code>if (ledDelay.justFinished()) {</code> is called every loop and that it is at the outer most level of the loop() method. 
 That is must not be inside another if() while() case() etc statement. It can be inside a method call as long as that method is called every loop. 
 
 See [How to code Timers and Delays in Arduino](https://www.forward.com.au/pfod/ArduinoProgramming/TimingDelaysInArduino.html) for more examples
 
****************************************************************************************/
class millisDelay {
 public:

 millisDelay();

 /**
 Start a delay of this many milliseconds
 @param delay in millisconds, 0 means ifFinished() return true on first call
 */
 void start(unsigned long delay);

 /**
 Stop the delay
 justFinished() will now never return true
 until after start(),restart() or repeat() called again
 */
 void stop();

 /**
 repeat()
 Do same delay again but allow for a possible delay in calling justFinished()
 */
 void repeat();

 /**
 restart()
 Start the same delay again starting from now
 Note: use repeat() when justFinished() returns true, if you want a regular repeating delay
 */
 void restart();

 /**
 Force delay to end now
 */
 void finish();

 /**
 Has the delay ended/expired or has finish() been called?
 justFinished() returns true just once when delay first exceeded or the first time it is called after finish() called
 */
 bool justFinished();

 /**
 Is the delay running, i.e. justFinished() will return true at some time in the future
 */
 bool isRunning();

 /**
 Returns the last time this delay was started, in ms, by calling start(), repeat() or restart()
 Returns 0 if it has never been started
 */
 unsigned long getStartTime();

 /**
 How many ms remaining until delay finishes
 Returns 0 if finished or stopped
 */
 unsigned long remaining();

 /**
 The delay set in start
 */
 unsigned long delay();

 private:
 unsigned long ms_delay;
 unsigned long startTime;
 bool running; // true if delay running false when ended
 bool finishNow; // true if finish() called to finish delay early, false after justFinished() returns true
};
#endif