Merge remote-tracking branch 'refs/remotes/upstream/master'

Author: hallard

boards.txt

@@ -219,14 +219,12 @@ void loop(void);
 void yield(void);
 void optimistic_yield(uint32_t interval_us);
 
-// Get the bit location within the hardware port of the given virtual pin.
-// This comes from the pins_*.c file for the active board configuration.
 #define digitalPinToPort(pin)       (0)
 #define digitalPinToBitMask(pin)    (1UL << (pin))
 #define digitalPinToTimer(pin)      (0)
-#define portOutputRegister(port)    ((volatile uint32_t*) GPO)
-#define portInputRegister(port)     ((volatile uint32_t*) GPI)
-#define portModeRegister(port)      ((volatile uint32_t*) GPE)
+#define portOutputRegister(port)    ((volatile uint32_t*) &GPO)
+#define portInputRegister(port)     ((volatile uint32_t*) &GPI)
+#define portModeRegister(port)      ((volatile uint32_t*) &GPE)
 
 #define NOT_A_PIN -1
 #define NOT_A_PORT -1

cores/esp8266/Arduino.h

@@ -617,18 +617,15 @@ size_t HardwareSerial::write(uint8_t c) {
     size_t room = uart_get_tx_fifo_room(_uart);
     if(room > 0 && _tx_buffer->empty()) {
         uart_transmit_char(_uart, c);
-        if(room < 10) {
-            uart_arm_tx_interrupt(_uart);
-        }
         return 1;
     }
 
     while(_tx_buffer->room() == 0) {
         yield();
-        uart_arm_tx_interrupt(_uart);
     }
 
     _tx_buffer->write(c);
+    uart_arm_tx_interrupt(_uart);
     return 1;
 }
 

cores/esp8266/HardwareSerial.cpp

@@ -38,14 +38,14 @@ void UpdaterClass::_reset() {
 bool UpdaterClass::begin(size_t size, int command) {
   if(_size > 0){
 #ifdef DEBUG_UPDATER
-    DEBUG_UPDATER.println("already running");
+    DEBUG_UPDATER.println("[begin] already running");
 #endif
     return false;
   }
 
 #ifdef DEBUG_UPDATER
   if (command == U_SPIFFS) {
-    DEBUG_UPDATER.println("Update SPIFFS.");
+    DEBUG_UPDATER.println("[begin] Update SPIFFS.");
   }
 #endif
 
@@ -73,6 +73,12 @@ bool UpdaterClass::begin(size_t size, int command) {
     //address where we will start writing the update
     updateStartAddress = updateEndAddress - roundedSize;
 
+#ifdef DEBUG_UPDATER
+        DEBUG_UPDATER.printf("[begin] roundedSize:       0x%08X (%d)\n", roundedSize, roundedSize);
+        DEBUG_UPDATER.printf("[begin] updateEndAddress:  0x%08X (%d)\n", updateEndAddress, updateEndAddress);
+        DEBUG_UPDATER.printf("[begin] currentSketchSize: 0x%08X (%d)\n", currentSketchSize, currentSketchSize);
+#endif
+
     //make sure that the size of both sketches is less than the total space (updateEndAddress)
     if(updateStartAddress < currentSketchSize) {
       _error = UPDATE_ERROR_SPACE;
@@ -88,7 +94,7 @@ bool UpdaterClass::begin(size_t size, int command) {
   else {
     // unknown command
 #ifdef DEBUG_UPDATER
-    DEBUG_UPDATER.println("Unknown update command.");
+    DEBUG_UPDATER.println("[begin] Unknown update command.");
 #endif
     return false;
   }
@@ -100,6 +106,12 @@ bool UpdaterClass::begin(size_t size, int command) {
   _buffer = new uint8_t[FLASH_SECTOR_SIZE];
   _command = command;
 
+#ifdef DEBUG_UPDATER
+  DEBUG_UPDATER.printf("[begin] _startAddress:     0x%08X (%d)\n", _startAddress, _startAddress);
+  DEBUG_UPDATER.printf("[begin] _currentAddress:   0x%08X (%d)\n", _currentAddress, _currentAddress);
+  DEBUG_UPDATER.printf("[begin] _size:             0x%08X (%d)\n", _size, _size);
+#endif
+
   _md5.begin();
   return true;
 }
@@ -168,9 +180,14 @@ bool UpdaterClass::end(bool evenIfRemaining){
 }
 
 bool UpdaterClass::_writeBuffer(){
+
+  yield();
+  bool result = ESP.flashEraseSector(_currentAddress/FLASH_SECTOR_SIZE);
+  yield();
+  if (result) {
+      result = ESP.flashWrite(_currentAddress, (uint32_t*) _buffer, _bufferLen);
+  }
   yield();
-  bool result = ESP.flashEraseSector(_currentAddress/FLASH_SECTOR_SIZE) &&
-                ESP.flashWrite(_currentAddress, (uint32_t*) _buffer, _bufferLen);
 
   if (!result) {
     _error = UPDATE_ERROR_WRITE;
@@ -217,29 +234,32 @@ size_t UpdaterClass::write(uint8_t *data, size_t len) {
 }
 
 size_t UpdaterClass::writeStream(Stream &data) {
-  size_t written = 0;
-  size_t toRead = 0;
-  if(hasError() || !isRunning())
-    return 0;
-
-  while(remaining()) {
-    toRead = FLASH_SECTOR_SIZE - _bufferLen;
-    toRead = data.readBytes(_buffer + _bufferLen, toRead);
-    if(toRead == 0){ //Timeout
-      _error = UPDATE_ERROR_STREAM;
-      _currentAddress = (_startAddress + _size);
+    size_t written = 0;
+    size_t toRead = 0;
+    if(hasError() || !isRunning())
+        return 0;
+
+    while(remaining()) {
+        toRead = data.readBytes(_buffer + _bufferLen,  (FLASH_SECTOR_SIZE - _bufferLen));
+        if(toRead == 0) { //Timeout
+            delay(100);
+            toRead = data.readBytes(_buffer + _bufferLen, (FLASH_SECTOR_SIZE - _bufferLen));
+            if(toRead == 0) { //Timeout
+                _error = UPDATE_ERROR_STREAM;
+                _currentAddress = (_startAddress + _size);
 #ifdef DEBUG_UPDATER
-      printError(DEBUG_UPDATER);
+                printError(DEBUG_UPDATER);
 #endif
-      return written;
+            }
+            return written;
+        }
+        _bufferLen += toRead;
+        if((_bufferLen == remaining() || _bufferLen == FLASH_SECTOR_SIZE) && !_writeBuffer())
+            return written;
+        written += toRead;
+        yield();
     }
-    _bufferLen += toRead;
-    if((_bufferLen == remaining() || _bufferLen == FLASH_SECTOR_SIZE) && !_writeBuffer())
-      return written;
-    written += toRead;
-    yield();
-  }
-  return written;
+    return written;
 }
 
 void UpdaterClass::printError(Stream &out){

cores/esp8266/Updater.cpp

@@ -26,7 +26,7 @@ class UpdaterClass {
       Call this to check the space needed for the update
       Will return false if there is not enough space
     */
-    bool begin(size_t size, int = U_FLASH);
+    bool begin(size_t size, int command = U_FLASH);
 
     /*
       Writes a buffer to the flash and increments the address

cores/esp8266/Updater.h

@@ -121,6 +121,7 @@ ICACHE_FLASH_ATTR String::~String() {
     if(buffer) {
         free(buffer);
     }
+    init();
 }
 
 // /*********************************************/
@@ -136,8 +137,7 @@ inline void String::init(void) {
 void ICACHE_FLASH_ATTR String::invalidate(void) {
     if(buffer)
         free(buffer);
-    buffer = NULL;
-    capacity = len = 0;
+    init();
 }
 
 unsigned char ICACHE_FLASH_ATTR String::reserve(unsigned int size) {

cores/esp8266/WString.cpp

@@ -76,7 +76,11 @@ class String {
         // invalid string (i.e., "if (s)" will be true afterwards)
         unsigned char reserve(unsigned int size);
         inline unsigned int length(void) const {
-            return len;
+            if(buffer) {
+                return len;
+            } else {
+                return 0;
+            }
         }
 
         // creates a copy of the assigned value.  if the value is null or

cores/esp8266/WString.h

@@ -68,6 +68,10 @@ void __throw_length_error(char const*) {
 void __throw_bad_alloc() {
     panic();
 }
+
+void __throw_logic_error(const char* str) {
+    panic();
+}
 }
 
 // TODO: rebuild windows toolchain to make this unnecessary:

cores/esp8266/abi.cpp

@@ -0,0 +1,63 @@
+/**
+ * base64.cpp
+ *
+ * Created on: 09.12.2015
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the ESP8266 core for Arduino.
+ *
+ * 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"
+extern "C" {
+#include "libb64/cdecode.h"
+#include "libb64/cencode.h"
+}
+#include "base64.h"
+
+/**
+ * convert input data to base64
+ * @param data uint8_t *
+ * @param length size_t
+ * @return String
+ */
+String base64::encode(uint8_t * data, size_t length) {
+    // base64 needs more size then the source data
+    size_t size = ((length * 1.6f) + 1);
+    char * buffer = (char *) malloc(size);
+    if(buffer) {
+        base64_encodestate _state;
+        base64_init_encodestate(&_state);
+        int len = base64_encode_block((const char *) &data[0], length, &buffer[0], &_state);
+        len = base64_encode_blockend((buffer + len), &_state);
+
+        String base64 = String(buffer);
+        free(buffer);
+        return base64;
+    }
+    return String("-FAIL-");
+}
+
+/**
+ * convert input data to base64
+ * @param text String
+ * @return String
+ */
+String base64::encode(String text) {
+    return base64::encode((uint8_t *) text.c_str(), text.length());
+}
+

cores/esp8266/base64.cpp

@@ -0,0 +1,36 @@
+/**
+ * base64.h
+ *
+ * Created on: 09.12.2015
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the ESP8266 core for Arduino.
+ *
+ * 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
+ *
+ */
+
+#ifndef CORE_BASE64_H_
+#define CORE_BASE64_H_
+
+class base64 {
+    public:
+        static String encode(uint8_t * data, size_t length);
+        static String encode(String text);
+    private:
+};
+
+
+#endif /* CORE_BASE64_H_ */

cores/esp8266/base64.h

@@ -42,9 +42,6 @@ class cbuf {
             if(_end >= _begin) {
                 return _size - (_end - _begin) - 1;
             }
-            if(_begin == _end) {
-                return _size;
-            }
             return _begin - _end - 1;
         }
 
@@ -62,7 +59,7 @@ class cbuf {
             if(getSize() == 0) return -1;
 
             char result = *_begin;
-            if(++_begin == _bufend) _begin = _buf;
+            _begin = wrap_if_bufend(_begin + 1);
             return static_cast<int>(result);
         }
 
@@ -78,16 +75,15 @@ class cbuf {
                 dst += top_size;
             }
             memcpy(dst, _begin, size_to_read);
-            _begin += size_to_read;
-            if(_begin == _bufend) _begin = _buf;
+            _begin = wrap_if_bufend(_begin + size_to_read);
             return size_read;
         }
 
         size_t write(char c) {
             if(room() == 0) return 0;
 
             *_end = c;
-            if(++_end == _bufend) _end = _buf;
+            _end = wrap_if_bufend(_end + 1);
             return 1;
         }
 
@@ -103,8 +99,7 @@ class cbuf {
                 src += top_size;
             }
             memcpy(_end, src, size_to_write);
-            _end += size_to_write;
-            if(_end == _bufend) _end = _buf;
+            _end = wrap_if_bufend(_end + size_to_write);
             return size_written;
         }
 
@@ -114,6 +109,10 @@ class cbuf {
         }
 
     private:
+        inline char* wrap_if_bufend(char* ptr) {
+            return (ptr == _bufend) ? _buf : ptr;
+        }
+
         size_t _size;
         char* _buf;
         char* _bufend;