Merge remote-tracking branch 'remotes/esp8266/master'

Links2004 · Links2004 · commit 44af3d5e897e · 2015-12-08T11:33:25.000+01:00
diff --git a/cores/esp8266/Arduino.h b/cores/esp8266/Arduino.h
@@ -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
diff --git a/cores/esp8266/HardwareSerial.cpp b/cores/esp8266/HardwareSerial.cpp
@@ -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;
 }
 
diff --git a/cores/esp8266/abi.cpp b/cores/esp8266/abi.cpp
@@ -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:
diff --git a/cores/esp8266/cbuf.h b/cores/esp8266/cbuf.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;
diff --git a/cores/esp8266/pgmspace.h b/cores/esp8266/pgmspace.h
@@ -78,7 +78,7 @@ int	vsnprintf_P(char *str, size_t strSize, PGM_P formatP, va_list ap) __attribut
 (__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 = reinterpret_cast<const uint32_t*>(reinterpret_cast<const uint8_t*>(__local)-__offset);   \
+    const uint32_t* __addr32 = (const uint32_t*)((const uint8_t*)(__local)-__offset); \
     uint8_t __result = ((*__addr32) >> (__offset * 8));                        \
     __result;                                                                  \
 }))
@@ -87,7 +87,7 @@ int	vsnprintf_P(char *str, size_t strSize, PGM_P formatP, va_list ap) __attribut
 (__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 = reinterpret_cast<const uint32_t*>(reinterpret_cast<const uint8_t*>(__local) - __offset); \
+    const uint32_t* __addr32 = (const uint32_t*)((const uint8_t*)(__local) - __offset); \
     uint16_t __result = ((*__addr32) >> (__offset * 8));                       \
     __result;                                                                  \
 }))	
diff --git a/libraries/ESP8266WiFi/examples/WiFiClient/WiFiClient.ino b/libraries/ESP8266WiFi/examples/WiFiClient/WiFiClient.ino
@@ -71,7 +71,14 @@ void loop() {
   client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                "Host: " + host + "\r\n" + 
                "Connection: close\r\n\r\n");
-  delay(10);
+  int timeout = millis() + 5000;
+  while (client.available() == 0) {
+    if (timeout - millis() < 0) {
+      Serial.println(">>> Client Timeout !");
+      client.stop();
+      return;
+    }
+  }
   
   // Read all the lines of the reply from server and print them to Serial
   while(client.available()){
diff --git a/libraries/ESP8266WiFi/src/include/UdpContext.h b/libraries/ESP8266WiFi/src/include/UdpContext.h
@@ -1,9 +1,9 @@
-/* 
+/*
   UdpContext.h - UDP connection handling on top of lwIP
 
   Copyright (c) 2014 Ivan Grokhotkov. 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
@@ -206,10 +206,10 @@ class UdpContext
         size_t max_size = _rx_buf->len - _rx_buf_offset;
         size = (size < max_size) ? size : max_size;
         DEBUGV(":urd %d, %d, %d\r\n", size, _rx_buf->len, _rx_buf_offset);
-        
-        os_memcpy(dst, reinterpret_cast<char*>(_rx_buf->payload) + _rx_buf_offset, size);        
+
+        memcpy(dst, reinterpret_cast<char*>(_rx_buf->payload) + _rx_buf_offset, size);
         _consume(size);
-        
+
         return size;
     }
 
@@ -236,7 +236,7 @@ class UdpContext
         {
             _reserve(_tx_buf_offset + size);
         }
-        
+
         size_t left_to_copy = size;
         while(left_to_copy)
         {
@@ -249,7 +249,7 @@ class UdpContext
                 continue;
             }
             size_t will_copy = (left_to_copy < free_cur) ? left_to_copy : free_cur;
-            os_memcpy(reinterpret_cast<char*>(_tx_buf_cur->payload) + used_cur, data, will_copy);
+            memcpy(reinterpret_cast<char*>(_tx_buf_cur->payload) + used_cur, data, will_copy);
             _tx_buf_offset += will_copy;
             left_to_copy -= will_copy;
             data += will_copy;
@@ -259,18 +259,20 @@ class UdpContext
 
     void send(ip_addr_t* addr = 0, uint16_t port = 0)
     {
-        size_t orig_size = _tx_buf_head->tot_len;
-
         size_t data_size = _tx_buf_offset;
-        size_t size_adjustment = orig_size - data_size;
-        for (pbuf* p = _tx_buf_head; p; p = p->next)
-        {
-            p->tot_len -= size_adjustment;
-            if (!p->next)
-            {
-                p->len = p->tot_len;
-            }
+        pbuf* tx_copy = pbuf_alloc(PBUF_TRANSPORT, data_size, PBUF_RAM);
+        uint8_t* dst = reinterpret_cast<uint8_t*>(tx_copy->payload);
+        for (pbuf* p = _tx_buf_head; p; p = p->next) {
+            size_t will_copy = (data_size < p->len) ? data_size : p->len;
+            memcpy(dst, p->payload, will_copy);
+            dst += will_copy;
+            data_size -= will_copy;
         }
+        pbuf_free(_tx_buf_head);
+        _tx_buf_head = 0;
+        _tx_buf_cur = 0;
+        _tx_buf_offset = 0;
+
 
         if (!addr) {
             addr = &_dest_addr;
@@ -282,30 +284,16 @@ class UdpContext
             _pcb->ttl = _multicast_ttl;
         }
 
-        udp_sendto(_pcb, _tx_buf_head, addr, port);
-
+        udp_sendto(_pcb, tx_copy, addr, port);
         _pcb->ttl = old_ttl;
-
-        for (pbuf* p = _tx_buf_head; p; p = p->next)
-        {
-            p->tot_len += size_adjustment;
-            if (!p->next)
-            {
-                p->len = p->tot_len;
-            }
-        }
-
-        pbuf_free(_tx_buf_head);
-        _tx_buf_head = 0;
-        _tx_buf_cur = 0;
-        _tx_buf_offset = 0;
+        pbuf_free(tx_copy);
     }
 
 private:
 
     void _reserve(size_t size)
     {
-        const size_t pbuf_unit_size = 512;
+        const size_t pbuf_unit_size = 128;
         if (!_tx_buf_head)
         {
             _tx_buf_head = pbuf_alloc(PBUF_TRANSPORT, pbuf_unit_size, PBUF_RAM);
@@ -357,7 +345,7 @@ class UdpContext
     }
 
 
-    static void _s_recv(void *arg, 
+    static void _s_recv(void *arg,
             udp_pcb *upcb, pbuf *p,
             ip_addr_t *addr, u16_t port)
     {

Original file line number	Diff line number	Diff line change
`@@ -617,18 +617,15 @@ size_t HardwareSerial::write(uint8_t c) {`
`617`	`617`	`size_t room = uart_get_tx_fifo_room(_uart);`
`618`	`618`	`if(room > 0 && _tx_buffer->empty()) {`
`619`	`619`	`uart_transmit_char(_uart, c);`
`620`		`- if(room < 10) {`
`621`		`- uart_arm_tx_interrupt(_uart);`
`622`		`- }`
`623`	`620`	`return 1;`
`624`	`621`	`}`
`625`	`622`
`626`	`623`	`while(_tx_buffer->room() == 0) {`
`627`	`624`	`yield();`
`628`		`- uart_arm_tx_interrupt(_uart);`
`629`	`625`	`}`
`630`	`626`
`631`	`627`	`_tx_buffer->write(c);`
	`628`	`+ uart_arm_tx_interrupt(_uart);`
`632`	`629`	`return 1;`
`633`	`630`	`}`
`634`	`631`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,10 @@ void __throw_length_error(char const*) {`
`68`	`68`	`void __throw_bad_alloc() {`
`69`	`69`	`panic();`
`70`	`70`	`}`
	`71`	`+`
	`72`	`+void __throw_logic_error(const char* str) {`
	`73`	`+ panic();`
	`74`	`+}`
`71`	`75`	`}`
`72`	`76`
`73`	`77`	`// TODO: rebuild windows toolchain to make this unnecessary:`
Original file line number	Diff line number	Diff line change
`@@ -42,9 +42,6 @@ class cbuf {`
`42`	`42`	`if(_end >= _begin) {`
`43`	`43`	`return _size - (_end - _begin) - 1;`
`44`	`44`	`}`
`45`		`- if(_begin == _end) {`
`46`		`- return _size;`
`47`		`- }`
`48`	`45`	`return _begin - _end - 1;`
`49`	`46`	`}`
`50`	`47`
`@@ -62,7 +59,7 @@ class cbuf {`
`62`	`59`	`if(getSize() == 0) return -1;`
`63`	`60`
`64`	`61`	`char result = *_begin;`
`65`		`- if(++_begin == _bufend) _begin = _buf;`
	`62`	`+ _begin = wrap_if_bufend(_begin + 1);`
`66`	`63`	`return static_cast<int>(result);`
`67`	`64`	`}`
`68`	`65`
`@@ -78,16 +75,15 @@ class cbuf {`
`78`	`75`	`dst += top_size;`
`79`	`76`	`}`
`80`	`77`	`memcpy(dst, _begin, size_to_read);`
`81`		`- _begin += size_to_read;`
`82`		`- if(_begin == _bufend) _begin = _buf;`
	`78`	`+ _begin = wrap_if_bufend(_begin + size_to_read);`
`83`	`79`	`return size_read;`
`84`	`80`	`}`
`85`	`81`
`86`	`82`	`size_t write(char c) {`
`87`	`83`	`if(room() == 0) return 0;`
`88`	`84`
`89`	`85`	`*_end = c;`
`90`		`- if(++_end == _bufend) _end = _buf;`
	`86`	`+ _end = wrap_if_bufend(_end + 1);`
`91`	`87`	`return 1;`
`92`	`88`	`}`
`93`	`89`
`@@ -103,8 +99,7 @@ class cbuf {`
`103`	`99`	`src += top_size;`
`104`	`100`	`}`
`105`	`101`	`memcpy(_end, src, size_to_write);`
`106`		`- _end += size_to_write;`
`107`		`- if(_end == _bufend) _end = _buf;`
	`102`	`+ _end = wrap_if_bufend(_end + size_to_write);`
`108`	`103`	`return size_written;`
`109`	`104`	`}`
`110`	`105`
`@@ -114,6 +109,10 @@ class cbuf {`
`114`	`109`	`}`
`115`	`110`
`116`	`111`	`private:`
	`112`	`+ inline char* wrap_if_bufend(char* ptr) {`
	`113`	`+ return (ptr == _bufend) ? _buf : ptr;`
	`114`	`+ }`
	`115`	`+`
`117`	`116`	`size_t _size;`
`118`	`117`	`char* _buf;`
`119`	`118`	`char* _bufend;`