Merge branch 'master' into master

Author: igrr

README.md

@@ -106,7 +106,7 @@ If you can not find the answers above, you can also try [ESP8266 Community Forum
 
 For minor fixes of code and documentation, go ahead and submit a pull request.
 
-Check out the list of issues which are easy to fix — [easy issues for 2.2.0](https://github.com/esp8266/Arduino/issues?q=is%3Aopen+is%3Aissue+milestone%3A2.2.0+label%3A%22level%3A+easy%22). Working on them is a great way to move the project forward.
+Check out the list of issues which are easy to fix — [easy issues for 2.4.0](https://github.com/esp8266/Arduino/issues?q=is%3Aopen+is%3Aissue+milestone%3A2.4.0+label%3A%22level%3A+easy%22). Working on them is a great way to move the project forward.
 
 Larger changes (rewriting parts of existing code from scratch, adding new functions to the core, adding new libraries) should generally be discussed [in the chat](https://gitter.im/esp8266/Arduino) first.
 

boards.txt

@@ -1,5 +1,7 @@
+menu.BoardModel=Model
 menu.UploadSpeed=Upload Speed
 menu.CpuFrequency=CPU Frequency
+menu.CrystalFreq=Crystal Frequency
 menu.FlashSize=Flash Size
 menu.FlashMode=Flash Mode
 menu.FlashFreq=Flash Frequency
@@ -1892,3 +1894,121 @@ coredev.menu.DebugLevel.OTA2____=OTA + Updater
 coredev.menu.DebugLevel.OTA2____.build.debug_level=-DDEBUG_ESP_OTA -DDEBUG_ESP_UPDATER
 coredev.menu.DebugLevel.all_____=All
 coredev.menu.DebugLevel.all_____.build.debug_level=-DDEBUG_ESP_CORE -DDEBUG_ESP_SSL -DDEBUG_ESP_WIFI -DDEBUG_ESP_HTTP_CLIENT -DDEBUG_ESP_HTTP_UPDATE -DDEBUG_ESP_HTTP_SERVER -DDEBUG_ESP_UPDATER -DDEBUG_ESP_OTA -DDEBUG_TLS_MEM
+
+############ Arduino boards with Esp8266 ############
+
+arduino-esp8266.name=Arduino
+
+arduino-esp8266.upload.tool=esptool
+arduino-esp8266.upload.speed=9600
+arduino-esp8266.upload.resetmethod=ck
+arduino-esp8266.upload.maximum_size=1044464
+arduino-esp8266.upload.maximum_data_size=81920
+arduino-esp8266.upload.wait_for_upload_port=true
+arduino-esp8266.serial.disableDTR=true
+arduino-esp8266.serial.disableRTS=true
+
+arduino-esp8266.build.mcu=esp8266
+arduino-esp8266.build.f_cpu=80000000L
+#arduino-esp8266.build.f_crystal=40000000
+arduino-esp8266.build.core=esp8266
+arduino-esp8266.build.flash_mode=qio
+arduino-esp8266.build.flash_size=4M
+arduino-esp8266.build.flash_freq=40
+arduino-esp8266.build.debug_port=
+arduino-esp8266.build.debug_level=
+arduino-esp8266.build.board=ESP8266_ARDUINO
+
+arduino-esp8266.menu.BoardModel.starottodeved=Star OTTO
+arduino-esp8266.menu.BoardModel.starottodeved.build.board=ESP8266_ARDUINO_STAR_OTTO
+arduino-esp8266.menu.BoardModel.starottodeved.build.variant=arduino_uart
+arduino-esp8266.menu.BoardModel.starottodeved.build.extra_flags=-DF_CRYSTAL=40000000
+
+arduino-esp8266.menu.BoardModel.primo=Primo
+arduino-esp8266.menu.BoardModel.primo.build.board=ESP8266_ARDUINO_PRIMO
+arduino-esp8266.menu.BoardModel.primo.build.variant=arduino_spi
+arduino-esp8266.menu.BoardModel.primo.build.extra_flags=-DF_CRYSTAL=40000000
+
+arduino-esp8266.menu.BoardModel.unowifideved=Uno WiFi
+arduino-esp8266.menu.BoardModel.unowifideved.build.board=ESP8266_ARDUINO_UNOWIFI
+arduino-esp8266.menu.BoardModel.unowifideved.build.variant=arduino_uart
+arduino-esp8266.menu.BoardModel.unowifideved.build.extra_flags=-DF_CRYSTAL=40000000
+
+arduino-esp8266.menu.UploadSpeed.9600=9600
+arduino-esp8266.menu.UploadSpeed.9600.upload.speed=9600
+arduino-esp8266.menu.UploadSpeed.19200=19200
+arduino-esp8266.menu.UploadSpeed.19200.upload.speed=19200
+arduino-esp8266.menu.UploadSpeed.57600=57600
+arduino-esp8266.menu.UploadSpeed.57600.upload.speed=57600
+arduino-esp8266.menu.UploadSpeed.115200=115200
+arduino-esp8266.menu.UploadSpeed.115200.upload.speed=115200
+arduino-esp8266.menu.UploadSpeed.230400=230400
+arduino-esp8266.menu.UploadSpeed.230400.upload.speed=230400
+arduino-esp8266.menu.UploadSpeed.460800=460800
+arduino-esp8266.menu.UploadSpeed.460800.upload.speed=460800
+
+arduino-esp8266.menu.FlashSize.4M1M=4M (1M SPIFFS)
+arduino-esp8266.menu.FlashSize.4M1M.build.flash_size=4M
+arduino-esp8266.menu.FlashSize.4M1M.build.flash_ld=eagle.flash.4m1m.ld
+arduino-esp8266.menu.FlashSize.4M1M.build.spiffs_start=0x300000
+arduino-esp8266.menu.FlashSize.4M1M.build.spiffs_end=0x3FB000
+arduino-esp8266.menu.FlashSize.4M1M.build.spiffs_blocksize=8192
+arduino-esp8266.menu.FlashSize.4M1M.build.spiffs_pagesize=256
+
+arduino-esp8266.menu.FlashSize.4M3M=4M (3M SPIFFS)
+arduino-esp8266.menu.FlashSize.4M3M.build.flash_size=4M
+arduino-esp8266.menu.FlashSize.4M3M.build.flash_ld=eagle.flash.4m.ld
+arduino-esp8266.menu.FlashSize.4M3M.build.spiffs_start=0x100000
+arduino-esp8266.menu.FlashSize.4M3M.build.spiffs_end=0x3FB000
+arduino-esp8266.menu.FlashSize.4M3M.build.spiffs_blocksize=8192
+arduino-esp8266.menu.FlashSize.4M3M.build.spiffs_pagesize=256
+
+##############################################################
+
+gen4iod.name=4D Systems gen4 IoD Range
+
+gen4iod.upload.tool=esptool
+gen4iod.upload.speed=921600
+gen4iod.upload.resetmethod=nodemcu
+gen4iod.upload.maximum_size=434160
+gen4iod.upload.maximum_data_size=81920
+gen4iod.upload.wait_for_upload_port=true
+gen4iod.serial.disableDTR=true
+gen4iod.serial.disableRTS=true
+
+gen4iod.build.mcu=esp8266
+gen4iod.build.f_cpu=160000000L
+gen4iod.build.board=GEN4_IOD
+gen4iod.build.core=esp8266
+gen4iod.build.variant=generic
+gen4iod.build.flash_mode=qio
+# flash chip: AT25SF041 (512 kbyte, 4Mbit)
+gen4iod.build.flash_size=512K
+gen4iod.build.flash_ld=eagle.flash.512k0.ld
+gen4iod.build.flash_freq=80
+gen4iod.build.debug_port=
+gen4iod.build.debug_level=
+
+gen4iod.menu.CpuFrequency.160=160 MHz
+gen4iod.menu.CpuFrequency.160.build.f_cpu=160000000L
+gen4iod.menu.CpuFrequency.80=80 MHz
+gen4iod.menu.CpuFrequency.80.build.f_cpu=80000000L
+
+gen4iod.menu.UploadSpeed.115200=115200
+gen4iod.menu.UploadSpeed.115200.upload.speed=115200
+gen4iod.menu.UploadSpeed.9600=9600
+gen4iod.menu.UploadSpeed.9600.upload.speed=9600
+gen4iod.menu.UploadSpeed.57600=57600
+gen4iod.menu.UploadSpeed.57600.upload.speed=57600
+gen4iod.menu.UploadSpeed.256000.windows=256000
+gen4iod.menu.UploadSpeed.256000.upload.speed=256000
+gen4iod.menu.UploadSpeed.230400.linux=230400
+gen4iod.menu.UploadSpeed.230400.macosx=230400
+gen4iod.menu.UploadSpeed.230400.upload.speed=230400
+gen4iod.menu.UploadSpeed.460800.linux=460800
+gen4iod.menu.UploadSpeed.460800.macosx=460800
+gen4iod.menu.UploadSpeed.460800.upload.speed=460800
+gen4iod.menu.UploadSpeed.512000.windows=512000
+gen4iod.menu.UploadSpeed.512000.upload.speed=512000
+gen4iod.menu.UploadSpeed.921600=921600
+gen4iod.menu.UploadSpeed.921600.upload.speed=921600

cores/esp8266/base64.cpp

@@ -35,13 +35,20 @@ extern "C" {
  * @param length size_t
  * @return String
  */
-String base64::encode(uint8_t * data, size_t length) {
+String base64::encode(uint8_t * data, size_t length, bool doNewLines) {
     // 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);
+        if(doNewLines)
+        {
+            base64_init_encodestate(&_state);
+        }
+        else 
+        {
+            base64_init_encodestate_nonewlines(&_state);
+        }
         int len = base64_encode_block((const char *) &data[0], length, &buffer[0], &_state);
         len = base64_encode_blockend((buffer + len), &_state);
 
@@ -57,7 +64,7 @@ String base64::encode(uint8_t * data, size_t length) {
  * @param text String
  * @return String
  */
-String base64::encode(String text) {
-    return base64::encode((uint8_t *) text.c_str(), text.length());
+String base64::encode(String text, bool doNewLines) {
+    return base64::encode((uint8_t *) text.c_str(), text.length(), doNewLines);
 }
 

cores/esp8266/base64.h

@@ -27,8 +27,11 @@
 
 class base64 {
     public:
-        static String encode(uint8_t * data, size_t length);
-        static String encode(String text);
+        // NOTE: The default behaviour of backend (lib64)
+        // is to add a newline every 72 (encoded) characters output.
+        // This may 'break' longer uris and json variables
+        static String encode(uint8_t * data, size_t length, bool doNewLines = true);
+        static String encode(String text, bool doNewLines = true);
     private:
 };
 

cores/esp8266/core_esp8266_i2s.c

@@ -146,6 +146,10 @@ void ICACHE_FLASH_ATTR i2s_slc_end(){
   SLCIE = 0;
   SLCTXL &= ~(SLCTXLAM << SLCTXLA); // clear TX descriptor address
   SLCRXL &= ~(SLCRXLAM << SLCRXLA); // clear RX descriptor address
+
+  for (int x = 0; x<SLC_BUF_CNT; x++) {
+	  free(i2s_slc_buf_pntr[x]);
+  }
 }
 
 //This routine pushes a single, 32-bit sample to the I2S buffers. Call this at (on average) 
@@ -238,8 +242,16 @@ void ICACHE_FLASH_ATTR i2s_begin(){
 }
 
 void ICACHE_FLASH_ATTR i2s_end(){
-  i2s_slc_end();
+  I2SC &= ~I2STXS;
+
+  //Reset I2S
+  I2SC &= ~(I2SRST);
+  I2SC |= I2SRST;
+  I2SC &= ~(I2SRST);
+
   pinMode(2, INPUT);
   pinMode(3, INPUT);
   pinMode(15, INPUT);
+
+  i2s_slc_end();
 }

cores/esp8266/core_esp8266_phy.c

@@ -88,7 +88,11 @@ static const uint8_t ICACHE_FLASH_ATTR phy_init_data[128] =
     // 0: 40MHz
     // 1: 26MHz
     // 2: 24MHz
-    [48] = 1,
+    #if F_CRYSTAL == 40000000
+      [48] = 0,
+    #else
+      [48] = 1,
+    #endif
 
 
 
@@ -312,4 +316,3 @@ void user_rf_pre_init()
 
 
 void ICACHE_RAM_ATTR user_spi_flash_dio_to_qio_pre_init() {}
-

cores/esp8266/esp8266_peri.h

@@ -586,6 +586,10 @@ extern uint8_t esp8266_gpioToFn[16];
 #define SPIE2IHEN 0x3 //SPI_INT_HOLD_ENA
 #define SPIE2IHEN_S 0 //SPI_INT_HOLD_ENA_S
 
+//SPI PIN (SPIxP)
+#define SPIPCS2DIS (1 << 2)
+#define SPIPCS1DIS (1 << 1)
+#define SPIPCS0DIS (1 << 0)
 
 //SLC (DMA) Registers
 #define SLCC0     ESP8266_REG(0xB00) //SLC_CONF0

cores/esp8266/libb64/cencode.c

@@ -13,6 +13,13 @@ void base64_init_encodestate(base64_encodestate* state_in){
   state_in->step = step_A;
   state_in->result = 0;
   state_in->stepcount = 0;
+  state_in->stepsnewline = CHARS_PER_LINE;
+}
+
+
+void base64_init_encodestate_nonewlines(base64_encodestate* state_in){
+  base64_init_encodestate(state_in);
+  state_in->stepsnewline = -1;
 }
 
 char base64_encode_value(char value_in){
@@ -65,7 +72,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
       *codechar++ = base64_encode_value(result);
 
       ++(state_in->stepcount);
-      if (state_in->stepcount == CHARS_PER_LINE/4){
+      if ((state_in->stepcount == CHARS_PER_LINE/4) && (state_in->stepsnewline > 0)){
         *codechar++ = '\n';
         state_in->stepcount = 0;
       }

cores/esp8266/libb64/cencode.h

@@ -22,9 +22,11 @@ typedef struct {
   base64_encodestep step;
   char result;
   int stepcount;
+  int stepsnewline;
 } base64_encodestate;
 
 void base64_init_encodestate(base64_encodestate* state_in);
+void base64_init_encodestate_nonewlines(base64_encodestate* state_in);
 
 char base64_encode_value(char value_in);
 

cores/esp8266/pgmspace.h

@@ -87,23 +87,31 @@ int	vsnprintf_P(char *str, size_t strSize, PGM_P formatP, va_list ap) __attribut
 //     w1,     w0
 
 #ifdef __ets__
-#define pgm_read_byte(addr) 		                                           \
-(__extension__({                                                               \
-    PGM_P __local = (PGM_P)(addr);  /* isolate varible for macro expansion */         \
-    ptrdiff_t __offset = ((uint32_t)__local & 0x00000003); /* byte aligned mask */            \
-    const uint32_t* __addr32 = (const uint32_t*)((const uint8_t*)(__local)-__offset); \
-    uint8_t __result = ((*__addr32) >> (__offset * 8));                        \
-    __result;                                                                  \
-}))
-
-#define pgm_read_word(addr) 		                                           \
-(__extension__({                                                               \
-    PGM_P __local = (PGM_P)(addr); /* isolate varible for macro expansion */          \
-    ptrdiff_t __offset = ((uint32_t)__local & 0x00000002);   /* word aligned mask */          \
-    const uint32_t* __addr32 = (const uint32_t*)((const uint8_t*)(__local) - __offset); \
-    uint16_t __result = ((*__addr32) >> (__offset * 8));                       \
-    __result;                                                                  \
-}))	
+
+#define pgm_read_with_offset(addr, res) \
+  asm("extui    %0, %1, 0, 2\n"     /* Extract offset within word (in bytes) */ \
+      "sub      %1, %1, %0\n"       /* Subtract offset from addr, yielding an aligned address */ \
+      "l32i.n   %1, %1, 0x0\n"      /* Load word from aligned address */ \
+      "slli     %0, %0, 3\n"        /* Mulitiply offset by 8, yielding an offset in bits */ \
+      "ssr      %0\n"               /* Prepare to shift by offset (in bits) */ \
+      "srl      %0, %1\n"           /* Shift right; now the requested byte is the first one */ \
+      :"=r"(res), "=r"(addr) \
+      :"1"(addr) \
+      :);
+
+static inline uint8_t pgm_read_byte(const void* addr) {
+  register uint32_t res;
+  pgm_read_with_offset(addr, res);
+  return (uint8_t) res;     /* This masks the lower byte from the returned word */
+}
+
+/* Although this says "word", it's actually 16 bit, i.e. half word on Xtensa */
+static inline uint16_t pgm_read_word(const void* addr) {
+  register uint32_t res;
+  pgm_read_with_offset(addr, res);
+  return (uint16_t) res;    /* This masks the lower half-word from the returned word */
+}
+
 #else //__ets__
 #define pgm_read_byte(addr)     (*reinterpret_cast<const uint8_t*>(addr))
 #define pgm_read_word(addr)     (*reinterpret_cast<const uint16_t*>(addr))