Merge branch 'master' into xmc_flash

Author: ChocolateFrogsNuts

boards.txt

@@ -0,0 +1,84 @@
+#ifndef __CALLBACKLIST_H__
+#define __CALLBACKLIST_H__
+
+
+/*
+ CallBackList, An implemention for handling callback execution
+
+ Copyright (c) 2019 Herman Reintke. All rights reserved.
+ This file is part of the esp8266 core for Arduino environment.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <Arduino.h>
+#include <memory>
+#include <list>
+#include <utility>
+
+namespace experimental
+{
+namespace CBListImplentation
+{
+
+template<class cbFunctionT>
+class CallBackList
+{
+public:
+	CallBackList (){};
+
+    struct CallBackInfo
+    {
+		CallBackInfo(cbFunctionT f) : cbFunction(f, true){};
+		CallBackInfo(cbFunctionT f, bool ar) : cbFunction(f), _allowRemove(ar) {};
+		cbFunctionT  cbFunction;
+    	bool _allowRemove = true;
+    	bool allowRemove()
+    	{
+    		return _allowRemove;
+    	}
+     };
+    using CallBackHandler = std::shared_ptr<CallBackInfo> ;
+    std::list<CallBackHandler> callBackEventList;
+
+    CallBackHandler add(cbFunctionT af, bool ad = true) {
+    	CallBackHandler handler = std::make_shared<CallBackInfo>(CallBackInfo(af,ad));
+    	callBackEventList.emplace_back(handler);
+    	return handler;
+    }
+
+    void remove(CallBackHandler& dh) {
+    	callBackEventList.remove(dh);
+	}
+
+    template<typename... Args>
+    void execute(Args... params) {
+        for(auto it = std::begin(callBackEventList); it != std::end(callBackEventList); ) {
+        	CallBackHandler &handler = *it;
+            if (handler->allowRemove() && handler.unique()) {
+                it = callBackEventList.erase(it);
+            }
+            else {
+             	handler->cbFunction(params...);
+                ++it;
+            }
+        }
+    }
+};
+
+} //CBListImplementation
+}//experimental
+
+#endif // __CALLBACKLIST_H__

cores/esp8266/CallBackList.h

@@ -245,6 +245,13 @@ class FS
 
 } // namespace fs
 
+extern "C"
+{
+void close_all_fs(void);
+void littlefs_request_end(void);
+void spiffs_request_end(void);
+}
+
 #ifndef FS_NO_GLOBALS
 using fs::FS;
 using fs::File;

cores/esp8266/FS.h

@@ -0,0 +1,33 @@
+/*
+ *  no-op implementations
+ *  used/linked when no strong implementation already exists elsewhere
+ */
+
+#include <FS.h>
+
+extern "C"
+{
+
+void close_all_fs(void)
+{
+    littlefs_request_end();
+    spiffs_request_end();
+}
+
+// default weak definitions
+// they are overriden in their respective real implementation
+// hint: https://github.com/esp8266/Arduino/pull/6699#issuecomment-549085382
+
+void littlefs_request_end(void) __attribute__((weak));
+void littlefs_request_end(void)
+{
+    //ets_printf("debug: noop: littlefs_request_end\n");
+}
+
+void spiffs_request_end(void) __attribute__((weak));
+void spiffs_request_end(void)
+{
+    //ets_printf("debug: noop: spiffs_request_end\n");
+}
+
+}

cores/esp8266/FSnoop.cpp

@@ -91,6 +91,9 @@ void preloop_update_frequency() {
 #endif
 }
 
+extern "C" bool can_yield() {
+  return cont_can_yield(g_pcont);
+}
 
 static inline void esp_yield_within_cont() __attribute__((always_inline));
 static void esp_yield_within_cont() {
@@ -99,7 +102,7 @@ static void esp_yield_within_cont() {
 }
 
 extern "C" void esp_yield() {
-    if (cont_can_yield(g_pcont)) {
+    if (can_yield()) {
         esp_yield_within_cont();
     }
 }
@@ -110,7 +113,7 @@ extern "C" void esp_schedule() {
 }
 
 extern "C" void __yield() {
-    if (cont_can_yield(g_pcont)) {
+    if (can_yield()) {
         esp_schedule();
         esp_yield_within_cont();
     }
@@ -122,7 +125,7 @@ extern "C" void __yield() {
 extern "C" void yield(void) __attribute__ ((weak, alias("__yield")));
 
 extern "C" void optimistic_yield(uint32_t interval_us) {
-    if (cont_can_yield(g_pcont) &&
+    if (can_yield() &&
         (system_get_time() - s_micros_at_task_start) > interval_us)
     {
         yield();

cores/esp8266/core_esp8266_main.cpp

@@ -14,6 +14,7 @@ extern "C" {
 
 extern bool timeshift64_is_set;
 
+bool can_yield();
 void esp_yield();
 void esp_schedule();
 void tune_timeshift64 (uint64_t now_us);

cores/esp8266/coredecls.h

@@ -141,6 +141,14 @@ FS SPIFFS = FS(FSImplPtr(new spiffs_impl::SPIFFSImpl(
                              FS_PHYS_PAGE,
                              FS_PHYS_BLOCK,
                              SPIFFS_MAX_OPEN_FILES)));
+
+extern "C" void spiffs_request_end(void)
+{
+    // override default weak function
+    //ets_printf("debug: not weak spiffs end\n");
+    SPIFFS.end();
+}
+
 #endif // ARDUINO
 #endif // !CORE_MOCK
 

cores/esp8266/spiffs_api.cpp

@@ -80,6 +80,11 @@ class SPIFFSImpl : public FSImpl
         memset(&_fs, 0, sizeof(_fs));
     }
 
+    ~SPIFFSImpl()
+    {
+        end();
+    }
+
     FileImplPtr open(const char* path, OpenMode openMode, AccessMode accessMode) override;
     bool exists(const char* path) override;
     DirImplPtr openDir(const char* path) override;

cores/esp8266/spiffs_api.h

@@ -5,7 +5,6 @@
 #include <WiFiUdp.h>
 #include <flash_hal.h>
 #include <FS.h>
-#include <LittleFS.h>
 #include "StreamString.h"
 #include "ESP8266HTTPUpdateServer.h"
 
@@ -94,8 +93,7 @@ void ESP8266HTTPUpdateServerTemplate<ServerType>::setup(ESP8266WebServerTemplate
           Serial.printf("Update: %s\n", upload.filename.c_str());
         if (upload.name == "filesystem") {
           size_t fsSize = ((size_t) &_FS_end - (size_t) &_FS_start);
-          SPIFFS.end();
-          LittleFS.end();
+          close_all_fs();
           if (!Update.begin(fsSize, U_FS)){//start with max available size
             if (_serial_output) Update.printError(Serial);
           }