Merge branch 'master' into i2s_input

Author: earlephilhower

boards.txt

@@ -1795,6 +1795,7 @@ nodemcuv2.menu.UploadSpeed.921600.upload.speed=921600
 ##############################################################
 modwifi.name=Olimex MOD-WIFI-ESP8266(-DEV)
 modwifi.build.board=MOD_WIFI_ESP8266
+modwifi.build.variant=modwifi
 modwifi.upload.tool=esptool
 modwifi.upload.maximum_data_size=81920
 modwifi.upload.wait_for_upload_port=true
@@ -1803,7 +1804,6 @@ modwifi.serial.disableDTR=true
 modwifi.serial.disableRTS=true
 modwifi.build.mcu=esp8266
 modwifi.build.core=esp8266
-modwifi.build.variant=generic
 modwifi.build.spiffs_pagesize=256
 modwifi.build.debug_port=
 modwifi.build.debug_level=

cores/esp8266/HardwareSerial.cpp

@@ -55,10 +55,8 @@ void HardwareSerial::end()
         uart_set_debug(UART_NO);
     }
 
-    if (_uart) {
-        uart_uninit(_uart);
-        _uart = NULL;
-    }
+    uart_uninit(_uart);
+    _uart = NULL;
 }
 
 size_t HardwareSerial::setRxBufferSize(size_t size){
@@ -70,30 +68,6 @@ size_t HardwareSerial::setRxBufferSize(size_t size){
     return _rx_size;
 }
 
-void HardwareSerial::swap(uint8_t tx_pin)
-{
-    if(!_uart) {
-        return;
-    }
-    uart_swap(_uart, tx_pin);
-}
-
-void HardwareSerial::set_tx(uint8_t tx_pin)
-{
-    if(!_uart) {
-        return;
-    }
-    uart_set_tx(_uart, tx_pin);
-}
-
-void HardwareSerial::pins(uint8_t tx, uint8_t rx)
-{
-    if(!_uart) {
-        return;
-    }
-    uart_set_pins(_uart, tx, rx);
-}
-
 void HardwareSerial::setDebugOutput(bool en)
 {
     if(!_uart) {
@@ -113,16 +87,6 @@ void HardwareSerial::setDebugOutput(bool en)
     }
 }
 
-bool HardwareSerial::isTxEnabled(void)
-{
-    return _uart && uart_tx_enabled(_uart);
-}
-
-bool HardwareSerial::isRxEnabled(void)
-{
-    return _uart && uart_rx_enabled(_uart);
-}
-
 int HardwareSerial::available(void)
 {
     int result = static_cast<int>(uart_rx_available(_uart));
@@ -132,27 +96,6 @@ int HardwareSerial::available(void)
     return result;
 }
 
-int HardwareSerial::peek(void)
-{
-    // this may return -1, but that's okay
-    return uart_peek_char(_uart);
-}
-
-int HardwareSerial::read(void)
-{
-    // this may return -1, but that's okay
-    return uart_read_char(_uart);
-}
-
-int HardwareSerial::availableForWrite(void)
-{
-    if(!_uart || !uart_tx_enabled(_uart)) {
-        return 0;
-    }
-
-    return static_cast<int>(uart_tx_free(_uart));
-}
-
 void HardwareSerial::flush()
 {
     if(!_uart || !uart_tx_enabled(_uart)) {
@@ -165,33 +108,9 @@ void HardwareSerial::flush()
     delayMicroseconds(11000000 / uart_get_baudrate(_uart) + 1);
 }
 
-size_t HardwareSerial::write(uint8_t c)
-{
-    if(!_uart || !uart_tx_enabled(_uart)) {
-        return 0;
-    }
-
-    uart_write_char(_uart, c);
-    return 1;
-}
-
-int HardwareSerial::baudRate(void)
-{
-    // Null pointer on _uart is checked by SDK
-    return uart_get_baudrate(_uart);
-}
-
-
-HardwareSerial::operator bool() const
-{
-    return _uart != 0;
-}
-
-
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
 HardwareSerial Serial(UART0);
 #endif
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL1)
 HardwareSerial Serial1(UART1);
 #endif
-

cores/esp8266/HardwareSerial.h

@@ -93,26 +93,50 @@ class HardwareSerial: public Stream
     {
         swap(1);
     }
-    void swap(uint8_t tx_pin);    //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
+    void swap(uint8_t tx_pin)    //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
+    {
+        uart_swap(_uart, tx_pin);
+    }
 
     /*
      * Toggle between use of GPIO1 and GPIO2 as TX on UART 0.
      * Note: UART 1 can't be used if GPIO2 is used with UART 0!
      */
-    void set_tx(uint8_t tx_pin);
+    void set_tx(uint8_t tx_pin)
+    {
+        uart_set_tx(_uart, tx_pin);
+    }
 
     /*
      * UART 0 possible options are (1, 3), (2, 3) or (15, 13)
      * UART 1 allows only TX on 2 if UART 0 is not (2, 3)
      */
-    void pins(uint8_t tx, uint8_t rx);
+    void pins(uint8_t tx, uint8_t rx)
+    {
+        uart_set_pins(_uart, tx, rx);
+    }
 
     int available(void) override;
-    int peek(void) override;
-    int read(void) override;
-    int availableForWrite(void);
+
+    int peek(void) override
+    {
+        // this may return -1, but that's okay
+        return uart_peek_char(_uart);
+    }
+    int read(void) override
+    {
+        // this may return -1, but that's okay
+        return uart_read_char(_uart);
+    }
+    int availableForWrite(void)
+    {
+        return static_cast<int>(uart_tx_free(_uart));
+    }
     void flush(void) override;
-    size_t write(uint8_t) override;
+    size_t write(uint8_t c) override
+    {
+        return uart_write_char(_uart, c);
+    }
     inline size_t write(unsigned long n)
     {
         return write((uint8_t) n);
@@ -129,13 +153,36 @@ class HardwareSerial: public Stream
     {
         return write((uint8_t) n);
     }
-    using Print::write; // pull in write(str) and write(buf, size) from Print
-    operator bool() const;
-
+    size_t write(const uint8_t *buffer, size_t size)
+    {
+        return uart_write(_uart, (const char*)buffer, size);
+    }
+    size_t write(const char *buffer)
+    {
+        return buffer? uart_write(_uart, buffer, strlen(buffer)): 0;
+    }
+    operator bool() const
+    {
+        return _uart != 0;
+    }
     void setDebugOutput(bool);
-    bool isTxEnabled(void);
-    bool isRxEnabled(void);
-    int  baudRate(void);
+    bool isTxEnabled(void)
+    {
+        return uart_tx_enabled(_uart);
+    }
+    bool isRxEnabled(void)
+    {
+        return uart_rx_enabled(_uart);
+    }
+    int baudRate(void)
+    {
+        return uart_get_baudrate(_uart);
+    }
+
+    bool hasOverrun(void)
+    {
+        return uart_has_overrun(_uart);
+    }
 
 protected:
     int _uart_nr;

cores/esp8266/Print.cpp

@@ -33,6 +33,16 @@
 
 /* default implementation: may be overridden */
 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 bool once = false;
+    if (!once) {
+        once = true;
+        os_printf_plus(not_the_best_way);
+    }
+#endif
+
     size_t n = 0;
     while (size--) {
         size_t ret = write(*buffer++);

cores/esp8266/Updater.cpp

@@ -86,7 +86,7 @@ bool UpdaterClass::begin(size_t size, int command) {
     //size of the update rounded to a sector
     uint32_t roundedSize = (size + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
     //address where we will start writing the update
-    updateStartAddress = updateEndAddress - roundedSize;
+    updateStartAddress = (updateEndAddress > roundedSize)? (updateEndAddress - roundedSize) : 0;
 
 #ifdef DEBUG_UPDATER
         DEBUG_UPDATER.printf("[begin] roundedSize:       0x%08X (%d)\n", roundedSize, roundedSize);
@@ -390,4 +390,4 @@ void UpdaterClass::printError(Print &out){
   }
 }
 
-UpdaterClass Update;
+UpdaterClass Update;