Group Actions
Engagement
  • Author Author: Workshopshed
  • Date Created: Date Created
  • Views 8763 views
  • Likes 4 likes
  • Comments 15 comments
Related
Recommended

A non blocking delay

Workshopshed

The "hello world" of the Arduino is the blink sketch. This demonstrates that your board is working by blinking an LED, typically the on-board LED attached to pin13 but it has a problem.

The code uses the "delay" function which waits the desired number of milliseconds before continuing with the next line of the code.

 

int led = 13;

void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
  //Code here runs once every 2 seconds
}

 

The problem with the delay function is that nothing else happens whilst the delay is running. This is not only wasteful of the limited processing power of the microcontroller but it also makes any other routines you are using potentially unresponsive. There are several approaches to this problem such as using interrupts. The approach I selected to use a class which implement the non blocking delay.

This delay is implemented with a variable and two function, the first sets the delay and the second checks if the delay has finished.

 

Here's how it is used:

#include "Delay.h"

int led = 13;
int ledstate = HIGH;
NonBlockDelay d;

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

// the loop routine runs over and over again forever:
void loop() {
  if (d.Timeout()) {
    digitalWrite(led, ledstate);
    ledstate = ledstate == LOW ? HIGH : LOW; //toggle state
    d.Delay(1000);
  } 
  //Code here runs frequently
}

 

Delay.h

#if defined(ARDUINO) && ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
class NonBlockDelay {
    unsigned long iTimeout;
  public:
    void Delay (unsigned long);
    bool Timeout (void);
    unsigned long Time(void);
};

 

Delay.cpp

#include "Delay.h"
void NonBlockDelay::Delay (unsigned long t)
{
  iTimeout = millis() + t;
  return;
};
bool NonBlockDelay::Timeout (void)
{
  return (iTimeout < millis());
}
unsigned long NonBlockDelay::Time(void)
 {
   return iTimeout;
 }

 

My reason for wrapping the delay in a class is so that I can use it for twice for each of the steppers in my clock project and so my loop will end up as a series of non blocking calls.

 

void loop() {
     CheckInput();
     ReadClock();
     CalcHandPositions();
     SetStepperPositions();
     StepMotors();
}

  • in reply to celem

    Hi Edward, nice idea, thanks for the comment.

  • I altered Andy Clark's solution to better suit my needs. While I kept the Timeout member, I am not using it. I modified Delay() so that it stands alone and only executes the code after the timer expires. Here is what I am using. Note, all three files are concatenated together for this comment.

     

    /**
 * nonblockdelay2.ino
 * 
 * example "blink" program
 *
 */


#include "Delay.h"


int led = 13;
int ledstate = HIGH;
static NonBlockDelay d;


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


// the loop routine runs over and over again forever:
void loop()
{
  if(d.Delay(1000))
  {
    ledstate = (ledstate == LOW ? HIGH : LOW); //toggle state
    digitalWrite(led, ledstate);
  }
  //Code here runs frequently
}


//---------------------
/**
 * Delay.cpp
 *
 */

#include "Delay.h"


// Set iTimeout to current millis plus milliseconds to wait for
/**
 * Called with milliseconds to delay.
 * Return true if timer expired
 * 
 */
bool NonBlockDelay::Delay (unsigned long t)
{
  if(TimingActive)
  {
    if((millis() >iTimeout)){
      TimingActive = 0;
      return(1);
    }
    return(0);
  }
  iTimeout = millis() + t;
  TimingActive = 1;
  return(0);
};




// returns true if timer expired
bool NonBlockDelay::Timeout (void)
{
  if(TimingActive){
    if((millis() >iTimeout)){
      TimingActive = 0;
      iTimeout = 0;
      return(1);
    }
  }
  return(false);
}


// Returns the current timeout value in milliseconds
unsigned long NonBlockDelay::Time(void)
 {
   return iTimeout;
 }


//------------------------------
/**
 * Delay.h
 *
 */

#if defined(ARDUINO) && ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
class NonBlockDelay {
    unsigned long iTimeout;
    bool TimingActive = 0;
  public:
    bool Delay (unsigned long);
    bool Timeout (void);
    unsigned long Time(void);
};
//-------------------------

  • in reply to celem

    A simple solution for non blocking delays is as follows

     

    #define timeDelay   2000 // 2Seconds
long nextOperation = millis() + timeDelay;

setup()
{
     .....
}

loop()
{
// stuff done in the main loop()
.......
// now the thing we want to only do every timeDelay Period
if (nextOperation <= millis()
{
     // Do you thing here 
     nextOperation = millis() + timeDelay; // reset the timer for next time
}

}

    The thing about this is it will only enter if the time period has elapsed. There are also libraries that can abstract all this for you if you want, but knowing how to do it yourself is always good.

  • Andy Clark's solution is concise and makes for readable source - but behaves as a do {..code..}while loop where the 'code' will execute one and the delay only applies to subsequent executions of Timeout(). Using the example code:

    void loop() {
  if (d.Timeout()) {    // always true on first call
    digitalWrite(led, ledstate);
    ledstate = ledstate == LOW ? HIGH : LOW; //toggle state
    d.Delay(1000);
  }

     

    d.Timeout returns (iTimeout < millis()). On the first invocation iTimeout is indeterminate but, unless millis() has turned over, probably less than millis() returns, so 'true' will be returned. Once d.Delay is called iTimeout will be set to millis() + 1000 so subsequent calls to d.Timeout will return 'false' until millis() increments above iTimeout.

     

    This is useful where a do {..code..}while loop is called for, such as blinking the LED but not useful in a delay before executing situation, which is more like a blocking delay() would do. I haven't figured out how to do that yet - meanwhile Andy Clark's solution works for some situations.

  • in reply to Workshopshed

    I had a mistake in the DELAY_DONE macro, it's now fixed.