diff --git a/cores/esp8266/Esp.cpp b/cores/esp8266/Esp.cpp
index 41d0592f31..2ee4a65b5e 100644
--- a/cores/esp8266/Esp.cpp
+++ b/cores/esp8266/Esp.cpp
@@ -115,20 +115,18 @@ void EspClass::wdtFeed(void)
system_soft_wdt_feed();
}
-extern "C" void esp_yield();
-
void EspClass::deepSleep(uint64_t time_us, WakeMode mode)
{
system_deep_sleep_set_option(static_cast<int>(mode));
system_deep_sleep(time_us);
- esp_yield();
+ esp_suspend();
}
void EspClass::deepSleepInstant(uint64_t time_us, WakeMode mode)
{
system_deep_sleep_set_option(static_cast<int>(mode));
system_deep_sleep_instant(time_us);
- esp_yield();
+ esp_suspend();
}
//this calculation was taken verbatim from the SDK api reference for SDK 2.1.0.
@@ -200,7 +198,7 @@ void EspClass::reset(void)
void EspClass::restart(void)
{
system_restart();
- esp_yield();
+ esp_suspend();
}
[[noreturn]] void EspClass::rebootIntoUartDownloadMode()
diff --git a/cores/esp8266/HardwareSerial.cpp b/cores/esp8266/HardwareSerial.cpp
index 88b47b33f3..4896e27758 100644
--- a/cores/esp8266/HardwareSerial.cpp
+++ b/cores/esp8266/HardwareSerial.cpp
@@ -143,7 +143,7 @@ unsigned long HardwareSerial::detectBaudrate(time_t timeoutMillis)
if ((detectedBaudrate = testBaudrate())) {
break;
}
- delay(100);
+ esp_delay(100);
}
return detectedBaudrate;
}
diff --git a/cores/esp8266/PolledTimeout.h b/cores/esp8266/PolledTimeout.h
index 7eec547e48..1252ce6c29 100644
--- a/cores/esp8266/PolledTimeout.h
+++ b/cores/esp8266/PolledTimeout.h
@@ -27,6 +27,7 @@
#include <limits> // std::numeric_limits
#include <type_traits> // std::is_unsigned
#include <core_esp8266_features.h>
+#include <coredecls.h>
namespace esp8266
{
@@ -45,7 +46,7 @@ struct DoNothing
struct YieldOrSkip
{
- static void execute() {delay(0);}
+ static void execute() {esp_yield();}
};
template <unsigned long delayMs>
diff --git a/cores/esp8266/Schedule.cpp b/cores/esp8266/Schedule.cpp
index b1230ed675..279e78ff6c 100644
--- a/cores/esp8266/Schedule.cpp
+++ b/cores/esp8266/Schedule.cpp
@@ -135,8 +135,6 @@ bool schedule_recurrent_function_us(const std::function<bool(void)>& fn,
void run_scheduled_functions()
{
- esp8266::polledTimeout::periodicFastMs yieldNow(100); // yield every 100ms
-
// prevent scheduling of new functions during this run
auto stop = sLast;
bool done = false;
@@ -161,13 +159,10 @@ void run_scheduled_functions()
recycle_fn_unsafe(to_recycle);
}
- if (yieldNow)
- {
- // because scheduled functions might last too long for watchdog etc,
- // this is yield() in cont stack:
- esp_schedule();
- cont_yield(g_pcont);
- }
+ // scheduled functions might last too long for watchdog etc.
+ // yield() is allowed in scheduled functions, therefore
+ // recursion into run_scheduled_recurrent_functions() is permitted
+ optimistic_yield(100000);
}
}
@@ -241,9 +236,10 @@ void run_scheduled_recurrent_functions()
if (yieldNow)
{
// because scheduled functions might last too long for watchdog etc,
- // this is yield() in cont stack:
+ // this is yield() in cont stack, but need to call cont_suspend directly
+ // to prevent recursion into run_scheduled_recurrent_functions()
esp_schedule();
- cont_yield(g_pcont);
+ cont_suspend(g_pcont);
}
} while (current && !done);
diff --git a/cores/esp8266/cont.S b/cores/esp8266/cont.S
index 00ca017785..4832b39170 100644
--- a/cores/esp8266/cont.S
+++ b/cores/esp8266/cont.S
@@ -21,9 +21,9 @@
.section .irom0.text
.align 4
.literal_position
- .global cont_yield
- .type cont_yield, @function
-cont_yield:
+ .global cont_suspend
+ .type cont_suspend, @function
+cont_suspend:
/* a1: sp */
/* a2: void* cont_ctx */
/* adjust stack and save registers */
@@ -35,10 +35,10 @@ cont_yield:
s32i a0, a1, 16
s32i a2, a1, 20
- /* &cont_continue -> cont_ctx.pc_yield */
+ /* &cont_continue -> cont_ctx.pc_suspend */
movi a3, cont_continue
s32i a3, a2, 8
- /* sp -> cont_ctx.sp_yield */
+ /* sp -> cont_ctx.sp_suspend */
s32i a1, a2, 12
/* a0 <- cont_ctx.pc_ret */
@@ -56,7 +56,7 @@ cont_continue:
l32i a2, a1, 20
addi a1, a1, 24
ret
- .size cont_yield, . - cont_yield
+ .size cont_suspend, . - cont_suspend
////////////////////////////////////////////////////
@@ -108,7 +108,7 @@ cont_run:
/* sp -> cont_ctx.sp_ret */
s32i a1, a2, 4
- /* if cont_ctx.pc_yield != 0, goto cont_resume */
+ /* if cont_ctx.pc_suspend != 0, goto cont_resume */
l32i a4, a2, 8
bnez a4, cont_resume
/* else */
@@ -119,12 +119,12 @@ cont_run:
jx a2
cont_resume:
- /* a1 <- cont_ctx.sp_yield */
+ /* a1 <- cont_ctx.sp_suspend */
l32i a1, a2, 12
- /* reset yield flag, 0 -> cont_ctx.pc_yield */
+ /* reset yield flag, 0 -> cont_ctx.pc_suspend */
movi a3, 0
s32i a3, a2, 8
- /* jump to saved cont_ctx.pc_yield */
+ /* jump to saved cont_ctx.pc_suspend */
movi a0, cont_ret
jx a4
diff --git a/cores/esp8266/cont.h b/cores/esp8266/cont.h
index 21ecad2806..6932416b68 100644
--- a/cores/esp8266/cont.h
+++ b/cores/esp8266/cont.h
@@ -35,8 +35,8 @@ typedef struct cont_ {
void (*pc_ret)(void);
unsigned* sp_ret;
- void (*pc_yield)(void);
- unsigned* sp_yield;
+ void (*pc_suspend)(void);
+ unsigned* sp_suspend;
unsigned* stack_end;
unsigned unused1;
@@ -55,12 +55,12 @@ extern cont_t* g_pcont;
void cont_init(cont_t*);
// Run function pfn in a separate stack, or continue execution
-// at the point where cont_yield was called
+// at the point where cont_suspend was called
void cont_run(cont_t*, void (*pfn)(void));
// Return to the point where cont_run was called, saving the
// execution state (registers and stack)
-void cont_yield(cont_t*);
+void cont_suspend(cont_t*);
// Check guard bytes around the stack. Return 0 in case everything is ok,
// return 1 if guard bytes were overwritten.
@@ -70,9 +70,9 @@ int cont_check(cont_t* cont);
// and thus weren't used by the user code. i.e. that stack space is free. (high water mark)
int cont_get_free_stack(cont_t* cont);
-// Check if yield() may be called. Returns true if we are running inside
+// Check if cont_suspend() may be called. Returns true if we are running inside
// continuation stack
-bool cont_can_yield(cont_t* cont);
+bool cont_can_suspend(cont_t* cont);
// Repaint the stack from the current SP to the end, to allow individual
// routines' stack usages to be calculated by re-painting, checking current
diff --git a/cores/esp8266/cont_util.cpp b/cores/esp8266/cont_util.cpp
index 8fa4421802..fd72ee5d18 100644
--- a/cores/esp8266/cont_util.cpp
+++ b/cores/esp8266/cont_util.cpp
@@ -62,9 +62,9 @@ int cont_get_free_stack(cont_t* cont) {
return freeWords * 4;
}
-bool IRAM_ATTR cont_can_yield(cont_t* cont) {
+bool IRAM_ATTR cont_can_suspend(cont_t* cont) {
return !ETS_INTR_WITHINISR() &&
- cont->pc_ret != 0 && cont->pc_yield == 0;
+ cont->pc_ret != 0 && cont->pc_suspend == 0;
}
// No need for this to be in IRAM, not expected to be IRQ called
diff --git a/cores/esp8266/core_esp8266_main.cpp b/cores/esp8266/core_esp8266_main.cpp
index ff95d08cfb..bd784bc7c8 100644
--- a/cores/esp8266/core_esp8266_main.cpp
+++ b/cores/esp8266/core_esp8266_main.cpp
@@ -62,7 +62,7 @@ cont_t* g_pcont __attribute__((section(".noinit")));
static os_event_t s_loop_queue[LOOP_QUEUE_SIZE];
/* Used to implement optimistic_yield */
-static uint32_t s_cycles_at_yield_start;
+static uint32_t s_cycles_at_resume;
/* For ets_intr_lock_nest / ets_intr_unlock_nest
* Max nesting seen by SDK so far is 2.
@@ -80,6 +80,10 @@ const char* core_release =
#else
NULL;
#endif
+
+static os_timer_t delay_timer;
+#define ONCE 0
+#define REPEAT 1
} // extern "C"
void initVariant() __attribute__((weak));
@@ -106,32 +110,71 @@ extern "C" void __preloop_update_frequency() {
extern "C" void preloop_update_frequency() __attribute__((weak, alias("__preloop_update_frequency")));
extern "C" bool can_yield() {
- return cont_can_yield(g_pcont);
+ return cont_can_suspend(g_pcont);
}
-static inline void esp_yield_within_cont() __attribute__((always_inline));
-static void esp_yield_within_cont() {
- cont_yield(g_pcont);
- s_cycles_at_yield_start = ESP.getCycleCount();
+static inline void esp_suspend_within_cont() __attribute__((always_inline));
+static void esp_suspend_within_cont() {
+ cont_suspend(g_pcont);
+ s_cycles_at_resume = ESP.getCycleCount();
run_scheduled_recurrent_functions();
}
-extern "C" void __esp_yield() {
- if (can_yield()) {
- esp_yield_within_cont();
+extern "C" void __esp_suspend() {
+ if (cont_can_suspend(g_pcont)) {
+ esp_suspend_within_cont();
}
}
-extern "C" void esp_yield() __attribute__ ((weak, alias("__esp_yield")));
+extern "C" void esp_suspend() __attribute__ ((weak, alias("__esp_suspend")));
extern "C" IRAM_ATTR void esp_schedule() {
ets_post(LOOP_TASK_PRIORITY, 0, 0);
}
+// Replacement for delay(0). In CONT, same as yield(). Whereas yield() panics
+// in SYS, esp_yield() is safe to call and only schedules CONT. Use yield()
+// whereever only called from CONT, use esp_yield() if code is called from SYS
+// or both CONT and SYS.
+extern "C" void esp_yield() {
+ esp_schedule();
+ esp_suspend();
+}
+
+void delay_end(void* arg) {
+ (void)arg;
+ esp_schedule();
+}
+
+extern "C" void __esp_delay(unsigned long ms) {
+ if (ms) {
+ os_timer_setfn(&delay_timer, (os_timer_func_t*)&delay_end, 0);
+ os_timer_arm(&delay_timer, ms, ONCE);
+ }
+ else {
+ esp_schedule();
+ }
+ esp_suspend();
+ if (ms) {
+ os_timer_disarm(&delay_timer);
+ }
+}
+
+extern "C" void esp_delay(unsigned long ms) __attribute__((weak, alias("__esp_delay")));
+
+bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms) {
+ uint32_t expired = millis() - start_ms;
+ if (expired >= timeout_ms) {
+ return true;
+ }
+ esp_delay(std::min((timeout_ms - expired), intvl_ms));
+ return false;
+}
+
extern "C" void __yield() {
- if (can_yield()) {
+ if (cont_can_suspend(g_pcont)) {
esp_schedule();
- esp_yield_within_cont();
+ esp_suspend_within_cont();
}
else {
panic();
@@ -140,6 +183,9 @@ extern "C" void __yield() {
extern "C" void yield(void) __attribute__ ((weak, alias("__yield")));
+// In CONT, actually performs yield() only once the given time interval
+// has elapsed since the last time yield() occured. Whereas yield() panics
+// in SYS, optimistic_yield() additionally is safe to call and does nothing.
extern "C" void optimistic_yield(uint32_t interval_us) {
const uint32_t intvl_cycles = interval_us *
#if defined(F_CPU)
@@ -147,7 +193,7 @@ extern "C" void optimistic_yield(uint32_t interval_us) {
#else
ESP.getCpuFreqMHz();
#endif
- if ((ESP.getCycleCount() - s_cycles_at_yield_start) > intvl_cycles &&
+ if ((ESP.getCycleCount() - s_cycles_at_resume) > intvl_cycles &&
can_yield())
{
yield();
@@ -207,7 +253,7 @@ static void loop_wrapper() {
static void loop_task(os_event_t *events) {
(void) events;
- s_cycles_at_yield_start = ESP.getCycleCount();
+ s_cycles_at_resume = ESP.getCycleCount();
ESP.resetHeap();
cont_run(g_pcont, &loop_wrapper);
ESP.setDramHeap();
@@ -215,8 +261,8 @@ static void loop_task(os_event_t *events) {
panic();
}
}
-extern "C" {
+extern "C" {
struct object { long placeholder[ 10 ]; };
void __register_frame_info (const void *begin, struct object *ob);
extern char __eh_frame[];
@@ -253,7 +299,6 @@ static void __unhandled_exception_cpp()
}
#endif
}
-
}
void init_done() {
diff --git a/cores/esp8266/core_esp8266_postmortem.cpp b/cores/esp8266/core_esp8266_postmortem.cpp
index 3e75342d05..2279401b54 100644
--- a/cores/esp8266/core_esp8266_postmortem.cpp
+++ b/cores/esp8266/core_esp8266_postmortem.cpp
@@ -245,12 +245,12 @@ static void print_stack(uint32_t start, uint32_t end) {
}
}
-static void uart_write_char_d(char c) {
+static void IRAM_ATTR uart_write_char_d(char c) {
uart0_write_char_d(c);
uart1_write_char_d(c);
}
-static void uart0_write_char_d(char c) {
+static void IRAM_ATTR uart0_write_char_d(char c) {
while (((USS(0) >> USTXC) & 0xff)) { }
if (c == '\n') {
@@ -259,7 +259,7 @@ static void uart0_write_char_d(char c) {
USF(0) = c;
}
-static void uart1_write_char_d(char c) {
+static void IRAM_ATTR uart1_write_char_d(char c) {
while (((USS(1) >> USTXC) & 0xff) >= 0x7e) { }
if (c == '\n') {
diff --git a/cores/esp8266/core_esp8266_waveform_phase.cpp b/cores/esp8266/core_esp8266_waveform_phase.cpp
index de2f914121..4240ccb3c1 100644
--- a/cores/esp8266/core_esp8266_waveform_phase.cpp
+++ b/cores/esp8266/core_esp8266_waveform_phase.cpp
@@ -211,7 +211,7 @@ int startWaveformClockCycles_weak(uint8_t pin, uint32_t highCcys, uint32_t lowCc
}
std::atomic_thread_fence(std::memory_order_acq_rel);
while (waveform.toSetBits) {
- delay(0); // Wait for waveform to update
+ esp_yield(); // Wait for waveform to update
std::atomic_thread_fence(std::memory_order_acquire);
}
return true;
diff --git a/cores/esp8266/core_esp8266_waveform_pwm.cpp b/cores/esp8266/core_esp8266_waveform_pwm.cpp
index 916361e2ca..f85ccb76aa 100644
--- a/cores/esp8266/core_esp8266_waveform_pwm.cpp
+++ b/cores/esp8266/core_esp8266_waveform_pwm.cpp
@@ -40,6 +40,7 @@
#include <Arduino.h>
+#include <coredecls.h>
#include "ets_sys.h"
#include "core_esp8266_waveform.h"
#include "user_interface.h"
@@ -162,7 +163,7 @@ static IRAM_ATTR void _notifyPWM(PWMState *p, bool idle) {
forceTimerInterrupt();
while (pwmState.pwmUpdate) {
if (idle) {
- delay(0);
+ esp_yield();
}
MEMBARRIER();
}
@@ -372,8 +373,8 @@ int startWaveformClockCycles_weak(uint8_t pin, uint32_t timeHighCycles, uint32_t
if (wvfState.waveformEnabled & mask) {
// Make sure no waveform changes are waiting to be applied
while (wvfState.waveformToChange) {
- delay(0); // Wait for waveform to update
- // No mem barrier here, the call to a global function implies global state updated
+ esp_yield(); // Wait for waveform to update
+ MEMBARRIER();
}
wvfState.waveformNewHigh = timeHighCycles;
wvfState.waveformNewLow = timeLowCycles;
@@ -392,8 +393,8 @@ int startWaveformClockCycles_weak(uint8_t pin, uint32_t timeHighCycles, uint32_t
initTimer();
forceTimerInterrupt();
while (wvfState.waveformToEnable) {
- delay(0); // Wait for waveform to update
- // No mem barrier here, the call to a global function implies global state updated
+ esp_yield(); // Wait for waveform to update
+ MEMBARRIER();
}
}
diff --git a/cores/esp8266/core_esp8266_wiring.cpp b/cores/esp8266/core_esp8266_wiring.cpp
index b956cebe43..40a996d560 100644
--- a/cores/esp8266/core_esp8266_wiring.cpp
+++ b/cores/esp8266/core_esp8266_wiring.cpp
@@ -23,37 +23,18 @@
#include "ets_sys.h"
#include "osapi.h"
#include "user_interface.h"
-#include "cont.h"
+#include "coredecls.h"
extern "C" {
-extern void ets_delay_us(uint32_t us);
-extern void esp_schedule();
-extern void esp_yield();
-
-static os_timer_t delay_timer;
static os_timer_t micros_overflow_timer;
static uint32_t micros_at_last_overflow_tick = 0;
static uint32_t micros_overflow_count = 0;
#define ONCE 0
#define REPEAT 1
-void delay_end(void* arg) {
- (void) arg;
- esp_schedule();
-}
-
void __delay(unsigned long ms) {
- if(ms) {
- os_timer_setfn(&delay_timer, (os_timer_func_t*) &delay_end, 0);
- os_timer_arm(&delay_timer, ms, ONCE);
- } else {
- esp_schedule();
- }
- esp_yield();
- if(ms) {
- os_timer_disarm(&delay_timer);
- }
+ esp_delay(ms);
}
void delay(unsigned long ms) __attribute__ ((weak, alias("__delay")));
diff --git a/cores/esp8266/coredecls.h b/cores/esp8266/coredecls.h
index b9c771df77..e5573792bb 100644
--- a/cores/esp8266/coredecls.h
+++ b/cores/esp8266/coredecls.h
@@ -2,6 +2,10 @@
#ifndef __COREDECLS_H
#define __COREDECLS_H
+#define HAVE_ESP_SUSPEND 1
+
+#include "core_esp8266_features.h"
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -13,8 +17,10 @@ extern "C" {
#include <cont.h> // g_pcont declaration
bool can_yield();
-void esp_yield();
+void esp_suspend();
+void esp_delay(unsigned long ms);
void esp_schedule();
+void esp_yield();
void tune_timeshift64 (uint64_t now_us);
void disable_extra4k_at_link_time (void) __attribute__((noinline));
bool sntp_set_timezone_in_seconds(int32_t timezone);
@@ -32,9 +38,45 @@ uint32_t crc32 (const void* data, size_t length, uint32_t crc = 0xffffffff);
using BoolCB = std::function<void(bool)>;
using TrivialCB = std::function<void()>;
+void settimeofday_cb (BoolCB&& cb);
void settimeofday_cb (const BoolCB& cb);
void settimeofday_cb (const TrivialCB& cb);
+// This overload of esp_suspend() performs the blocked callback whenever it is resumed,
+// and if that returns true, it immediately suspends again.
+template <typename T>
+inline void esp_suspend(T&& blocked) {
+ do {
+ esp_suspend();
+ } while (blocked());
+}
+
+// Try to delay until timeout_ms has expired since start_ms.
+// Returns true if timeout_ms has completely expired on entry.
+// Otherwise returns false after delaying for the relative
+// remainder of timeout_ms, or an absolute intvl_ms, whichever is shorter.
+// The delay may be asynchronously cancelled, before that timeout is reached.
+bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms);
+
+// This overload of esp_delay() delays for a duration of at most timeout_ms milliseconds.
+// Whenever it is resumed, as well as every intvl_ms millisconds, it performs
+// the blocked callback, and if that returns true, it keeps delaying for the remainder
+// of the original timeout_ms period.
+template <typename T>
+inline void esp_delay(const uint32_t timeout_ms, T&& blocked, const uint32_t intvl_ms) {
+ const auto start_ms = millis();
+ while (!esp_try_delay(start_ms, timeout_ms, intvl_ms) && blocked()) {
+ }
+}
+
+// This overload of esp_delay() delays for a duration of at most timeout_ms milliseconds.
+// Whenever it is resumed, it performs the blocked callback, and if that returns true,
+// it keeps delaying for the remainder of the original timeout_ms period.
+template <typename T>
+inline void esp_delay(const uint32_t timeout_ms, T&& blocked) {
+ esp_delay(timeout_ms, std::forward<T>(blocked), timeout_ms);
+}
+
#endif // __cplusplus
#endif // __COREDECLS_H
diff --git a/cores/esp8266/hwdt_app_entry.cpp b/cores/esp8266/hwdt_app_entry.cpp
index 3a657cfcd9..22a91a6bee 100644
--- a/cores/esp8266/hwdt_app_entry.cpp
+++ b/cores/esp8266/hwdt_app_entry.cpp
@@ -952,13 +952,13 @@ STATIC void IRAM_MAYBE handle_hwdt(void) {
/* Print separate ctx: cont stack */
/* Check if cont stack is yielding to SYS */
- if (0 == hwdt_info.cont_integrity && 0 != g_pcont->pc_yield) {
- ctx_cont_ptr = (const uint32_t *)((uintptr_t)g_pcont->sp_yield - 8u);
+ if (0 == hwdt_info.cont_integrity && 0 != g_pcont->pc_suspend) {
+ ctx_cont_ptr = (const uint32_t *)((uintptr_t)g_pcont->sp_suspend - 8u);
}
print_stack((uintptr_t)ctx_cont_ptr, (uintptr_t)g_pcont->stack_end, PRINT_STACK::CONT);
} else {
- if (0 == hwdt_info.cont_integrity && 0 != g_pcont->pc_yield) {
- ETS_PRINTF("\nCont stack is yielding. Active stack starts at 0x%08X.\n", (uint32_t)g_pcont->sp_yield - 8u);
+ if (0 == hwdt_info.cont_integrity && 0 != g_pcont->pc_suspend) {
+ ETS_PRINTF("\nCont stack is yielding. Active stack starts at 0x%08X.\n", (uint32_t)g_pcont->sp_suspend - 8u);
}
}
diff --git a/cores/esp8266/time.cpp b/cores/esp8266/time.cpp
index b9489c330f..8e997c72d5 100644
--- a/cores/esp8266/time.cpp
+++ b/cores/esp8266/time.cpp
@@ -214,6 +214,11 @@ void settimeofday_cb (const TrivialCB& cb)
_settimeofday_cb = [cb](bool sntp) { (void)sntp; cb(); };
}
+void settimeofday_cb (BoolCB&& cb)
+{
+ _settimeofday_cb = std::move(cb);
+}
+
void settimeofday_cb (const BoolCB& cb)
{
_settimeofday_cb = cb;
diff --git a/cores/esp8266/uart.cpp b/cores/esp8266/uart.cpp
index de574d0bee..1f657c9403 100644
--- a/cores/esp8266/uart.cpp
+++ b/cores/esp8266/uart.cpp
@@ -41,6 +41,7 @@
*
*/
#include "Arduino.h"
+#include "coredecls.h"
#include <pgmspace.h>
#include "gdb_hooks.h"
#include "uart.h"
@@ -493,13 +494,13 @@ uart_stop_isr(uart_t* uart)
-tools/sdk/uart_register.h
-cores/esp8266/esp8266_peri.h
*/
-inline size_t
+inline __attribute__((always_inline)) size_t
uart_tx_fifo_available(const int uart_nr)
{
return (USS(uart_nr) >> USTXC) & 0xff;
}
-inline bool
+inline __attribute__((always_inline)) bool
uart_tx_fifo_full(const int uart_nr)
{
return uart_tx_fifo_available(uart_nr) >= 0x7f;
@@ -566,7 +567,7 @@ uart_wait_tx_empty(uart_t* uart)
return;
while(uart_tx_fifo_available(uart->uart_nr) > 0)
- delay(0);
+ esp_yield();
}
@@ -943,23 +944,23 @@ uart_ignore_char(char c)
(void) c;
}
-inline void
+inline __attribute__((always_inline)) void
uart_write_char_delay(const int uart_nr, char c)
{
while(uart_tx_fifo_full(uart_nr))
- delay(0);
+ esp_yield();
USF(uart_nr) = c;
}
-static void
+static void IRAM_ATTR
uart0_write_char(char c)
{
uart_write_char_delay(0, c);
}
-static void
+static void IRAM_ATTR
uart1_write_char(char c)
{
uart_write_char_delay(1, c);
diff --git a/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp b/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp
index b35892e748..d9b50a8b7c 100644
--- a/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp
+++ b/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp
@@ -22,6 +22,7 @@
*
*/
#include <Arduino.h>
+#include <coredecls.h>
#include "ESP8266HTTPClient.h"
#include <ESP8266WiFi.h>
@@ -556,6 +557,7 @@ int HTTPClient::sendRequest(const char * type, Stream * stream, size_t size)
if (transferred != size)
{
DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] short write, asked for %d but got %d failed.\n", size, transferred);
+ esp_yield();
return returnError(HTTPC_ERROR_SEND_PAYLOAD_FAILED);
}
@@ -698,7 +700,7 @@ int HTTPClient::writeToPrint(Print * print)
return returnError(HTTPC_ERROR_READ_TIMEOUT);
}
- delay(0);
+ esp_yield();
}
} else {
return returnError(HTTPC_ERROR_ENCODING);
@@ -1060,7 +1062,7 @@ int HTTPClient::handleHeaderResponse()
if((millis() - lastDataTime) > _tcpTimeout) {
return HTTPC_ERROR_READ_TIMEOUT;
}
- delay(0);
+ esp_yield();
}
}
diff --git a/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer-impl.h b/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer-impl.h
index 3357f2ac63..39608934cd 100644
--- a/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer-impl.h
+++ b/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer-impl.h
@@ -1,4 +1,5 @@
#include <Arduino.h>
+#include <coredecls.h>
#include <WiFiClient.h>
#include <WiFiServer.h>
#include <ESP8266WebServer.h>
@@ -119,7 +120,7 @@ void ESP8266HTTPUpdateServerTemplate<ServerType>::setup(ESP8266WebServerTemplate
Update.end();
if (_serial_output) Serial.println("Update was aborted");
}
- delay(0);
+ esp_yield();
});
}
diff --git a/libraries/ESP8266WiFi/examples/WiFiScan/WiFiScan.ino b/libraries/ESP8266WiFi/examples/WiFiScan/WiFiScan.ino
index 84a9befcf2..b546df4a7d 100644
--- a/libraries/ESP8266WiFi/examples/WiFiScan/WiFiScan.ino
+++ b/libraries/ESP8266WiFi/examples/WiFiScan/WiFiScan.ino
@@ -49,7 +49,7 @@ void loop() {
(encryptionType == ENC_TYPE_NONE) ? ' ' : '*',
hidden ? 'H' : 'V',
ssid.c_str());
- delay(0);
+ yield();
}
} else {
Serial.printf(PSTR("WiFi scan error %d"), scanResult);
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp
index 19da592c76..822f861a91 100644
--- a/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp
+++ b/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp
@@ -49,10 +49,6 @@ extern "C" {
#include "debug.h"
#include "include/WiFiState.h"
-extern "C" void esp_schedule();
-extern "C" void esp_yield();
-
-
// -----------------------------------------------------------------------------------------------------------------------
// ------------------------------------------------- Generic WiFi function -----------------------------------------------
// -----------------------------------------------------------------------------------------------------------------------
@@ -438,10 +434,9 @@ bool ESP8266WiFiGenericClass::mode(WiFiMode_t m) {
//tasks to wait correctly.
constexpr unsigned int timeoutValue = 1000; //1 second
if(can_yield()) {
- using oneShot = esp8266::polledTimeout::oneShotFastMs;
- oneShot timeout(timeoutValue);
- while(wifi_get_opmode() != (uint8) m && !timeout)
- delay(5);
+ // The final argument, intvl_ms, to esp_delay influences how frequently
+ // the scheduled recurrent functions (Schedule.h) are probed.
+ esp_delay(timeoutValue, [m]() { return wifi_get_opmode() != m; }, 5);
//if at this point mode still hasn't been reached, give up
if(wifi_get_opmode() != (uint8) m) {
@@ -518,9 +513,9 @@ bool ESP8266WiFiGenericClass::forceSleepBegin(uint32 sleepUs) {
}
wifi_fpm_set_sleep_type(MODEM_SLEEP_T);
- delay(0);
+ esp_yield();
wifi_fpm_open();
- delay(0);
+ esp_yield();
auto ret = wifi_fpm_do_sleep(sleepUs);
if (ret != 0)
{
@@ -621,22 +616,24 @@ int ESP8266WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResul
aResult = IPAddress(&addr);
} else if(err == ERR_INPROGRESS) {
_dns_lookup_pending = true;
- delay(timeout_ms);
- // will resume on timeout or when wifi_dns_found_callback fires
+ // Will resume on timeout or when wifi_dns_found_callback fires.
+ // The final argument, intvl_ms, to esp_delay influences how frequently
+ // the scheduled recurrent functions (Schedule.h) are probed; here, to allow
+ // the ethernet driver perform work.
+ esp_delay(timeout_ms, []() { return _dns_lookup_pending; }, 1);
_dns_lookup_pending = false;
- // will return here when dns_found_callback fires
if(aResult.isSet()) {
err = ERR_OK;
}
}
- if(err != 0) {
- DEBUG_WIFI_GENERIC("[hostByName] Host: %s lookup error: %d!\n", aHostname, (int)err);
- } else {
+ if(err == ERR_OK) {
DEBUG_WIFI_GENERIC("[hostByName] Host: %s IP: %s\n", aHostname, aResult.toString().c_str());
+ return 1;
}
-
- return (err == ERR_OK) ? 1 : 0;
+
+ DEBUG_WIFI_GENERIC("[hostByName] Host: %s lookup error: %s (%d)!\n", aHostname, lwip_strerr(err), (int)err);
+ return 0;
}
#if LWIP_IPV4 && LWIP_IPV6
@@ -671,8 +668,8 @@ int ESP8266WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResul
aResult = IPAddress(&addr);
} else if(err == ERR_INPROGRESS) {
_dns_lookup_pending = true;
- delay(timeout_ms);
// will resume on timeout or when wifi_dns_found_callback fires
+ esp_delay(timeout_ms, []() { return _dns_lookup_pending; });
_dns_lookup_pending = false;
// will return here when dns_found_callback fires
if(aResult.isSet()) {
@@ -680,13 +677,13 @@ int ESP8266WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResul
}
}
- if(err != 0) {
- DEBUG_WIFI_GENERIC("[hostByName] Host: %s lookup error: %d!\n", aHostname, (int)err);
- } else {
+ if(err == ERR_OK) {
DEBUG_WIFI_GENERIC("[hostByName] Host: %s IP: %s\n", aHostname, aResult.toString().c_str());
+ return 1;
}
- return (err == ERR_OK) ? 1 : 0;
+ DEBUG_WIFI_GENERIC("[hostByName] Host: %s lookup error: %d!\n", aHostname, (int)err);
+ return 0;
}
#endif
@@ -705,7 +702,8 @@ void wifi_dns_found_callback(const char *name, const ip_addr_t *ipaddr, void *ca
if(ipaddr) {
(*reinterpret_cast<IPAddress*>(callback_arg)) = IPAddress(ipaddr);
}
- esp_schedule(); // break delay in hostByName
+ _dns_lookup_pending = false; // resume hostByName
+ esp_schedule();
}
uint32_t ESP8266WiFiGenericClass::shutdownCRC (const WiFiState& state)
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp
index 8d74f687cb..0f6cb72abe 100644
--- a/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp
+++ b/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp
@@ -25,6 +25,7 @@
#include "PolledTimeout.h"
#include "ESP8266WiFiMulti.h"
+#include <coredecls.h>
#include <limits.h>
#include <string.h>
@@ -82,37 +83,29 @@ static void printWiFiStatus(wl_status_t status)
*/
static wl_status_t waitWiFiConnect(uint32_t connectTimeoutMs)
{
- wl_status_t status;
-
- // Set WiFi connect timeout
- using esp8266::polledTimeout::oneShotMs;
- oneShotMs connectTimeout(connectTimeoutMs);
-
- // Wait for WiFi status change or timeout
- do {
- // Refresh watchdog
- delay(0);
-
- // Get WiFi status
- status = WiFi.status();
-
- // Check status
- if (status == WL_CONNECTED) {
- // Connected, print WiFi status
- printWiFiStatus(status);
-
- // Return WiFi status
- return status;
- } else if (status == WL_CONNECT_FAILED) {
- DEBUG_WIFI_MULTI("[WIFIM] Connect failed\n");
-
- // Return WiFi connect failed
- return WL_CONNECT_FAILED;
- }
- } while (!connectTimeout);
+ wl_status_t status = WL_CONNECT_FAILED;
+ // The final argument, intvl_ms, to esp_delay influences how frequently
+ // the scheduled recurrent functions (Schedule.h) are probed.
+ esp_delay(connectTimeoutMs,
+ [&status]() {
+ status = WiFi.status();
+ return status != WL_CONNECTED && status != WL_CONNECT_FAILED;
+ }, 0);
+
+ // Check status
+ if (status == WL_CONNECTED) {
+ // Connected, print WiFi status
+ printWiFiStatus(status);
- DEBUG_WIFI_MULTI("[WIFIM] Connect timeout\n");
+ // Return WiFi status
+ return status;
+ } else if (status == WL_CONNECT_FAILED) {
+ DEBUG_WIFI_MULTI("[WIFIM] Connect failed\n");
+ } else {
+ DEBUG_WIFI_MULTI("[WIFIM] Connect timeout\n");
+ }
+ // Return WiFi connect failed
return WL_CONNECT_FAILED;
}
@@ -242,24 +235,19 @@ int8_t ESP8266WiFiMulti::startScan()
// Start wifi scan in async mode
WiFi.scanNetworks(true);
- // Set WiFi scan timeout
- using esp8266::polledTimeout::oneShotMs;
- oneShotMs scanTimeout(WIFI_SCAN_TIMEOUT_MS);
-
// Wait for WiFi scan change or timeout
- do {
- // Refresh watchdog
- delay(0);
-
- // Check scan timeout which may occur when scan does not report completion
- if (scanTimeout) {
- DEBUG_WIFI_MULTI("[WIFIM] Scan timeout\n");
- return WIFI_SCAN_FAILED;
- }
-
- // Get scan result
- scanResult = WiFi.scanComplete();
- } while (scanResult < 0);
+ // The final argument, intvl_ms, to esp_delay influences how frequently
+ // the scheduled recurrent functions (Schedule.h) are probed.
+ esp_delay(WIFI_SCAN_TIMEOUT_MS,
+ [&scanResult]() {
+ scanResult = WiFi.scanComplete();
+ return scanResult < 0;
+ }, 0);
+ // Check for scan timeout which may occur when scan does not report completion
+ if (scanResult < 0) {
+ DEBUG_WIFI_MULTI("[WIFIM] Scan timeout\n");
+ return WIFI_SCAN_FAILED;
+ }
// Print WiFi scan result
printWiFiScan();
@@ -535,7 +523,7 @@ void ESP8266WiFiMulti::printWiFiScan()
rssi,
(encryptionType == ENC_TYPE_NONE) ? ' ' : '*',
ssid.c_str());
- delay(0);
+ esp_yield();
}
#endif
}
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiSTA-WPS.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiSTA-WPS.cpp
index 99d27ba7a3..b93c77da9c 100644
--- a/libraries/ESP8266WiFi/src/ESP8266WiFiSTA-WPS.cpp
+++ b/libraries/ESP8266WiFi/src/ESP8266WiFiSTA-WPS.cpp
@@ -30,6 +30,8 @@
static void wifi_wps_status_cb(wps_cb_status status);
+static bool _wps_config_pending = false;
+
/**
* WPS config
* so far only WPS_TYPE_PBC is supported (SDK 1.2.0)
@@ -70,8 +72,9 @@ bool ESP8266WiFiSTAClass::beginWPSConfig(void) {
return false;
}
- esp_yield();
+ _wps_config_pending = true;
// will resume when wifi_wps_status_cb fires
+ esp_suspend([]() { return _wps_config_pending; });
return true;
}
@@ -107,5 +110,6 @@ void wifi_wps_status_cb(wps_cb_status status) {
}
// TODO user function to get status
- esp_schedule(); // resume beginWPSConfig
+ _wps_config_pending = false; // resume beginWPSConfig
+ esp_schedule();
}
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.cpp
index 618dbfcc86..c1c63996aa 100644
--- a/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.cpp
+++ b/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.cpp
@@ -28,6 +28,8 @@
#include "PolledTimeout.h"
#include "LwipIntf.h"
+#include <coredecls.h>
+
#include "c_types.h"
#include "ets_sys.h"
#include "os_type.h"
@@ -44,9 +46,6 @@ extern "C" {
#include "debug.h"
-extern "C" void esp_schedule();
-extern "C" void esp_yield();
-
// -----------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------- Private functions ------------------------------------------------
// -----------------------------------------------------------------------------------------------------------------------
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiScan.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiScan.cpp
index 65878a3d5b..6aaf432e2d 100644
--- a/libraries/ESP8266WiFi/src/ESP8266WiFiScan.cpp
+++ b/libraries/ESP8266WiFi/src/ESP8266WiFiScan.cpp
@@ -36,9 +36,7 @@ extern "C" {
}
#include "debug.h"
-
-extern "C" void esp_schedule();
-extern "C" void esp_yield();
+#include <coredecls.h>
// -----------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------- Private functions ------------------------------------------------
@@ -94,11 +92,13 @@ int8_t ESP8266WiFiScanClass::scanNetworks(bool async, bool show_hidden, uint8 ch
ESP8266WiFiScanClass::_scanStarted = true;
if(ESP8266WiFiScanClass::_scanAsync) {
- delay(0); // time for the OS to trigger the scan
+ esp_yield(); // time for the OS to trigger the scan
return WIFI_SCAN_RUNNING;
}
- esp_yield(); // will resume when _scanDone fires
+ // will resume when _scanDone fires
+ esp_suspend([]() { return !ESP8266WiFiScanClass::_scanComplete && ESP8266WiFiScanClass::_scanStarted; });
+
return ESP8266WiFiScanClass::_scanCount;
} else {
return WIFI_SCAN_FAILED;
@@ -322,7 +322,7 @@ void ESP8266WiFiScanClass::_scanDone(void* result, int status) {
ESP8266WiFiScanClass::_scanStarted = false;
ESP8266WiFiScanClass::_scanComplete = true;
- if(!ESP8266WiFiScanClass::_scanAsync) {
+ if (!ESP8266WiFiScanClass::_scanAsync) {
esp_schedule(); // resume scanNetworks
} else if (ESP8266WiFiScanClass::_onComplete) {
ESP8266WiFiScanClass::_onComplete(ESP8266WiFiScanClass::_scanCount);
diff --git a/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp b/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp
index 6a82ff3b96..9ad357c33a 100644
--- a/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp
+++ b/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp
@@ -44,7 +44,6 @@ extern "C" {
#include "lwip/netif.h"
#include <include/ClientContext.h>
#include "c_types.h"
-#include "coredecls.h"
#include <mmu_iram.h>
#include <umm_malloc/umm_malloc.h>
#include <umm_malloc/umm_heap_select.h>
diff --git a/libraries/ESP8266WiFi/src/include/ClientContext.h b/libraries/ESP8266WiFi/src/include/ClientContext.h
index a994b5cb1d..7fcad3678a 100644
--- a/libraries/ESP8266WiFi/src/include/ClientContext.h
+++ b/libraries/ESP8266WiFi/src/include/ClientContext.h
@@ -26,11 +26,9 @@ class WiFiClient;
typedef void (*discard_cb_t)(void*, ClientContext*);
-extern "C" void esp_yield();
-extern "C" void esp_schedule();
-
#include <assert.h>
#include <esp_priv.h>
+#include <coredecls.h>
bool getDefaultPrivateGlobalSyncValue ();
@@ -145,11 +143,9 @@ class ClientContext
}
_connect_pending = true;
_op_start_time = millis();
- for (decltype(_timeout_ms) i = 0; _connect_pending && i < _timeout_ms; i++) {
- // Give scheduled functions a chance to run (e.g. Ethernet uses recurrent)
- delay(1);
- // will resume on timeout or when _connected or _notify_error fires
- }
+ // will resume on timeout or when _connected or _notify_error fires
+ // give scheduled functions a chance to run (e.g. Ethernet uses recurrent)
+ esp_delay(_timeout_ms, [this]() { return this->_connect_pending; }, 1);
_connect_pending = false;
if (!_pcb) {
DEBUGV(":cabrt\r\n");
@@ -352,7 +348,7 @@ class ClientContext
last_sent = millis();
}
- delay(0); // from sys or os context
+ esp_yield(); // from sys or os context
if ((state() != ESTABLISHED) || (sndbuf == TCP_SND_BUF)) {
// peer has closed or all bytes are sent and acked
@@ -458,9 +454,10 @@ class ClientContext
void _notify_error()
{
if (_connect_pending || _send_waiting) {
+ // resume connect or _write_from_source
_send_waiting = false;
_connect_pending = false;
- esp_schedule(); // break delay in connect or _write_from_source
+ esp_schedule();
}
}
@@ -487,11 +484,9 @@ class ClientContext
}
_send_waiting = true;
- for (decltype(_timeout_ms) i = 0; _send_waiting && i < _timeout_ms; i++) {
- // Give scheduled functions a chance to run (e.g. Ethernet uses recurrent)
- delay(1);
- // will resume on timeout or when _write_some_from_cb or _notify_error fires
- }
+ // will resume on timeout or when _write_some_from_cb or _notify_error fires
+ // give scheduled functions a chance to run (e.g. Ethernet uses recurrent)
+ esp_delay(_timeout_ms, [this]() { return this->_send_waiting; }, 1);
_send_waiting = false;
} while(true);
@@ -561,8 +556,9 @@ class ClientContext
void _write_some_from_cb()
{
if (_send_waiting) {
+ // resume _write_from_source
_send_waiting = false;
- esp_schedule(); // break delay in _write_from_source
+ esp_schedule();
}
}
@@ -649,8 +645,9 @@ class ClientContext
(void) pcb;
assert(pcb == _pcb);
if (_connect_pending) {
+ // resume connect
_connect_pending = false;
- esp_schedule(); // break delay in connect
+ esp_schedule();
}
return ERR_OK;
}
diff --git a/libraries/ESP8266WiFi/src/include/UdpContext.h b/libraries/ESP8266WiFi/src/include/UdpContext.h
index 1d3c6e418c..1e7f639e34 100644
--- a/libraries/ESP8266WiFi/src/include/UdpContext.h
+++ b/libraries/ESP8266WiFi/src/include/UdpContext.h
@@ -24,7 +24,7 @@
class UdpContext;
extern "C" {
-void esp_yield();
+void esp_suspend();
void esp_schedule();
#include <assert.h>
}
@@ -177,7 +177,7 @@ class UdpContext
}
// warning: handler is called from tcp stack context
- // esp_yield and non-reentrant functions which depend on it will fail
+ // esp_suspend and non-reentrant functions which depend on it will fail
void onRx(rxhandler_t handler) {
_on_rx = handler;
}
@@ -411,7 +411,7 @@ class UdpContext
err_t err;
esp8266::polledTimeout::oneShotFastMs timeout(timeoutMs);
while (((err = trySend(addr, port, /* keep buffer on error */true)) != ERR_OK) && !timeout)
- delay(0);
+ esp_yield();
if (err != ERR_OK)
cancelBuffer(); // get rid of buffer kept on error after timeout
return err == ERR_OK;
diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp
index 6fc4e3cd01..bf1b1cde26 100644
--- a/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp
+++ b/libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp
@@ -702,7 +702,7 @@ bool MDNSResponder::_parseResponse(const MDNSResponder::stcMDNS_MsgHeader& p_Msg
for (uint16_t qd=0; ((bDumpResult) && (qd<p_MsgHeader.m_u16QDCount)); ++qd) {
stcMDNS_RRQuestion questionRR;
bDumpResult = _readRRQuestion(questionRR);
- esp_yield();
+ esp_suspend();
} // for questions
// Handle known answers
uint32_t u32Answers = (p_MsgHeader.m_u16ANCount + p_MsgHeader.m_u16NSCount + p_MsgHeader.m_u16ARCount);
@@ -713,7 +713,7 @@ bool MDNSResponder::_parseResponse(const MDNSResponder::stcMDNS_MsgHeader& p_Msg
delete pRRAnswer;
pRRAnswer = 0;
}
- esp_yield();
+ esp_suspend();
}
);*/
m_pUDPContext->flush();
diff --git a/libraries/esp8266/examples/SerialStress/SerialStress.ino b/libraries/esp8266/examples/SerialStress/SerialStress.ino
index b06b38e307..a19eb9f270 100644
--- a/libraries/esp8266/examples/SerialStress/SerialStress.ino
+++ b/libraries/esp8266/examples/SerialStress/SerialStress.ino
@@ -122,7 +122,7 @@ void loop() {
if ((out_idx += local_written_size) == BUFFER_SIZE) {
out_idx = 0;
}
- delay(0);
+ yield();
DEBUG(logger->printf("----------\n"));
diff --git a/tests/host/common/Arduino.cpp b/tests/host/common/Arduino.cpp
index 780c4adc14..c2c1fa10a2 100644
--- a/tests/host/common/Arduino.cpp
+++ b/tests/host/common/Arduino.cpp
@@ -15,6 +15,7 @@
#include <sys/time.h>
#include "Arduino.h"
+#include <functional>
#include <unistd.h>
@@ -53,10 +54,31 @@ extern "C" void optimistic_yield (uint32_t interval_us)
(void)interval_us;
}
+extern "C" void esp_suspend()
+{
+}
+
+extern "C" void esp_schedule()
+{
+}
+
extern "C" void esp_yield()
{
}
+extern "C" void esp_delay (unsigned long ms)
+{
+ usleep(ms * 1000);
+}
+
+bool esp_try_delay(const uint32_t start_ms, const uint32_t timeout_ms, const uint32_t intvl_ms) {
+ uint32_t expired = millis() - start_ms;
+ if (expired >= timeout_ms) {
+ return true;
+ }
+ esp_delay(std::min((timeout_ms - expired), intvl_ms));
+ return false;
+}
extern "C" void __panic_func(const char* file, int line, const char* func) {
(void)file;
@@ -67,7 +89,7 @@ extern "C" void __panic_func(const char* file, int line, const char* func) {
extern "C" void delay(unsigned long ms)
{
- usleep(ms * 1000);
+ esp_delay(ms);
}
extern "C" void delayMicroseconds(unsigned int us)
@@ -77,6 +99,6 @@ extern "C" void delayMicroseconds(unsigned int us)
#include "cont.h"
cont_t* g_pcont = NULL;
-extern "C" void cont_yield(cont_t*)
+extern "C" void cont_suspend(cont_t*)
{
}
diff --git a/tests/host/common/include/ClientContext.h b/tests/host/common/include/ClientContext.h
index 744d7872d4..bd9c9b80a5 100644
--- a/tests/host/common/include/ClientContext.h
+++ b/tests/host/common/include/ClientContext.h
@@ -24,9 +24,6 @@
class ClientContext;
class WiFiClient;
-extern "C" void esp_yield();
-extern "C" void esp_schedule();
-
#include <assert.h>
bool getDefaultPrivateGlobalSyncValue ();
diff --git a/tests/host/common/user_interface.cpp b/tests/host/common/user_interface.cpp
index b3a302df18..4e03d77786 100644
--- a/tests/host/common/user_interface.cpp
+++ b/tests/host/common/user_interface.cpp
@@ -498,10 +498,6 @@ extern "C"
(void)intr;
}
- void esp_schedule(void)
- {
- }
-
void dns_setserver(u8_t numdns, ip_addr_t *dnsserver)
{
(void)numdns;