Goodbye delay(), hello millis()

Getting rid of the delay

Using the delay() function is nice, but the more we want to do, the more it just brings us problems. During a delay() call, you can’t respond to inputs, you can't process any data and you can’t change any outputs. The delay() ties up 100% of the processor. So, if any part of your code uses a delay(), everything else is dead in the water for the duration. So let's see how we can go on without using it:)

Usng millis()

One simple technique for implementing timing is to make a schedule and keep an eye on the clock. Instead of a world-stopping delay, you just check the clock regularly so you know when it is time to act. Meanwhile the processor is still free for other tasks to do their thing. A very simple example of this is the BlinkWithoutDelay example sketch that comes with the IDE.

/*
  Blink without Delay

  Turns on and off a light emitting diode (LED) connected to a digital pin,
  without using the delay() function. This means that other code can run at the
  same time without being interrupted by the LED code.

  The circuit:
  - Use the onboard LED.
  - Note: Most Arduinos have an on-board LED you can control. On the UNO, MEGA
    and ZERO it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN
    is set to the correct LED pin independent of which board is used.
    If you want to know what pin the on-board LED is connected to on your
    Arduino model, check the Technical Specs of your board at:
    https://www.arduino.cc/en/Main/Products

  created 2005
  by David A. Mellis
  modified 8 Feb 2010
  by Paul Stoffregen
  modified 11 Nov 2013
  by Scott Fitzgerald
  modified 9 Jan 2017
  by Arturo Guadalupi

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
*/

// constants won't change. Used here to set a pin number:
const int ledPin =  3;// the number of the LED pin

// Variables will change:
int ledState = LOW;             // ledState used to set the LED

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;        // will store last time LED was updated

// constants won't change:
const long interval = 1000;           // interval at which to blink (milliseconds)

void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the difference
  // between the current time and last time you blinked the LED is bigger than
  // the interval at which you want to blink the LED.
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  }
}

State + Machine = State Machine
Note that we have variables to keep track of whether the LED is ON or OFF. And variables to keep track of when the last change happened. That is the State part of the State Machine.

We also have code that looks at the state and decides when and how it needs to change. That is the Machine part. Every time through the loop we ‘run the machine’ and the machine takes care of updating the state.

For the advanced group

For the advanced people, write a sketch where using millis() you can change the times of the on and off times separately.

another way / led flasher

Ok, lets make it a bit more efficient
A variant that has a different on-time and off-time.

// These variables store the flash pattern
// and the current state of the LED
 
int ledPin =  8;      // the number of the LED pin
int ledState = LOW;             // ledState used to set the LED
unsigned long previousMillis = 0;        // will store last time LED was updated
long OnTime = 250;           // milliseconds of on-time
long OffTime = 950;          // milliseconds of off-time
 
void setup() 
{
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);      
}
 
void loop()
{
  // check to see if it's time to change the state of the LED
  unsigned long currentMillis = millis();
 
  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  {
    ledState = LOW;  // Turn it off
    previousMillis = currentMillis;  // Remember the time
    digitalWrite(ledPin, ledState);  // Update the actual LED
  }
  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  {
    ledState = HIGH;  // turn it on
    previousMillis = currentMillis;   // Remember the time
    digitalWrite(ledPin, ledState);    // Update the actual LED
  }
}

the ultrasonic example

#define echoPin 7 // attach pin D9 Arduino to pin Echo of HC-SR04
#define trigPin 8 //attach pin D10 Arduino to pin Trig of HC-SR04

long duration; // variable for the duration of sound wave travel
int distance; // variable for the distance measurement
long previousMillis = 0;
 
void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an OUTPUT
  pinMode(echoPin, INPUT); // Sets the echoPin as an INPUT
  Serial.begin(9600); // // Serial Communication is starting with 9600 of baudrate speed
  Serial.println("Ultrasonic Sensor HC-SR04 Test"); // print some text in Serial Monitor
  Serial.println("with Arduino UNO R3");
}
  
void loop() {
  unsigned long currentMillis = micros();
  digitalWrite(trigPin, LOW);
  
  if (currentMillis - previousMillis > 2) {
    digitalWrite(trigPin, HIGH);
    previousMillis = currentMillis;
  }
  
  if (currentMillis - previousMillis > 10) {
    digitalWrite(trigPin, LOW);
    previousMillis = currentMillis;
    digitalWrite(trigPin, HIGH);

  }
  
 duration = pulseIn(echoPin, HIGH);
  // Calculating the distance
  distance = duration * 0.034 / 2; // Speed of sound wave divided by 2 (go and back)
  // Displays the distance on the Serial Monitor
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");
}

Class

A class is simply a collection of functions and variables that are all kept together in one place. Let's say:) a detailed tutorial for the curious here heeereee

and another one here

with a led flasher

Defining a class: We start by declaring a “Flasher” class:

Then we add in all the variables from the Flasher example. Since they are part of the class, they are known as member variables.

class Flasher
{
	// Class Member Variables
	// These are initialized at startup
	int ledPin;      // the number of the LED pin
	long OnTime;     // milliseconds of on-time
	long OffTime;    // milliseconds of off-time
 
	// These maintain the current state
	int ledState;             		// ledState used to set the LED
	unsigned long previousMillis;  	// will store last time LED was updated
};

Next we add a constructor. The constructor has the same name as the class and its job is to initialize all the variables.

class Flasher
{
	// Class Member Variables
	// These are initialized at startup
	int ledPin;      // the number of the LED pin
	long OnTime;     // milliseconds of on-time
	long OffTime;    // milliseconds of off-time
 
	// These maintain the current state
	int ledState;             		// ledState used to set the LED
	unsigned long previousMillis;  	// will store last time LED was updated
 
  // Constructor - creates a Flasher 
  // and initializes the member variables and state
  public:
  Flasher(int pin, long on, long off)
  {
	ledPin = pin;
	pinMode(ledPin, OUTPUT);     
	  
	OnTime = on;
	OffTime = off;
	
	ledState = LOW; 
	previousMillis = 0;
  }
};

Finally we take our loop and turn it into a member function called “Update()”. Note that this is identical to our original void loop(). Only the name has changed.

class Flasher
{
	// Class Member Variables
	// These are initialized at startup
	int ledPin;      // the number of the LED pin
	long OnTime;     // milliseconds of on-time
	long OffTime;    // milliseconds of off-time
 
	// These maintain the current state
	int ledState;             		// ledState used to set the LED
	unsigned long previousMillis;  	// will store last time LED was updated
 
  // Constructor - creates a Flasher 
  // and initializes the member variables and state
  public:
  Flasher(int pin, long on, long off)
  {
	ledPin = pin;
	pinMode(ledPin, OUTPUT);     
	  
	OnTime = on;
	OffTime = off;
	
	ledState = LOW; 
	previousMillis = 0;
  }
 
  void Update()
  {
    // check to see if it's time to change the state of the LED
    unsigned long currentMillis = millis();
     
    if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
    {
    	ledState = LOW;  // Turn it off
      previousMillis = currentMillis;  // Remember the time
      digitalWrite(ledPin, ledState);  // Update the actual LED
    }
    else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
    {
      ledState = HIGH;  // turn it on
      previousMillis = currentMillis;   // Remember the time
      digitalWrite(ledPin, ledState);	  // Update the actual LED
    }
  }
};

By simply re-arranging our existing code into the Flasher class, we have encapsulated all of the variables (the state) and the functionality (the machine) for flashing a LED.

Now lets use it: Now, for every LED that we want to flash, we create an instance of the Flasher class by calling the constructor. And on every pass through the loop we just need to call Update() for each instance of Flasher.

There is no need to replicate the entire state machine code anymore. We just need to ask for another instance of the Flasher class!

class Flasher
{
	// Class Member Variables
	// These are initialized at startup
	int ledPin;      // the number of the LED pin
	long OnTime;     // milliseconds of on-time
	long OffTime;    // milliseconds of off-time
 
	// These maintain the current state
	int ledState;             		// ledState used to set the LED
	unsigned long previousMillis;  	// will store last time LED was updated
 
  // Constructor - creates a Flasher 
  // and initializes the member variables and state
  public:
  Flasher(int pin, long on, long off)
  {
	ledPin = pin;
	pinMode(ledPin, OUTPUT);     
	  
	OnTime = on;
	OffTime = off;
	
	ledState = LOW; 
	previousMillis = 0;
  }
 
  void Update()
  {
    // check to see if it's time to change the state of the LED
    unsigned long currentMillis = millis();
     
    if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
    {
    	ledState = LOW;  // Turn it off
      previousMillis = currentMillis;  // Remember the time
      digitalWrite(ledPin, ledState);  // Update the actual LED
    }
    else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
    {
      ledState = HIGH;  // turn it on
      previousMillis = currentMillis;   // Remember the time
      digitalWrite(ledPin, ledState);	  // Update the actual LED
    }
  }
};
 
 
Flasher led1(12, 100, 400);
Flasher led2(13, 350, 350);
 
void setup()
{
}
 
void loop()
{
	led1.Update();
	led2.Update();
}

with the ultrasonic sensor

class UltraSonic
{
    int trigPin;
    int echoPin;
    long duration;
    int distance;
    long previousMicros = 0;

  public:
    UltraSonic(int trig, int echo)
    {
      trigPin = trig;
      echoPin = echo;
      pinMode(trigPin, OUTPUT);
      pinMode(echoPin, INPUT);
      Serial.begin(9600);
    }

    void Update()
    {
      unsigned long currentMicros = micros();
      digitalWrite(trigPin, LOW);
      if (currentMicros - previousMicros > 2) {
        digitalWrite(trigPin, HIGH);
        previousMicros = currentMicros;
      }
      if (currentMicros - previousMicros > 10) {
        digitalWrite(trigPin, LOW);
        previousMicros = currentMicros;
        digitalWrite(trigPin, HIGH);
      }
      duration = pulseIn(echoPin, HIGH);
      distance = duration * 0.034 / 2;
      Serial.print("Distance: ");
      Serial.print(distance);
      Serial.println(" cm");
    }
};



UltraSonic US1(10, 9);


void setup() {
  Serial.begin(9600);
}
void loop () {
  Serial.print("US1:  ");
  US1.Update();

}

For the advanced group

create a sketch where two distance sensors and two leds are at work. If sensor1 measures a certain distance start flashing the led1. If sensor2 measures a certain other distance, the flash led2 at a different rate than led1.
or come up with a better case scenario:)