Avoiding the use of delay()

[polarmolar]

I am starting to program an environmental datalogger system with multiple sensors + {RTC + SD-card shield} , where the interval between reading the sensors will be several hours; most likely 2 or 4 times per 24-hour period.

The intention is to base the project on an Arduino R4 WiFi. At some point, I may wish to add LoRa (probably 915 MHz) capability

It is desired that this datalogger system be capable of running reliably in a remote location for months at a time. Conserving battery power by putting the microprocessor into "sleep" or "hibernate" mode during the long intervals between readings would seem to be a good idea!

I have been reading that one should avoid the use of delay() because it causes a break in code execution. Looking forward, I may elect to have each of the 4 sensors reading at different intervals; avoiding breaks then sounds like a good idea.

The alternatives to using delay() I have found mention of, so far, include:

1. use of millis();
2. use of hardware counters (i.e., those built into the microprocessor);
3. using timer interrupts; and finally,
4. a rather vague suggestion about writing code that would rely on comparing readings from the RTC to trigger the reading-and-recording of sensor values. But that suggestion was so vague as to be useless.

Would anybody care to suggest an "ideal" direction to proceed in, before I get into the nitty-gritty ?

[LarryD]

• Read through thes then return with your questions.

Using millis() for timing. A beginners guide

Part 1 It is not usually long before new Arduino users discover that although the delay() function is easy to use it has side effects, the main one of which is that its stops all activity on the Arduino until the delay is finished (not quite true, I know, but that is usually how the problem presents itself). When this occurs the new user is usually directed to the BlinkWithoutDelay example sketch (BWoD) and/or the excellent thread entitled Several things at the same time. Several things at the…

Tutorial Task Scheduler for Arduino

Designing a Modular Non-Blocking Task Scheduler for Arduino With One-Shot and Passive Timer Support Many Arduino projects outgrow delay(). This tutorial shows how to build a scalable, cooperative scheduler that runs multiple timed tasks safely and efficiently — without blocking. A Lightweight, Modular Cooperative Scheduler for Arduino Many Arduino users eventually run into this problem: “How do I run multiple timed tasks without using delay()?” This scheduler: Runs multiple independent t…

[xfpd]

RTC seems the best way to schedule events. [edit[ see posts below]Using millis() will need to reboot the MCU every forty-nine days.

@polarmolar

4 sensors reading at different intervals

Define the four intervals.

@polarmolar

suggestion was so vague as to be useless

How specific do you need? Here's an RTC sketch that does one event every five seconds and a second event every minute.

#include <RTClib.h> // library for RTC
RTC_DS1307 rtc; // create RTC object/instance
int second, minute, minuteOld; // storage variables
bool firsttime = 1; // flag for non-repeating event

void setup() {
  Serial.begin(115200); // start Serial Monitor
  rtc.begin(); // start RTC instance
}

void loop() {
  DateTime now = rtc.now(); // read new time/date
  second = now.second(); // store second
  minute = now.minute(); // store minute

  if (second % 5 == 0) { // every five seconds
    if (firsttime == 1) { // allow this event
      firsttime = 0; // skip this event until next timeout
      event_one(); // call the event
    }
  } else {
    firsttime = 1; // reset one-time flag
  }

  if (minute != minuteOld) { // minute changed
    minuteOld = minute;
    event_two();
  }
}

void event_one() {
  Serial.print("Five second. "); // do the thing
  Serial.println(second); // print seconds
}

void event_two() {
  Serial.print("New minute. ");
  Serial.println(minute);
}

Results:

New minute. 42
Five second. 5
Five second. 10
Five second. 15
.
.
Five second. 50
Five second. 55
Five second. 0
New minute. 43

[sterretje]

@xfpd

Using millis() will need to reboot the MCU every forty-nine days.

millis() will roll over but the use of unsigned variables will result in correct behaviour for timing; no need for a reboot of the MCU.

[gcjr]

@polarmolar

Conserving battery power by putting the microprocessor into "sleep" or "hibernate" mode during the long intervals between readings would seem to be a good idea!

then you need something external to the chip to wake it up

[david_2018]

@polarmolar

where the interval between reading the sensors will be several hours; most likely 2 or 4 times per 24-hour period.

You are not going to be using delay(), millis, or any other type of timing that requires a running processor over that period of time. Obvious option is to use the alarm output of an RTC to wake the processor from the sleep state.

Do you need WiFi? That consumes a large amount of power.

The SD card also will consume considerable power, you might want to buffer the data to another type of storage, such as FRAM memory, and only periodically write to the SD card.

[cedarlakeinstruments]

Doesn't the R4 have any RTOS support? Sounds like multiple threads would be a simple solution.

[sciroccotorc]

@polarmolar

Conserving battery power by putting the microprocessor into "sleep" or "hibernate" mode during the long intervals between readings would seem to be a good idea!

If saving power is essential rather than a nice to have, then you are going to need to put the board into deep sleep mode. In this mode loop() stops executing until the RTC interval expires, and then it wakes and restarts where it left off.

This means you don't need to have an external wake source such as an interrupt from your sensors - it's done purely on time. RAM contents are preserved during sleep so you can set and read flags like "last time I was awake I did X".

This could work for you if your intervals to read the sensors are defineable and repeatable.

The Arduino MKR 1310 has a deep sleep consumption of ~110 micro amps and will run for many weeks on a 3.7V LiPo, without the need for butchering it by removing components. It also has onboard LoRa radio. I use it for data logging a remote water meter. Works very well.

[PaulRB]

1. You cannot use either delay() or millis() to achieve low power sleep mode. Other functions are required which will be specific to the type of Arduino. I'm not familiar with Uno R4 and don't know what they would be.
2. A hardware counter would need some external clock signal for it to count. This could be provided by the 1Hz output of an RTC module, for example.
3. Timer interrupts (from the Arduino's internal hardware timers) can probably wake the Arduino from sleep mode. However, there may be a limit to how long the timed period can be, which means your code will need to sleep multiple times until the correct time for the next sensor reading.
4. Some RTC modules have alarm timers that can be set to send an interrupt signal to the Arduino to wake it from deep sleep at a set time.

[horace]

you need to experiment to see how well the Arduino R4 WiFi sleeps, e.g.

1. can you put the Renesas RA4M1 microcontroller to sleep
2. can you put the ESP32-S3 radio microcontroller to sleep
3. are there other modules on board which need to sleep?

you may find that even when all the onboard devices are sleeping the onboard power supply may still draw significant current

EDIT: if you are considering LoRa it could be worth considering a LoRa development board with an onboard microcontroller which supports deep sleep modes, e.g. heltec wifi-lora-ESP32S3-v4/
see ESP32-S3 sleep modes

[sciroccotorc]

If you were to use the Arduino MKRWAN 1310 because of its LoRa radio and deep sleep / ultra-low current consumption, you could take advantage of the fact that it also has a built-in RTC peripheral.

The ArduinoLowPower library integrates the RTC with deep sleep mode. The maximum sleep time with this library is about 71 minutes, but you can chain this indefinitely in a for loop for much longer intervals.

Flashing an LED, putting the device to low consumption / deep sleep for a minute, waking it and repeating is literally as easy as this:

#include "ArduinoLowPower.h"

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);  
}
void loop() {

  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
  LowPower.deepSleep(60000);
}

[GoForSmoke]

@xfpd

RTC seems the best way to schedule events. Using millis() will need to reboot the MCU every forty-nine days.

You are wrong about that.

The longest INTERVAL using 32-bit time variables is 49 days and a fraction but Proper Use Of Unsigned Subtraction Completely Negates ANY ROLLOVER PROBLEMS.

If you want a longer interval, use 64 bit unsigned long long variables. [edit:add] Then you can time for literally billions of years if you had an immortal project, otherwise possibly decades long intervals on a future museum piece project.

The need for an RTC with an Uno or other board using a resonator (cheaper than a crystal and 2 capacitors) is that the resonator can lose minutes a day running slow. Depending on what you're doing, that may not matter at all.

[GoForSmoke]

@polarmolar

It is desired that this datalogger system be capable of running reliably in a remote location for months at a time.

The Arduino forum archives hold a number of examples of doing that. For a while back over 10 years ago the fad was packing data collectors in Altoid tins and some of those did run for months. Those had standalone AVR chips wired in, a board takes way more room! Yes, Arduino supports standalone chip projects.

If you don't write much per hour or day, a quick burst to SD won't take 1 whole second. How often do you need sampling? Can you buffer the data in RAM, write directly to the 512B (default) SD buffer and write when it's full.

Some projects included solar cells and had to get into power management.

[Rintin]

@polarmolar

Conserving battery power

You need to get rid of everything you do not need.
A board with 2 CPUs is at least questionable.
Need an onboard debugger? How about an USB-Serial chip?
A power LED?

Also some experimentation is required:

• What needs more power? Turn on/off the SD or let it idle for a few seconds
• When does the SD its housekeeping?
• ...

@polarmolar

At some point, I may wish to add LoRa (probably 915 MHz) capability

Have you looked at the STM32WL?

---

Your outer loop might look something like this:

• Calculate when to run the next activity
• Set alarm
• Sleep
• Wake up
• Run activity
• Rinse and repeat

With delay() you are busy watching grass grow at full speed. With millis() it is easier to build a cooperative scheduling. Take a look at the example "blink without delay".

---

@xfpd

Using millis() will need to reboot

This should handle the overflow correctly:

start = millis();

...

now = millis();
if(now - start >= delay) {
    <do something>
    start = now;
}

or use 2 event queues. One for events that need to run before the overflow and one for events that need to run after the overflow.

[build_1971]

And you could also catch the rollover and add another uint32_t to count the rollovers...
I think there will be no rollover of a 64 bit counter before the end of times.
Rtc may still be a good idea as the millis counters are not very accurate... if you schedule a measurement every day at 12:00 the event will drift away by minutes per day (depending on temperature and god knows what else).
Rtc can also be used to wake up controller from sleep mode...
And rtc will keep time in case of power failure...

[jim-p]

@polarmolar

The intention is to base the project on an Arduino R4 WiFi

Real bad choice for a low power project, an R3 is all you need. Use one of these to cut power to everything

Adafruit TPL5110 Low Power Timer Breakout

They claim that it only draws 20uA (0.00002A) when off.

[GoForSmoke]

@Rintin

One for events that need to run before the overflow and one for events that need to run after the overflow.

For FFS not that tired old crap that fools newbs!

Do the time math as all unsigned subtractions and THERE IS NO EFFING OVERFLOW!

Unsigned: elapsed time = end time - start time....

that WORKS EVERY TIME!

Big concern is are your unsigned time variables big enough to hold the longest Interval you would time. After that, for speed we want unsigned time variables that aren't so big that they have extra bytes to process:

With 32-bits you can time millis to 49.71-some Days or with micros a bit over 71 Minutes.

With 16-bits you can time millis to 65.535 Seconds or with micros you can time 65.535 millis --- twice as fast as using 32-bit values.

With 8 bits you can time millis but watch out for how Arduino skips 6 values in those 8 bits to get millis +/- 1 ms. IF you need precision, use micros, they work to the next 4 usecs which is 250x smaller than ms.

If this is new to you, it's going to take practice to get easy cause the code techniques are not like "common wisdom".

[sonofcy]

A video/article should drop today over at Dronebot Workshop. Jumping to the big reveal, an esp32 in hibernate mode draws 2.5uA, in deep sleep 25uA. I have had an UNO R4 under RTC test for months and it's cloc is very inaccurtae but probably good enough for your use case. You may benefit by looking at the SEEED Studio XIAO line of thumb nail sized ESP32 with dataloger, LORA, and more add-ons.

[GoForSmoke]

@sonofcy

an esp32 in hibernate mode draws 2.5uA, in deep sleep 25uA.

But shouldn't the deep sleep draw less power?

Um confuuused!

[jim-p]

@sonofcy

Jumping to the big reveal, an esp32 in hibernate mode draws 2.5uA, in deep sleep 25uA.

I'm also confused.
How did you make these measurements and how did you verify the ESP mode?