Is there a non blocking delay that's as easy to use as the built in delay function?

[gazz292]

i keep wondering why the built in standard 'delay ();' function hasn't been changed to a non blocking delay function.

i can see when searching that there are many libraries / functions offered with non blocking delays, and i can vaguely remember a way of using the milli's function.
But they all seem to need quite a few bits of code to use,

I'd have thought it may be easier for beginners (and people like me who forget stuff) to be able to simply type something like :

'nonBlockingDelay (1000);

when they just want a simple delay for say flashing a led, or sending repeating keyboard key's at a speed the computer can keep up with.

[jremington]

What would you imagine that line to do, that would be different from delay(1000);?

[er_name_not_found]

One very accepted standard is to create a series of timed events using millis() for timing. There are dozens if not hundreds of threads about it. It is not as simple as using delay, but it's not too complex for most applications either.

[paulpaulson]

Hello gazz292

Either you use an operating system like RTOS or you develop your own µKernel to handle wait times.

A wait call could look like this:

wait[functionName](waitTime,currentTime); 

This means that the function is executed once after a defined wait time. You just have to juggle around a bit with arrays and function pointers.

Have a nice day and enjoy coding in C++.

[DaveX]

delay()'s whole purpose is blocking code from proceeding to the next line. For simple scripts, it is indeed easy, right up until the point you want to do more than one thing, when un-tangling the interactions between delay()s (and for(...)s, while(...)s, etc.) makes things much more difficult.

[noiasca]

@gazz292

i keep wondering why

these are two complete different programming paradigm, which can't be easily solved with the exchange of a simple keyword like "nonblockingdelay()"

delay() does what it says - it delays further execution of the next user line of code.

one variant to avoid blocking is "Blink Without Delay" - do things when they are due to do.
I highly recommend to study Blink Without Delay.
Study it as long as it takes so you can write down the blinking code by heart.
Afterwards you can apply that concept for any non blocking time management you need.

If you were using RTOS you could let run several tasks in parallel and each could have its own delay. But on a small arduino, you are better using "Blink Without Delay" - using millis()

[DrDiettrich]

@gazz292

But they all seem to need quite a few bits of code to use,

Check the Task Macros for using a non-blocking taskDelay() function.

[johnerrington]

@gazz292

when they just want a simple delay for say flashing a led, or sending repeating keyboard key's at a speed the computer can keep up with.

If that is all you want to do there is no benefit in using non-blocking code.

Its only when your requirements become more sophisticated that non-blocking code is needed.
And in those cases you need to plan the way processor time is handled, and use a timer (eg millis) to control it.

[johnerrington]

@DrDiettrich

Check the Task Macros for using a non-blocking taskDelay() function.

I followed the link but I see no explanation of the code or the way the TaskDelay macro works.
And yes I googled for it - +"taskDelay(millis)" arduino - with no results.

[DrDiettrich]

@johnerrington

I googled for it

Google for "Task Macros Arduino" instead. The Task Macros principle; invented by Knuth; should be understood before diving into macro details.

[Power_Broker]

I'm late to the party, but FireTimer.h was written for basically this purpose

[cedarlakeinstruments]

There are two options. The pthreads library offers a form of non-blocking behavior but it can be difficult to beginners to understand.

Or you can move to a more modern processor like an ESP32 or an STM32 that can run FreeRTOS. A multitasking operating system that can manage running multiple threads at once. It's far easier to use than people seem to think and it immediately solves the problem you have.

[DrDiettrich]

@cedarlakeinstruments

it immediately solves the problem you have.

That multi-tasking approach also is possible with the Task Macros on the smaller Arduinos.

[alto777]

@DrDiettrich

Google for "Task Macros Arduino" instead.

I did, and with and without Knuth and Arduino.

I don't see what you are telling us to look at. I do see many task library solutions SimlpleTaskManager, TaskManager, TaskSheduker and so forth.

Seems like it's been solved to death. One wonders why we almost never see anyone actually using those libraries in an UNO.

Whether or not one uses a library, I think it is valuable to at least once come fully to grips with blink without delay, and how that pattern can be leveraged into directly coding the performance of multiple things at once.

By writing something that does a few things at once using millis(). No library, no easy helper functions, no language features you wouldn't know after the first few steps into programming.

The few I've looked at don't do what I want and looked harder to use for what they did that I could make any use of than just writing it myself, or getting it from a previous sketch nearly wholesale.

a7

[DaveX]

Hook for RTOS in Timer0 on AVR

16ms is a frequently used time slice in multitasking systems. Consider the overhead in a task switch on a single core controller without full register and state save/restore feature. RTOS systems are event driven while ordinary multi-tasking systems use time slices. Which architecture do you want to implement? Simple multi-tasking can be implemented using Task Macros as already described by Knuth and implemented by Combie and me.

[alto777]

THX. The heart of the matter @DrDiettrich points to is this remarkable set of macros:

# define taskBegin() static int _mark = 0; static millis_t __attribute__((unused)) time_Stamp = 0; switch(_mark){ case 0:
# define taskSwitch() { _mark = __LINE__; return; case __LINE__: ; }
# define taskDelay(interval) time_Stamp = millis(); taskSwitch(); if ((millis() - time_Stamp) < (interval)) return;
# define taskWaitFor(condition) taskSwitch(); if (!(condition)) return;
# define taskRestart() { _mark = 0; return; }
# define taskEnd() _mark=0; }

which will make interesting beach reading. It looks the macros expand and chop the code into steps managed by a stealth switch/case statement.

a7

[MrMark]

To the above, I'd add that AdaFruit has a nice series of extensive tutorials on multitasking.

Part 1 motivates the need to move past delay() and explores the "blink without delay" approach.

Part 2 explores interrupt driven approaches.

Part 3 explores encapsulating tasks in class structures.

[gfvalvo]

@alto777, @DrDiettrich and others:
All of the above discussion of Multi-Tasking is totally inappropriate given that the OP is apparently a newbie who has not yet mastered basic millis-based non-blocking code. Any other Multi-Tasking technique is at least an order of magnitude more complex.

[MrMark]

The original question was, "Is there a non blocking delay that 's as easy to use as the built in delay function?".

The short answer is, "No, because moving past delay inherently implies some form multitasking." One can't simply insert some "nonBlockingDelay()" without also specifying what code can and can't run during the delay period and providing some mechanism for exiting the delay period.

Thus how one does multitasking seems an appropriate response albeit starting with the BlinkWithoutDelay() is probably the most appropriate first step on this journey.

[DrDiettrich]

@gfvalvo

Any other Multi-Tasking technique is at least an order of magnitude more complex.

Multi-tasking becomes complex only if inter-task communication is involved. Newbies typically have the other problem, that tasks should not interact and that's what Task Macros can do.