add regular scheduled functions, now also callable on yield() (#6039)

* add regular scheduled functions, now also callable on `yield()`

added bool schedule_function_us(std::function<bool(void)> fn, uint32_t repeat_us)
lambda must return true to be not removed from the schedule function list
if repeat_us is 0, then the function is called only once.

Legacy schedule_function() is preserved

This addition allows network drivers like ethernet chips on lwIP to be regularly called
- even if some user code loops on receiving data without getting out from main loop
  (callable from yield())
- without the need to call the driver handling function
  (transparent)

This may be also applicable with common libraries (mDNS, Webserver, )

cores/esp8266/Schedule.h

@@ -4,22 +4,28 @@
 #include <functional>
 
 #define SCHEDULED_FN_MAX_COUNT 32
-#define SCHEDULED_FN_INITIAL_COUNT 4
 
-// Warning 
-// This API is not considered stable. 
-// Function signatures will change.
+// This API was not considered stable but is now stabilizing.
+// Function signatures may change, queue must stay FIFO.
 // You have been warned.
 
-// Run given function next time `loop` function returns, 
+// Run given function ONCE next time `loop` function returns,
+// or `yield` is called,
 // or `run_scheduled_functions` is called.
 // Use std::bind to pass arguments to a function, or call a class member function.
 // Note: there is no mechanism for cancelling scheduled functions.
 // Keep that in mind when binding functions to objects which may have short lifetime.
 // Returns false if the number of scheduled functions exceeds SCHEDULED_FN_MAX_COUNT.
-bool schedule_function(std::function<void(void)> fn);
+//bool schedule_function(std::function<void(void)>&& fn);
+bool schedule_function(const std::function<void(void)>& fn);
 
-// Run all scheduled functions. 
+// Run given function periodically about every <repeat_us> microseconds until it returns false.
+// Note that it may be more than <repeat_us> microseconds between calls if `yield` is not called
+// frequently, and therefore should not be used for timing critical operations.
+//bool schedule_function_us(std::function<bool(void)>&& fn, uint32_t repeat_us);
+bool schedule_function_us(const std::function<bool(void)>& fn, uint32_t repeat_us);
+
+// Run all scheduled functions.
 // Use this function if your are not using `loop`, or `loop` does not return
 // on a regular basis.
 void run_scheduled_functions();