Merge remote-tracking branch 'origin/master' into secure-connected-means-read-and-write

Author: mcspr

boards.txt

@@ -186,6 +186,9 @@ void attachInterrupt(uint8_t pin, void (*)(void), int mode);
 void detachInterrupt(uint8_t pin);
 void attachInterruptArg(uint8_t pin, void (*)(void*), void* arg, int mode);
 
+#if FLASH_MAP_SUPPORT
+#include "flash_hal.h"
+#endif
 void preinit(void);
 void setup(void);
 void loop(void);
@@ -279,6 +282,8 @@ inline void configTzTime(const char* tz, const char* server1,
     configTime(tz, server1, server2, server3);
 }
 
+bool getLocalTime(struct tm * info, uint32_t ms = 5000);
+
 // Everything we expect to be implicitly loaded for the sketch
 #include <pgmspace.h>
 

cores/esp8266/Arduino.h

@@ -23,19 +23,18 @@
 #include "coredecls.h"
 #include "Esp.h"
 
-void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
+void EspClass::getHeapStats(uint32_t* hfree, uint32_t* hmax, uint8_t* hfrag)
 {
     // L2 / Euclidean norm of free block sizes.
     // Having getFreeHeap()=sum(hole-size), fragmentation is given by
     // 100 * (1 - sqrt(sum(hole-size²)) / sum(hole-size))
-
     umm_info(NULL, false);
 
     uint32_t free_size = umm_free_heap_size_core(umm_get_current_heap());
     if (hfree)
         *hfree = free_size;
     if (hmax)
-        *hmax = (uint16_t)umm_max_block_size_core(umm_get_current_heap());
+        *hmax = umm_max_block_size_core(umm_get_current_heap());
     if (hfrag) {
       if (free_size) {
         *hfrag = umm_fragmentation_metric_core(umm_get_current_heap());
@@ -45,6 +44,18 @@ void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
     }
 }
 
+void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
+{
+    uint32_t hmax32;
+    getHeapStats(hfree, &hmax32, hfrag);
+    if (hmax) {
+      // With the MMU_EXTERNAL_HEAP option, hmax could overflow for heaps larger
+      // then 64KB. return UINT16_MAX (saturation) for those cases.
+      // Added deprecated attribute and message.
+      *hmax = (hmax32 > UINT16_MAX) ? UINT16_MAX : hmax32;
+    }
+}
+
 uint8_t EspClass::getHeapFragmentation()
 {
   return (uint8_t)umm_fragmentation_metric();

cores/esp8266/Esp-frag.cpp

@@ -26,7 +26,7 @@
 #include "MD5Builder.h"
 #include "umm_malloc/umm_malloc.h"
 #include "cont.h"
-
+#include "flash_hal.h"
 #include "coredecls.h"
 #include "umm_malloc/umm_malloc.h"
 #include <pgmspace.h>
@@ -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()
@@ -224,7 +222,7 @@ uint32_t EspClass::getFreeHeap(void)
     return system_get_free_heap_size();
 }
 
-uint16_t EspClass::getMaxFreeBlockSize(void)
+uint32_t EspClass::getMaxFreeBlockSize(void)
 {
     return umm_max_block_size();
 }
@@ -293,13 +291,17 @@ uint32_t EspClass::getFlashChipRealSize(void)
 
 uint32_t EspClass::getFlashChipSize(void)
 {
+#if FLASH_MAP_SUPPORT
+    return getFlashChipRealSize();
+#else
     uint32_t data;
     uint8_t * bytes = (uint8_t *) &data;
     // read first 4 byte (magic byte + flash config)
     if(spi_flash_read(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
         return magicFlashChipSize((bytes[3] & 0xf0) >> 4);
     }
     return 0;
+#endif
 }
 
 uint32_t EspClass::getFlashChipSpeed(void)
@@ -325,6 +327,7 @@ FlashMode_t EspClass::getFlashChipMode(void)
     return mode;
 }
 
+#if !FLASH_MAP_SUPPORT
 uint32_t EspClass::magicFlashChipSize(uint8_t byte) {
     switch(byte & 0x0F) {
         case 0x0: // 4 Mbit (512KB)
@@ -345,6 +348,7 @@ uint32_t EspClass::magicFlashChipSize(uint8_t byte) {
             return 0;
     }
 }
+#endif
 
 uint32_t EspClass::magicFlashChipSpeed(uint8_t byte) {
     switch(byte & 0x0F) {
@@ -614,14 +618,12 @@ uint32_t EspClass::getSketchSize() {
     return result;
 }
 
-extern "C" uint32_t _FS_start;
-
 uint32_t EspClass::getFreeSketchSpace() {
 
     uint32_t usedSize = getSketchSize();
     // round one sector up
     uint32_t freeSpaceStart = (usedSize + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
-    uint32_t freeSpaceEnd = (uint32_t)&_FS_start - 0x40200000;
+    uint32_t freeSpaceEnd = (uint32_t)FS_start - 0x40200000;
 
 #ifdef DEBUG_SERIAL
     DEBUG_SERIAL.printf("usedSize=%u freeSpaceStart=%u freeSpaceEnd=%u\r\n", usedSize, freeSpaceStart, freeSpaceEnd);

cores/esp8266/Esp.cpp

@@ -114,9 +114,10 @@ class EspClass {
         static uint32_t getChipId();
 
         static uint32_t getFreeHeap();
-        static uint16_t getMaxFreeBlockSize();
+        static uint32_t getMaxFreeBlockSize();
         static uint8_t getHeapFragmentation(); // in %
-        static void getHeapStats(uint32_t* free = nullptr, uint16_t* max = nullptr, uint8_t* frag = nullptr);
+        static void getHeapStats(uint32_t* free = nullptr, uint16_t* max = nullptr, uint8_t* frag = nullptr) __attribute__((deprecated("Use 'uint32_t*' on max, 2nd argument")));
+        static void getHeapStats(uint32_t* free = nullptr, uint32_t* max = nullptr, uint8_t* frag = nullptr);
 
         static uint32_t getFreeContStack();
         static void resetFreeContStack();

cores/esp8266/Esp.h

@@ -118,6 +118,18 @@ class File : public Stream
     time_t getCreationTime();
     void setTimeCallback(time_t (*cb)(void));
 
+    // Stream::send configuration
+
+    bool inputCanTimeout () override {
+        // unavailable data can't become later available
+        return false;
+    }
+
+    bool outputCanTimeout () override {
+        // free space for write can't increase later
+        return false;
+    }
+
 protected:
     FileImplPtr _p;
     time_t (*_timeCallback)(void) = nullptr;

cores/esp8266/FS.h

@@ -0,0 +1,59 @@
+
+// - do not edit - autogenerated by boards.txt.py
+
+#ifndef __FLASH_MAP_H
+#define __FLASH_MAP_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef struct
+{
+    uint32_t eeprom_start;
+    uint32_t fs_start;
+    uint32_t fs_end;
+    uint32_t fs_block_size;
+    uint32_t fs_page_size;
+    uint32_t flash_size_kb;
+} flash_map_s;
+
+/*
+  Following definitions map the above structure, one per line.
+  FLASH_MAP_* is a user choice in sketch:
+      `FLASH_MAP_SETUP_CONFIG(FLASH_MAP_OTA_FS)`
+  Configuration is made at boot with detected flash chip size (last argument 512..16384)
+  Other values are defined from `tools/boards.txt.py`.
+*/
+
+#define FLASH_MAP_OTA_FS \
+    { \
+        { .eeprom_start = 0x402fb000, .fs_start = 0x402eb000, .fs_end = 0x402fb000, .fs_block_size = 0x1000, .fs_page_size = 0x100, .flash_size_kb = 1024 }, \
+        { .eeprom_start = 0x403fb000, .fs_start = 0x403c0000, .fs_end = 0x403fb000, .fs_block_size = 0x1000, .fs_page_size = 0x100, .flash_size_kb = 2048 }, \
+        { .eeprom_start = 0x405fb000, .fs_start = 0x40400000, .fs_end = 0x405fa000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 4096 }, \
+        { .eeprom_start = 0x409fb000, .fs_start = 0x40400000, .fs_end = 0x409fa000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 8192 }, \
+        { .eeprom_start = 0x411fb000, .fs_start = 0x40400000, .fs_end = 0x411fa000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 16384 }, \
+        { .eeprom_start = 0x4027b000, .fs_start = 0x40273000, .fs_end = 0x4027b000, .fs_block_size = 0x1000, .fs_page_size = 0x100, .flash_size_kb = 512 }, \
+    }
+
+#define FLASH_MAP_MAX_FS \
+    { \
+        { .eeprom_start = 0x402fb000, .fs_start = 0x4027b000, .fs_end = 0x402fb000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 1024 }, \
+        { .eeprom_start = 0x403fb000, .fs_start = 0x40300000, .fs_end = 0x403fa000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 2048 }, \
+        { .eeprom_start = 0x405fb000, .fs_start = 0x40300000, .fs_end = 0x405fa000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 4096 }, \
+        { .eeprom_start = 0x409fb000, .fs_start = 0x40300000, .fs_end = 0x409fa000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 8192 }, \
+        { .eeprom_start = 0x411fb000, .fs_start = 0x40300000, .fs_end = 0x411fa000, .fs_block_size = 0x2000, .fs_page_size = 0x100, .flash_size_kb = 16384 }, \
+        { .eeprom_start = 0x4027b000, .fs_start = 0x4025b000, .fs_end = 0x4027b000, .fs_block_size = 0x1000, .fs_page_size = 0x100, .flash_size_kb = 512 }, \
+    }
+
+#define FLASH_MAP_NO_FS \
+    { \
+        { .eeprom_start = 0x402fb000, .fs_start = 0x402fb000, .fs_end = 0x402fb000, .fs_block_size = 0x0, .fs_page_size = 0x0, .flash_size_kb = 1024 }, \
+        { .eeprom_start = 0x403fb000, .fs_start = 0x403fb000, .fs_end = 0x403fb000, .fs_block_size = 0x0, .fs_page_size = 0x0, .flash_size_kb = 2048 }, \
+        { .eeprom_start = 0x405fb000, .fs_start = 0x405fb000, .fs_end = 0x405fb000, .fs_block_size = 0x0, .fs_page_size = 0x0, .flash_size_kb = 4096 }, \
+        { .eeprom_start = 0x409fb000, .fs_start = 0x409fb000, .fs_end = 0x409fb000, .fs_block_size = 0x0, .fs_page_size = 0x0, .flash_size_kb = 8192 }, \
+        { .eeprom_start = 0x411fb000, .fs_start = 0x411fb000, .fs_end = 0x411fb000, .fs_block_size = 0x0, .fs_page_size = 0x0, .flash_size_kb = 16384 }, \
+        { .eeprom_start = 0x4027b000, .fs_start = 0x4027b000, .fs_end = 0x4027b000, .fs_block_size = 0x0, .fs_page_size = 0x0, .flash_size_kb = 512 }, \
+    }
+
+#endif // __FLASH_MAP_H
+

cores/esp8266/FlashMap.h

@@ -143,7 +143,7 @@ unsigned long HardwareSerial::detectBaudrate(time_t timeoutMillis)
         if ((detectedBaudrate = testBaudrate())) {
           break;
         }
-        delay(100);
+        esp_delay(100);
     }
     return detectedBaudrate;
 }

cores/esp8266/HardwareSerial.cpp

@@ -66,6 +66,7 @@ class LwipIntfDev: public LwipIntf, public RawDev
 
     void setDefault();
 
+    // true if interface has a valid IPv4 address
     bool connected()
     {
         return !!ip4_addr_get_u32(ip_2_ip4(&_netif.ip_addr));
@@ -305,8 +306,10 @@ void LwipIntfDev<RawDev>::netif_status_callback()
 {
     if (connected())
     {
-        if (_default)
+        if (_default || (netif_default == nullptr && !ip_addr_isany(&_netif.gw)))
         {
+            // on user request,
+            // or if there is no current default interface, but a gateway is valid
             netif_set_default(&_netif);
         }
         sntp_stop();

cores/esp8266/LwipIntfDev.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>

cores/esp8266/PolledTimeout.h

@@ -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);
 

cores/esp8266/Schedule.cpp

@@ -274,7 +274,7 @@ int Stream::read (uint8_t* buffer, size_t maxLen)
         int c = read();
         if (c == -1)
             break;
-        buffer[nbread++] = read();
+        buffer[nbread++] = c;
     }
     return nbread;
 }

cores/esp8266/Stream.cpp

@@ -61,6 +61,7 @@ class Stream: public Print {
         virtual int peek() = 0;
 
         Stream() {}
+        virtual ~Stream() {}
 
 // parsing methods
 

cores/esp8266/Stream.h

@@ -160,6 +160,7 @@ class StreamConstPtr: public StreamNull
     size_t _peekPointer = 0;
 
 public:
+    StreamConstPtr(const String&& string) = delete; // prevents passing String temporary, use ctor(buffer,size) if you know what you are doing
     StreamConstPtr(const String& string): _buffer(string.c_str()), _size(string.length()), _byteAddressable(true) { }
     StreamConstPtr(const char* buffer, size_t size): _buffer(buffer), _size(size), _byteAddressable(__byteAddressable(buffer)) { }
     StreamConstPtr(const uint8_t* buffer, size_t size): _buffer((const char*)buffer), _size(size), _byteAddressable(__byteAddressable(buffer)) { }

cores/esp8266/StreamDev.h

@@ -341,7 +341,7 @@ Stream& operator << (Stream& out, Stream& stream)
 
 Stream& operator << (Stream& out, const char* text)
 {
-    StreamConstPtr(text).sendAll(out);
+    StreamConstPtr(text, strlen_P(text)).sendAll(out);
     return out;
 }
 

cores/esp8266/StreamSend.cpp

@@ -24,6 +24,8 @@
 #define __STREAMSTRING_H
 
 #include <limits>
+#include <algorithm>
+#include "Stream.h"
 #include "WString.h"
 
 ///////////////////////////////////////////////////////////////