Merge branch 'master' into feature/HTTPClient_WiFiClient_parameter

Author: Jeroen88

.travis.yml

@@ -50,6 +50,8 @@ deploy:
     api_key:
       secure: A4FBmqyhlzy33oPeZVolg2Q/A3ZcJ3WnRQqQJ3NAPy+qGM5xcboOYtwcLL9vKaHZGfUB7lUP9QVZFGou1Wrmo9DnPvAoe3+XvCaDRGzVMxeIpu7UStbBD4Knbh98tlbMvZCXYRlT4VcusI9bMLK6UWw4sMdPislBh2FEfglTiag=
     file_glob: true
+    tag_name: $TRAVIS_TAG
+    target_commitish: $TRAVIS_COMMIT
     file:
       - package/versions/$TRAVIS_TAG/esp8266-$TRAVIS_TAG.zip
       - package/versions/$TRAVIS_TAG/package_esp8266com_index.json

cores/esp8266/Esp.cpp

@@ -114,6 +114,13 @@ void EspClass::deepSleep(uint64_t time_us, WakeMode mode)
     esp_yield();
 }
 
+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();
+}
+
 //this calculation was taken verbatim from the SDK api reference for SDK 2.1.0.
 //Note: system_rtc_clock_cali_proc() returns a uint32_t, even though system_deep_sleep() takes a uint64_t.
 uint64_t EspClass::deepSleepMax()

cores/esp8266/Esp.h

@@ -93,6 +93,7 @@ class EspClass {
         void wdtFeed();
 
         void deepSleep(uint64_t time_us, RFMode mode = RF_DEFAULT);
+        void deepSleepInstant(uint64_t time_us, RFMode mode = RF_DEFAULT);
         uint64_t deepSleepMax();
 
         bool rtcUserMemoryRead(uint32_t offset, uint32_t *data, size_t size);

cores/esp8266/Print.cpp

@@ -35,7 +35,7 @@
 size_t Print::write(const uint8_t *buffer, size_t size) {
 
 #ifdef DEBUG_ESP_CORE
-    static char not_the_best_way [] ICACHE_RODATA_ATTR STORE_ATTR = "Print::write(data,len) should be overridden for better efficiency\r\n";
+    static char not_the_best_way [] PROGMEM STORE_ATTR = "Print::write(data,len) should be overridden for better efficiency\r\n";
     static bool once = false;
     if (!once) {
         once = true;

cores/esp8266/core_esp8266_phy.c

@@ -301,10 +301,7 @@ void user_rf_pre_init()
     // *((volatile uint32_t*) 0x60000710) = 0;
     spoof_init_data = false;
     volatile uint32_t* rtc_reg = (volatile uint32_t*) 0x60001000;
-    if((rtc_reg[24] >> 16) > 4) {
-        rtc_reg[24] &= 0xFFFF;
-        rtc_reg[30] = 0;
-    }
+    rtc_reg[30] = 0;
 
     system_set_os_print(0);
     int rf_mode = __get_rf_mode();

cores/esp8266/core_esp8266_postmortem.c

@@ -166,7 +166,7 @@ void __wrap_system_restart_local() {
 
     // Use cap-X formatting to ensure the standard EspExceptionDecoder doesn't match the address
     if (umm_last_fail_alloc_addr) {
-      ets_printf("\nlast failed alloc call: %08X(%d)\n", (uint32_t)umm_last_fail_alloc_addr, umm_last_fail_alloc_size);
+      ets_printf_P("\nlast failed alloc call: %08X(%d)\n", (uint32_t)umm_last_fail_alloc_addr, umm_last_fail_alloc_size);
     }
 
     custom_crash_callback( &rst_info, sp + offset, stack_end );

cores/esp8266/debug.h

@@ -23,7 +23,7 @@ extern "C" {
 #endif
 
 void __panic_func(const char* file, int line, const char* func) __attribute__((noreturn));
-#define panic() __panic_func(__FILE__, __LINE__, __func__)
+#define panic() __panic_func(PSTR(__FILE__), __LINE__, __func__)
 
 #ifdef __cplusplus
 }

cores/esp8266/heap.c

@@ -84,9 +84,9 @@ void* ICACHE_RAM_ATTR pvPortZalloc(size_t size, const char* file, int line)
 #undef calloc
 #undef realloc
 
-static const char oom_fmt[]   ICACHE_RODATA_ATTR STORE_ATTR = ":oom(%d)@?\n";
-static const char oom_fmt_1[] ICACHE_RODATA_ATTR STORE_ATTR = ":oom(%d)@";
-static const char oom_fmt_2[] ICACHE_RODATA_ATTR STORE_ATTR = ":%d\n";
+static const char oom_fmt[]   PROGMEM STORE_ATTR = ":oom(%d)@?\n";
+static const char oom_fmt_1[] PROGMEM STORE_ATTR = ":oom(%d)@";
+static const char oom_fmt_2[] PROGMEM STORE_ATTR = ":%d\n";
 
 void* malloc (size_t s)
 {

cores/esp8266/pgmspace.h

@@ -10,7 +10,19 @@
 #include "ets_sys.h"
 #include "osapi.h"
 
-#define PROGMEM     ICACHE_RODATA_ATTR
+// Since __section__ is supposed to be only use for global variables,
+// there could be conflicts when a static/inlined function has them in the
+// same file as a non-static PROGMEM object.
+// Ref: https://gcc.gnu.org/onlinedocs/gcc-3.2/gcc/Variable-Attributes.html
+// Place each progmem object into its own named section, avoiding conflicts
+
+// The following two macros cause a parameter to be enclosed in quotes
+// by the preopressor (i.e. for concatenating ints to strings)
+#define __STRINGIZE_NX(A) #A
+#define __STRINGIZE(A) __STRINGIZE_NX(A)
+
+#define PROGMEM      __attribute__((section( "\".irom.text." __FILE__ "." __STRINGIZE(__LINE__) "."  __STRINGIZE(__COUNTER__) "\"")))
+
 #define PGM_P  		const char *
 #define PGM_VOID_P  const void *
 #define PSTR(s) (__extension__({static const char __c[] PROGMEM = (s); &__c[0];}))

cores/esp8266/uart.c

@@ -41,12 +41,13 @@
  *
  */
 #include "Arduino.h"
+#include <pgmspace.h>
 #include "uart.h"
 #include "esp8266_peri.h"
 #include "user_interface.h"
 #include "uart_register.h"
 
-const char overrun_str [] ICACHE_RODATA_ATTR STORE_ATTR = "uart input full!\r\n";
+const char overrun_str [] PROGMEM STORE_ATTR = "uart input full!\r\n";
 static int s_uart_debug_nr = UART0;
 
 

cores/esp8266/umm_malloc/umm_malloc_cfg.h

@@ -178,7 +178,8 @@ extern char _heap_start;
 // this must be outside from "#ifndef _UMM_MALLOC_CFG_H"
 // because Arduino.h's <cstdlib> does #undef *alloc
 // Arduino.h recall us to redefine them
-#define malloc(s) ({ static const char mem_debug_file[] ICACHE_RODATA_ATTR STORE_ATTR = __FILE__; malloc_loc(s, mem_debug_file, __LINE__); })
-#define calloc(n,s) ({ static const char mem_debug_file[] ICACHE_RODATA_ATTR STORE_ATTR = __FILE__; calloc_loc(n, s, mem_debug_file, __LINE__); })
-#define realloc(p,s) ({ static const char mem_debug_file[] ICACHE_RODATA_ATTR STORE_ATTR = __FILE__; realloc_loc(p, s, mem_debug_file, __LINE__); })
+#include <pgmspace.h>
+#define malloc(s) ({ static const char mem_debug_file[] PROGMEM STORE_ATTR = __FILE__; malloc_loc(s, mem_debug_file, __LINE__); })
+#define calloc(n,s) ({ static const char mem_debug_file[] PROGMEM STORE_ATTR = __FILE__; calloc_loc(n, s, mem_debug_file, __LINE__); })
+#define realloc(p,s) ({ static const char mem_debug_file[] PROGMEM STORE_ATTR = __FILE__; realloc_loc(p, s, mem_debug_file, __LINE__); })
 #endif /* DEBUG_ESP_OOM */

doc/libraries.rst

@@ -73,6 +73,8 @@ Some ESP-specific APIs related to deep sleep, RTC and flash memories are availab
 
 ``ESP.deepSleep(microseconds, mode)`` will put the chip into deep sleep. ``mode`` is one of ``WAKE_RF_DEFAULT``, ``WAKE_RFCAL``, ``WAKE_NO_RFCAL``, ``WAKE_RF_DISABLED``. (GPIO16 needs to be tied to RST to wake from deepSleep.) The chip can sleep for at most ``ESP.deepSleepMax()`` microseconds.
 
+``ESP.deepSleepInstant(microseconds, mode)`` works similarly to ``ESP.deepSleep`` but  sleeps instantly without waiting for WiFi to shutdown.
+
 ``ESP.rtcUserMemoryWrite(offset, &data, sizeof(data))`` and ``ESP.rtcUserMemoryRead(offset, &data, sizeof(data))`` allow data to be stored in and retrieved from the RTC user memory of the chip respectively. Total size of RTC user memory is 512 bytes, so ``offset + sizeof(data)`` shouldn't exceed 512. Data should be 4-byte aligned. The stored data can be retained between deep sleep cycles. However, the data might be lost after power cycling the chip.
 
 ``ESP.restart()`` restarts the CPU.

doc/reference.rst

@@ -42,7 +42,12 @@ either to read voltage at ADC pin, or to read module supply voltage
 (VCC).
 
 To read external voltage applied to ADC pin, use ``analogRead(A0)``.
-Input voltage range is 0 — 1.0V.
+Input voltage range of bare ESP8266 is 0 — 1.0V, however some many 
+boards may implement voltage dividers. To be on the safe side, <1.0V 
+can be tested. If e.g. 0.5V delivers values around ~512, then maximum 
+voltage is very likely to be 1.0V and 3.3V may harm the ESP8266. 
+However values around ~150 indicates that the maximum voltage is 
+likely to be 3.3V.
 
 To read VCC voltage, use ``ESP.getVcc()`` and ADC pin must be kept
 unconnected. Additionally, the following line has to be added to the

libraries/DNSServer/examples/CaptivePortalAdvanced/CaptivePortalAdvanced.ino

@@ -53,7 +53,7 @@ void setup() {
   delay(1000);
   Serial.begin(9600);
   Serial.println();
-  Serial.print("Configuring access point...");
+  Serial.println("Configuring access point...");
   /* You can remove the password parameter if you want the AP to be open. */
   WiFi.softAPConfig(apIP, apIP, netMsk);
   WiFi.softAP(softAP_ssid, softAP_password);

libraries/DNSServer/examples/CaptivePortalAdvanced/handleHttp.ino

@@ -27,7 +27,7 @@ void handleRoot() {
 /** Redirect to captive portal if we got a request for another domain. Return true in that case so the page handler do not try to handle the request again. */
 boolean captivePortal() {
   if (!isIp(server.hostHeader()) && server.hostHeader() != (String(myHostname) + ".local")) {
-    Serial.print("Request redirected to captive portal");
+    Serial.println("Request redirected to captive portal");
     server.sendHeader("Location", String("http://") + toStringIp(server.client().localIP()), true);
     server.send(302, "text/plain", "");   // Empty content inhibits Content-length header so we have to close the socket ourselves.
     server.client().stop(); // Stop is needed because we sent no content length

libraries/ESP8266WebServer/src/detail/mimetable.cpp

@@ -5,7 +5,7 @@ namespace mime
 {
 
 // Table of extension->MIME strings stored in PROGMEM, needs to be global due to GCC section typing rules
-const Entry mimeTable[maxType] ICACHE_RODATA_ATTR = 
+const Entry mimeTable[maxType] PROGMEM = 
 {
     { ".html", "text/html" },
     { ".htm", "text/html" },

libraries/ESP8266WiFi/examples/WiFiHTTPSServer/make-self-signed-cert.sh

@@ -4,11 +4,11 @@
 # Replace your-name-here with somethine appropriate before running and use
 # the generated .H files in your code as follows:
 #
-#      static const uint8_t rsakey[]  ICACHE_RODATA_ATTR = {
+#      static const uint8_t rsakey[] PROGMEM = {
 #        #include "key.h"
 #      };
 #
-#      static const uint8_t x509[] ICACHE_RODATA_ATTR = {
+#      static const uint8_t x509[] PROGMEM = {
 #        #include "x509.h"
 #      };
 #

libraries/Ticker/Ticker.cpp

@@ -65,9 +65,23 @@ void Ticker::detach()
 	os_timer_disarm(_timer);
 	delete _timer;
 	_timer = nullptr;
+	_callback_function = nullptr;
 }
 
 bool Ticker::active()
 {
 	return (bool)_timer;
 }
+
+void Ticker::_static_callback(void* arg)
+{
+	Ticker* _this = (Ticker*)arg;
+	if (_this == nullptr)
+	{
+		return;
+	}
+	if (_this->_callback_function)
+	{
+		_this->_callback_function();
+	}
+}

libraries/Ticker/Ticker.h

@@ -25,6 +25,8 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <functional>
+#include <Schedule.h>
 
 extern "C" {
 	typedef struct _ETSTIMER_ ETSTimer;
@@ -37,15 +39,28 @@ class Ticker
 	~Ticker();
 	typedef void (*callback_t)(void);
 	typedef void (*callback_with_arg_t)(void*);
+	typedef std::function<void(void)> callback_function_t;
 
-	void attach(float seconds, callback_t callback)
+	void attach_scheduled(float seconds, callback_function_t callback)
 	{
-		_attach_ms(seconds * 1000, true, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		attach(seconds,std::bind(schedule_function, callback));
 	}
 
-	void attach_ms(uint32_t milliseconds, callback_t callback)
+	void attach(float seconds, callback_function_t callback)
 	{
-		_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		_callback_function = callback;
+		attach(seconds, _static_callback, (void*)this);
+	}
+
+	void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
+	{
+		attach_ms(milliseconds, std::bind(schedule_function, callback));
+	}
+
+	void attach_ms(uint32_t milliseconds, callback_function_t callback)
+	{
+		_callback_function = callback;
+		attach_ms(milliseconds, _static_callback, (void*)this);
 	}
 
 	template<typename TArg>
@@ -67,14 +82,26 @@ class Ticker
 		_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), arg32);
 	}
 
-	void once(float seconds, callback_t callback)
+	void once_scheduled(float seconds, callback_function_t callback)
 	{
-		_attach_ms(seconds * 1000, false, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		once(seconds, std::bind(schedule_function, callback));
 	}
 
-	void once_ms(uint32_t milliseconds, callback_t callback)
+	void once(float seconds, callback_function_t callback)
 	{
-		_attach_ms(milliseconds, false, reinterpret_cast<callback_with_arg_t>(callback), 0);	
+		_callback_function = callback;
+		once(seconds, _static_callback, (void*)this);
+	}
+
+	void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
+	{
+		once_ms(milliseconds, std::bind(schedule_function, callback));
+	}
+
+	void once_ms(uint32_t milliseconds, callback_function_t callback)
+	{
+		_callback_function = callback;
+		once_ms(milliseconds, _static_callback, (void*)this);
 	}
 
 	template<typename TArg>
@@ -98,10 +125,11 @@ class Ticker
 
 protected:	
 	void _attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t callback, uint32_t arg);
-
+	static void _static_callback (void* arg);
 
 protected:
 	ETSTimer* _timer;
+	callback_function_t _callback_function = nullptr;
 };
 
 

libraries/Ticker/examples/TickerFunctional/TickerFunctional.ino

@@ -0,0 +1,64 @@
+#include "Arduino.h"
+#include "Ticker.h"
+
+#define LED1  2
+#define LED2  4
+#define LED3  12
+#define LED4  14
+#define LED5  15
+
+
+class ExampleClass {
+  public:
+    ExampleClass(int pin, int duration) : _pin(pin), _duration(duration) {
+      pinMode(_pin, OUTPUT);
+      _myTicker.attach_ms(_duration, std::bind(&ExampleClass::classBlink, this));
+    }
+    ~ExampleClass() {};
+
+    int _pin, _duration;
+    Ticker _myTicker;
+
+    void classBlink() {
+      digitalWrite(_pin, !digitalRead(_pin));
+    }
+};
+
+void staticBlink() {
+  digitalWrite(LED2, !digitalRead(LED2));
+}
+
+void scheduledBlink() {
+  digitalWrite(LED3, !digitalRead(LED2));
+}
+
+void parameterBlink(int p) {
+  digitalWrite(p, !digitalRead(p));
+}
+
+Ticker staticTicker;
+Ticker scheduledTicker;
+Ticker parameterTicker;
+Ticker lambdaTicker;
+
+ExampleClass example(LED1, 100);
+
+
+void setup() {
+  pinMode(LED2, OUTPUT);
+  staticTicker.attach_ms(100, staticBlink);
+
+  pinMode(LED3, OUTPUT);
+  scheduledTicker.attach_ms_scheduled(100, scheduledBlink);
+
+  pinMode(LED4, OUTPUT);
+  parameterTicker.attach_ms(100, std::bind(parameterBlink, LED4));
+
+  pinMode(LED5, OUTPUT);
+  lambdaTicker.attach_ms(100, []() {
+    digitalWrite(LED5, !digitalRead(LED5));
+  });
+}
+
+void loop() {
+}