Merge branch 'master' into master

Author: devyte

cores/esp8266/Arduino.h

@@ -204,6 +204,7 @@ void setup(void);
 void loop(void);
 
 void yield(void);
+
 void optimistic_yield(uint32_t interval_us);
 
 #define _PORT_GPIO16    1
@@ -281,6 +282,13 @@ void configTime(int timezone, int daylightOffset_sec, const char* server1,
 void configTime(const char* tz, const char* server1,
     const char* server2 = nullptr, const char* server3 = nullptr);
 
+// esp32 api compatibility
+inline void configTzTime(const char* tz, const char* server1,
+    const char* server2 = nullptr, const char* server3 = nullptr)
+{
+    configTime(tz, server1, server2, server3);
+}
+
 #endif // __cplusplus
 
 #include "pins_arduino.h"

cores/esp8266/FS.cpp

@@ -187,6 +187,13 @@ time_t File::getLastWrite() {
     return _p->getLastWrite();
 }
 
+time_t File::getCreationTime() {
+    if (!_p)
+        return 0;
+
+    return _p->getCreationTime();
+}
+
 void File::setTimeCallback(time_t (*cb)(void)) {
     if (!_p)
         return;
@@ -224,6 +231,12 @@ time_t Dir::fileTime() {
     return _impl->fileTime();
 }
 
+time_t Dir::fileCreationTime() {
+    if (!_impl)
+        return 0;
+    return _impl->fileCreationTime();
+}
+
 size_t Dir::fileSize() {
     if (!_impl) {
         return 0;
@@ -262,17 +275,11 @@ bool Dir::rewind() {
     return _impl->rewind();
 }
 
-time_t Dir::getLastWrite() {
-    if (!_impl)
-        return 0;
-
-    return _impl->getLastWrite();
-}
-
 void Dir::setTimeCallback(time_t (*cb)(void)) {
     if (!_impl)
         return;
     _impl->setTimeCallback(cb);
+    timeCallback = cb;
 }
 
 
@@ -289,6 +296,7 @@ bool FS::begin() {
         DEBUGV("#error: FS: no implementation");
         return false;
     }
+    _impl->setTimeCallback(timeCallback);
     bool ret = _impl->begin();
     DEBUGV("%s\n", ret? "": "#error: FS could not start");
     return ret;

cores/esp8266/FS.h

@@ -112,6 +112,7 @@ class File : public Stream
     String readString() override;
 
     time_t getLastWrite();
+    time_t getCreationTime();
     void setTimeCallback(time_t (*cb)(void));
 
 protected:
@@ -120,7 +121,6 @@ class File : public Stream
     // Arduino SD class emulation
     std::shared_ptr<Dir> _fakeDir;
     FS                  *_baseFS;
-    time_t (*timeCallback)(void) = nullptr;
 };
 
 class Dir {
@@ -132,20 +132,19 @@ class Dir {
     String fileName();
     size_t fileSize();
     time_t fileTime();
+    time_t fileCreationTime();
     bool isFile() const;
     bool isDirectory() const;
 
     bool next();
     bool rewind();
 
-    time_t getLastWrite();
     void setTimeCallback(time_t (*cb)(void));
 
 protected:
     DirImplPtr _impl;
     FS       *_baseFS;
     time_t (*timeCallback)(void) = nullptr;
-
 };
 
 // Backwards compatible, <4GB filesystem usage

cores/esp8266/FSImpl.h

@@ -51,6 +51,8 @@ class FileImpl {
     // as the FS is allowed to return either the time of the last write() operation or the
     // time present in the filesystem metadata (often the last time the file was closed)
     virtual time_t getLastWrite() { return 0; } // Default is to not support timestamps
+    // Same for creation time.
+    virtual time_t getCreationTime() { return 0; } // Default is to not support timestamps
 
 protected:
     time_t (*timeCallback)(void) = nullptr;
@@ -75,7 +77,11 @@ class DirImpl {
     virtual FileImplPtr openFile(OpenMode openMode, AccessMode accessMode) = 0;
     virtual const char* fileName() = 0;
     virtual size_t fileSize() = 0;
+    // Return the last written time for a file.  Undefined when called on a writable file
+    // as the FS is allowed to return either the time of the last write() operation or the
+    // time present in the filesystem metadata (often the last time the file was closed)
     virtual time_t fileTime() { return 0; } // By default, FS doesn't report file times
+    virtual time_t fileCreationTime() { return 0; } // By default, FS doesn't report file times
     virtual bool isFile() const = 0;
     virtual bool isDirectory() const = 0;
     virtual bool next() = 0;
@@ -86,11 +92,6 @@ class DirImpl {
     // same name.  The default implementation simply returns time(&null)
     virtual void setTimeCallback(time_t (*cb)(void)) { timeCallback = cb; }
 
-    // Return the last written time for a file.  Undefined when called on a writable file
-    // as the FS is allowed to return either the time of the last write() operation or the
-    // time present in the filesystem metadata (often the last time the file was closed)
-    virtual time_t getLastWrite() { return 0; } // Default is to not support timestamps
-
 protected:
     time_t (*timeCallback)(void) = nullptr;
 };

cores/esp8266/StackThunk.cpp

@@ -111,14 +111,14 @@ uint32_t stack_thunk_get_max_usage()
 /* Print the stack from the first used 16-byte chunk to the top, decodable by the exception decoder */
 void stack_thunk_dump_stack()
 {
-  uint32_t *pos = stack_thunk_top;
-  while (pos < stack_thunk_ptr) {
+  uint32_t *pos = stack_thunk_ptr;
+  while (pos < stack_thunk_top) {
     if ((pos[0] != _stackPaint) || (pos[1] != _stackPaint) || (pos[2] != _stackPaint) || (pos[3] != _stackPaint))
       break;
     pos += 4;
   }
   ets_printf(">>>stack>>>\n");
-  while (pos < stack_thunk_ptr) {
+  while (pos < stack_thunk_top) {
     ets_printf("%08x:  %08x %08x %08x %08x\n", (int32_t)pos, pos[0], pos[1], pos[2], pos[3]);
     pos += 4;
   }

cores/esp8266/core_esp8266_main.cpp

@@ -37,7 +37,6 @@ extern "C" {
 
 #define LOOP_TASK_PRIORITY 1
 #define LOOP_QUEUE_SIZE    1
-#define OPTIMISTIC_YIELD_TIME_US 16000
 
 extern "C" void call_user_start();
 extern void loop();
@@ -58,7 +57,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_micros_at_task_start;
+static uint32_t s_cycles_at_yield_start;
 
 /* For ets_intr_lock_nest / ets_intr_unlock_nest
  * Max nesting seen by SDK so far is 2.
@@ -97,6 +96,7 @@ extern "C" bool can_yield() {
 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();
         run_scheduled_recurrent_functions();
 }
 
@@ -125,14 +125,19 @@ extern "C" void __yield() {
 extern "C" void yield(void) __attribute__ ((weak, alias("__yield")));
 
 extern "C" void optimistic_yield(uint32_t interval_us) {
-    if (can_yield() &&
-        (system_get_time() - s_micros_at_task_start) > interval_us)
+    const uint32_t intvl_cycles = interval_us *
+#if defined(F_CPU)
+        clockCyclesPerMicrosecond();
+#else
+        ESP.getCpuFreqMHz();
+#endif
+    if ((ESP.getCycleCount() - s_cycles_at_yield_start) > intvl_cycles &&
+        can_yield())
     {
         yield();
     }
 }
 
-
 // Replace ets_intr_(un)lock with nestable versions
 extern "C" void IRAM_ATTR ets_intr_lock() {
   if (ets_intr_lock_stack_ptr < ETS_INTR_LOCK_NEST_MAX)
@@ -183,7 +188,7 @@ static void loop_wrapper() {
 
 static void loop_task(os_event_t *events) {
     (void) events;
-    s_micros_at_task_start = system_get_time();
+    s_cycles_at_yield_start = ESP.getCycleCount();
     cont_run(g_pcont, &loop_wrapper);
     if (cont_check(g_pcont) != 0) {
         panic();
@@ -211,7 +216,7 @@ extern void __unhandled_exception(const char *str);
 static void  __unhandled_exception_cpp()
 {
 #ifndef __EXCEPTIONS
-	abort();
+    abort();
 #else
     static bool terminating;
     if (terminating)

cores/esp8266/core_esp8266_noniso.cpp

@@ -22,12 +22,12 @@
 
  */
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <math.h>
+#include <limits>
 #include "stdlib_noniso.h"
 
 extern "C" {
@@ -41,9 +41,79 @@ char* ultoa(unsigned long value, char* result, int base) {
 }
 
 char * dtostrf(double number, signed char width, unsigned char prec, char *s) {
-    char fmt[32];
-    sprintf(fmt, "%%%d.%df", width, prec);
-    sprintf(s, fmt, number);
+    bool negative = false;
+
+    if (isnan(number)) {
+        strcpy(s, "nan");
+        return s;
+    }
+    if (isinf(number)) {
+        strcpy(s, "inf");
+        return s;
+    }
+
+    char* out = s;
+
+    int fillme = width; // how many cells to fill for the integer part
+    if (prec > 0) {
+        fillme -= (prec+1);
+    }
+
+    // Handle negative numbers
+    if (number < 0.0) {
+        negative = true;
+        fillme--;
+        number = -number;
+    }
+
+    // Round correctly so that print(1.999, 2) prints as "2.00"
+    // I optimized out most of the divisions
+    double rounding = 2.0;
+    for (uint8_t i = 0; i < prec; ++i)
+        rounding *= 10.0;
+    rounding = 1.0 / rounding;
+
+    number += rounding;
+
+    // Figure out how big our number really is
+    double tenpow = 1.0;
+    int digitcount = 1;
+    double nextpow;
+    while (number >= (nextpow = (10.0 * tenpow))) {
+        tenpow = nextpow;
+        digitcount++;
+    }
+
+    // minimal compensation for possible lack of precision (#7087 addition)
+    number *= 1 + std::numeric_limits<decltype(number)>::epsilon();
+
+    number /= tenpow;
+    fillme -= digitcount;
+
+    // Pad unused cells with spaces
+    while (fillme-- > 0) {
+        *out++ = ' ';
+    }
+
+    // Handle negative sign
+    if (negative) *out++ = '-';
+
+    // Print the digits, and if necessary, the decimal point
+    digitcount += prec;
+    int8_t digit = 0;
+    while (digitcount-- > 0) {
+        digit = (int8_t)number;
+        if (digit > 9) digit = 9; // insurance
+        *out++ = (char)('0' | digit);
+        if ((digitcount == prec) && (prec > 0)) {
+            *out++ = '.';
+        }
+        number -= digit;
+        number *= 10.0;
+    }
+
+    // make sure the string is terminated
+    *out = 0;
     return s;
 }
 

cores/esp8266/coredecls.h

@@ -13,12 +13,14 @@ extern "C" {
 #include <cont.h> // g_pcont declaration
 
 extern bool timeshift64_is_set;
+extern uint32_t sntp_real_timestamp;
 
 bool can_yield();
 void esp_yield();
 void esp_schedule();
 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);
 
 uint32_t sqrt32 (uint32_t n);
 uint32_t crc32 (const void* data, size_t length, uint32_t crc = 0xffffffff);