various fixes

esp8266 · earlephilhower · Mar 15, 2021 · Dec 15, 2019 · Dec 16, 2019 · Dec 16, 2019
commit 630b6b60c423ab7a15acc3882b212b6736c46ff7
diff --git a/cores/esp8266/Print.h b/cores/esp8266/Print.h
@@ -111,7 +111,7 @@ class Print {
 
         // by default write timeout is possible (outgoing data from network,serial..)
         // (children can override to false (like String))
-        virtual bool outputTimeoutPossible () const { return true; }
+        virtual bool outputTimeoutPossible () { return true; }
 };
 
 #endif
diff --git a/cores/esp8266/Stream.h b/cores/esp8266/Stream.h
@@ -148,7 +148,7 @@ class Stream: public Print {
         // by default read timeout is possible (incoming data from network,serial..)
         // children can override to false (like String::)
         // (outputTimeoutPossible() is defined in Print::)
-        virtual bool inputTimeoutPossible () const { return true; }
+        virtual bool inputTimeoutPossible () { return true; }
 
         //////////////////// extensions: Stream streams
         // Stream::to()

diff --git a/cores/esp8266/StreamDev.cpp b/cores/esp8266/StreamDev.cpp
@@ -135,6 +135,7 @@ size_t Stream::to (Print* to,
             if (w == 0 && !to->outputTimeoutPossible())
                 // no more data can be written, ever
                 break;
+
             w = std::min(w, avr);
             w = std::min(w, (decltype(w))64); //XXX FIXME 64 is a constant
             if (w)
@@ -164,9 +165,9 @@ size_t Stream::to (Print* to,
 
     if (getWriteError() == STREAMTO_SUCCESS)
     {
-        if (timedOut)
+        if (timeout && timedOut)
             setWriteError(STREAMTO_TIMED_OUT);
-        else if ((ssize_t)written != len)
+        else if (len > 0 && (ssize_t)written != len)
             // This is happening when source cannot timeout (ex: a String)
             // but has not enough data, or a dest has closed or cannot
             // timeout but is too small (String, buffer...)

diff --git a/cores/esp8266/StreamDev.h b/cores/esp8266/StreamDev.h
@@ -24,8 +24,8 @@ class StreamNull: public Stream
     virtual int peek() override { return -1; }
     virtual size_t readBytes(char* buffer, size_t len) override { (void)buffer; (void)len; return 0; }
     virtual int readNow(char* buffer, size_t len) override { (void)buffer; (void)len; return 0; }
-    virtual bool outputTimeoutPossible () const override { return false; }
-    virtual bool inputTimeoutPossible () const override { return false; }
+    virtual bool outputTimeoutPossible () override { return false; }
+    virtual bool inputTimeoutPossible () override { return false; }
 };
 
 ///////////////////////////////////////////////

diff --git a/cores/esp8266/WString.h b/cores/esp8266/WString.h
@@ -353,7 +353,7 @@ class String: public Stream {
     virtual size_t availableForPeek () override { return available(); }
     virtual const char* peekBuffer () override;
     virtual void peekConsume (size_t consume) override;
-    virtual bool inputTimeoutPossible () const override { return false; }
+    virtual bool inputTimeoutPossible () override { return false; }
     virtual int read (char* buffer, size_t len) /*should override*/;
 
     void peekPointerSetConsume () { peekPointer = -1; }
@@ -366,7 +366,7 @@ class String: public Stream {
 
     //// Print:
 
-    virtual bool outputTimeoutPossible () const override { return false; }
+    virtual bool outputTimeoutPossible () override { return false; }
     virtual int availableForWrite() override { return 64; } // or biggestChunk()/4 or max(1,reserved-length)?
 };
 

diff --git a/libraries/ESP8266WiFi/examples/WiFiEcho/WiFiEcho.ino b/libraries/ESP8266WiFi/examples/WiFiEcho/WiFiEcho.ino
@@ -5,7 +5,7 @@
 */
 
 #include <ESP8266WiFi.h>
-
+#include <PolledTimeout.h>
 #include <algorithm> // std::min
 
 #ifndef STASSID
@@ -16,11 +16,14 @@
 #define STACK_PROTECTOR 128
 
 const int port = 23;
-int t = 3;
+int t = 1; // test (1, 2 or 3, see below)
 
 WiFiServer server(port);
 WiFiClient client;
 
+constexpr uint32_t breathMs = 100;
+esp8266::polledTimeout::oneShotFastMs enoughMs(breathMs);
+
 void setup() {
 
   Serial.begin(115200);
@@ -44,7 +47,8 @@ void setup() {
 
   Serial.print("Ready! Use 'telnet ");
   Serial.print(WiFi.localIP());
-  Serial.printf(" %d' to connect\n", port);
+  Serial.printf(" %d' to try echo, use a bandwidth meter and try typing 1, 2 or 3 on console during transfer\n", port);
+
 }
 
 void loop() {
@@ -57,25 +61,24 @@ void loop() {
 
   if (Serial.available())
     switch (Serial.read()) {
-      case '1': t = 1; break;
-      case '2': t = 2; break;
-      case '3': t = 3; break;
+      case '1': t = 1; Serial.println("byte-by-byte"); break;
+      case '2': t = 2; Serial.println("through buffer"); break;
+      case '3': t = 3; Serial.println("direct access"); break;
     }
 
-  if (t == 1)
-  {
+  enoughMs.reset(breathMs);
+
+  if (t == 1) {
     // byte by byte
-    while (client.available() && client.availableForWrite())
-    {
+    while (client.available() && client.availableForWrite() && !enoughMs) {
       // working char by char is not efficient
       client.write(client.read());
     }
   }
 
-  else if (t == 2)
-  {
+  else if (t == 2) {
     // block by block through a local buffer (2 copies)
-    while (client.available() && client.availableForWrite()) {
+    while (client.available() && client.availableForWrite() && !enoughMs) {
       size_t maxTo = std::min(client.available(), client.availableForWrite());
       maxTo = std::min(maxTo, (size_t)STACK_PROTECTOR);
       uint8_t buf[maxTo];
@@ -87,10 +90,31 @@ void loop() {
     }
   }
 
-  else if (t == 3)
-  {
+  else if (t == 3) {
     // stream to print, possibly with only one copy
-    client.to(&client, -1, 0);  // transfer everything possible, immediate return (no timeout)
+
+#if CORE_MOCK
+
+    // (without limit, with a bandwitdh tester, this call would endlessly transfer data)
+    client.to(&client, 10000000, 0);  // transfer large chunks, no timeout
+    if (client.getLastTo() == Stream::STREAMTO_SHORT)
+      // don't really care about really transfered bytes
+    {
+      client.clearWriteError();
+    }
+
+#else
+
+    client.to(&client, -1, 0);  // on esp: no size limit, no timeout
+
+#endif
+    switch (client.getLastTo()) {
+      case Stream::STREAMTO_SUCCESS: break;
+      case Stream::STREAMTO_TIMED_OUT: Serial.println("Stream::to: timeout"); break;
+      case Stream::STREAMTO_READ_ERROR: Serial.println("Stream::to: read error"); break;
+      case Stream::STREAMTO_WRITE_ERROR: Serial.println("Stream::to: write error"); break;
+      case Stream::STREAMTO_SHORT: Serial.println("Stream::to: short transfer"); break;
+    }
   }
 
 }
diff --git a/libraries/ESP8266WiFi/src/WiFiClient.cpp b/libraries/ESP8266WiFi/src/WiFiClient.cpp
@@ -208,7 +208,7 @@ bool WiFiClient::getSync() const
 
 int WiFiClient::availableForWrite ()
 {
-    return _client? (int)_client->availableForWrite(): 0;
+    return connected()? (int)_client->availableForWrite(): 0;
 }
 
 size_t WiFiClient::write(uint8_t b)
@@ -255,7 +255,7 @@ size_t WiFiClient::write_P(PGM_P buf, size_t size)
 int WiFiClient::available()
 {
     if (!_client)
-        return false;
+        return 0;
 
     int result = _client->getSize();
 
@@ -433,17 +433,18 @@ bool WiFiClient::peekBufferAPI () const
 // semantic forbids any kind of read() before calling peekConsume()
 const char* WiFiClient::peekBuffer ()
 {
-    return _client->peekBuffer();
+    return _client? _client->peekBuffer(): nullptr;
 }
 
 // return number of byte accessible by peekBuffer()
 size_t WiFiClient::availableForPeek ()
 {
-    return _client->availableForPeek();
+    return _client? _client->availableForPeek(): 0;
 }
 
 // consume bytes after use (see peekBuffer)
 void WiFiClient::peekConsume (size_t consume)
 {
-    return _client->peekConsume(consume);
+    if (_client)
+        _client->peekConsume(consume);
 }
diff --git a/libraries/ESP8266WiFi/src/WiFiClient.h b/libraries/ESP8266WiFi/src/WiFiClient.h
@@ -143,6 +143,9 @@ class WiFiClient : public Client, public SList<WiFiClient> {
   // consume bytes after use (see peekBuffer)
   virtual void peekConsume (size_t consume) override;
 
+  virtual bool outputTimeoutPossible () override { return connected(); }
+  virtual bool inputTimeoutPossible () override { return connected(); }
+
 protected:
 
   static int8_t _s_connected(void* arg, void* tpcb, int8_t err);

diff --git a/tests/host/common/mock.h b/tests/host/common/mock.h
@@ -87,7 +87,7 @@ typedef uint32_t uint32;
 #include <c_types.h>
 #include <core_esp8266_features.h>
 
-inline uint32_t esp_get_cycle_count() { return millis(); }
+inline uint32_t esp_get_cycle_count() { return millis() * (F_CPU / 1000); }
 
 #include <Arduino.h>