workaround windows gcc Template issue (#228, #229)

fix some naming

examples/WebSocketClient/WebSocketClient.ino

@@ -17,71 +17,76 @@
 ESP8266WiFiMulti WiFiMulti;
 WebSocketsClient webSocket;
 
-
 #define USE_SERIAL Serial1
 
 void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
 
+	switch(type) {
+		case WStype_DISCONNECTED:
+			USE_SERIAL.printf("[WSc] Disconnected!\n");
+			break;
+		case WStype_CONNECTED: {
+			USE_SERIAL.printf("[WSc] Connected to url: %s\n", payload);
 
-    switch(type) {
-        case WStype_DISCONNECTED:
-            USE_SERIAL.printf("[WSc] Disconnected!\n");
-            break;
-        case WStype_CONNECTED:
-            {
-                USE_SERIAL.printf("[WSc] Connected to url: %s\n",  payload);
-				
-			    // send message to server when Connected
-				webSocket.sendTXT("Connected");
-            }
-            break;
-        case WStype_TEXT:
-            USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+			// send message to server when Connected
+			webSocket.sendTXT("Connected");
+		}
+			break;
+		case WStype_TEXT:
+			USE_SERIAL.printf("[WSc] get text: %s\n", payload);
 
 			// send message to server
 			// webSocket.sendTXT("message here");
-            break;
-        case WStype_BIN:
-            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
-            hexdump(payload, length);
+			break;
+		case WStype_BIN:
+			USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+			hexdump(payload, length);
 
-            // send data to server
-            // webSocket.sendBIN(payload, length);
-            break;
-    }
+			// send data to server
+			// webSocket.sendBIN(payload, length);
+			break;
+	}
 
 }
 
 void setup() {
-    // USE_SERIAL.begin(921600);
-    USE_SERIAL.begin(115200);
+	// USE_SERIAL.begin(921600);
+	USE_SERIAL.begin(115200);
 
-    //Serial.setDebugOutput(true);
-    USE_SERIAL.setDebugOutput(true);
+	//Serial.setDebugOutput(true);
+	USE_SERIAL.setDebugOutput(true);
 
-    USE_SERIAL.println();
-    USE_SERIAL.println();
-    USE_SERIAL.println();
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+	USE_SERIAL.println();
 
-      for(uint8_t t = 4; t > 0; t--) {
-          USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
-          USE_SERIAL.flush();
-          delay(1000);
-      }
+	for(uint8_t t = 4; t > 0; t--) {
+		USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+		USE_SERIAL.flush();
+		delay(1000);
+	}
 
-    WiFiMulti.addAP("SSID", "passpasspass");
+	WiFiMulti.addAP("SSID", "passpasspass");
 
-    //WiFi.disconnect();
-    while(WiFiMulti.run() != WL_CONNECTED) {
-        delay(100);
-    }
+	//WiFi.disconnect();
+	while(WiFiMulti.run() != WL_CONNECTED) {
+		delay(100);
+	}
 
-    webSocket.begin("192.168.0.123", 81);
-    //webSocket.setAuthorization("user", "Password"); // HTTP Basic Authorization
-    webSocket.onEvent(webSocketEvent);
+	// server address, port and URL
+	webSocket.begin("192.168.0.123", 81, "/");
+
+	// event handler
+	webSocket.onEvent(webSocketEvent);
+
+	// use HTTP Basic Authorization this is optional remove if not needed
+	webSocket.setAuthorization("user", "Password");
+
+	// try ever 5000 again if connection has failed
+	webSocket.setReconnectInterval(5000);
 
 }
 
 void loop() {
-    webSocket.loop();
+	webSocket.loop();
 }

library.json

@@ -13,7 +13,7 @@
         "type": "git",
         "url": "https://github.com/Links2004/arduinoWebSockets.git"
     },
-    "version": "2.0.7",
+    "version": "2.0.9",
     "license": "LGPL-2.1",
     "export": {
         "exclude": [

library.properties

@@ -1,7 +1,7 @@
 name=WebSockets
-version=2.0.7
+version=2.0.9
 author=Markus Sattler
-maintainer=Markus Sattler 
+maintainer=Markus Sattler
 sentence=WebSockets for Arduino (Server + Client)
 paragraph=use 2.x.x for ESP and 1.3 for AVR
 category=Communication

src/WebSockets.cpp

@@ -233,18 +233,18 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
         // header has be added to payload
         // payload is forced to reserved 14 Byte but we may not need all based on the length and mask settings
         // offset in payload is calculatetd 14 - headerSize
-        if(client->tcp->write(&payloadPtr[(WEBSOCKETS_MAX_HEADER_SIZE - headerSize)], (length + headerSize)) != (length + headerSize)) {
+        if(write(client, &payloadPtr[(WEBSOCKETS_MAX_HEADER_SIZE - headerSize)], (length + headerSize)) != (length + headerSize)) {
             ret = false;
         }
     } else {
         // send header
-        if(client->tcp->write(&buffer[0], headerSize) != headerSize) {
+        if(write(client, &buffer[0], headerSize) != headerSize) {
             ret = false;
         }
 
         if(payloadPtr && length > 0) {
             // send payload
-            if(client->tcp->write(&payloadPtr[0], length) != length) {
+            if(write(client, &payloadPtr[0], length) != length) {
                 ret = false;
             }
         }
@@ -593,3 +593,56 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
 #endif
     return true;
 }
+
+/**
+ * write x byte to tcp or get timeout
+ * @param client WSclient_t *
+ * @param out  uint8_t * data buffer
+ * @param n size_t byte count
+ * @return bytes send
+ */
+size_t WebSockets::write(WSclient_t * client, uint8_t *out, size_t n) {
+	if(out == NULL) return 0;
+	if(client == NULL) return 0;
+	unsigned long t = millis();
+	size_t len = 0;
+	size_t total = 0;
+	DEBUG_WEBSOCKETS("[write] n: %d t: %d\n", n, t);
+	while(n > 0) {
+		if(client->tcp == NULL) {
+			DEBUG_WEBSOCKETS("[write] tcp is null!\n");
+			break;
+		}
+
+		if(!client->tcp->connected()) {
+			DEBUG_WEBSOCKETS("[write] not connected!\n");
+			break;
+		}
+
+		if((millis() - t) > WEBSOCKETS_TCP_TIMEOUT) {
+			DEBUG_WEBSOCKETS("[write] write TIMEOUT! %d\n", (millis() - t));
+			break;
+		}
+
+		len = client->tcp->write((const uint8_t*)out, n);
+		if(len) {
+			t = millis();
+			out += len;
+			n -= len;
+			total += len;
+			//DEBUG_WEBSOCKETS("write %d left %d!\n", len, n);
+		} else {
+			//DEBUG_WEBSOCKETS("write %d failed left %d!\n", len, n);
+		}
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+		delay(0);
+#endif
+	}
+	return total;
+}
+
+size_t WebSockets::write(WSclient_t * client, const char *out) {
+	if(client == NULL) return 0;
+	if(out == NULL) return 0;
+	return write(client, (uint8_t*)out, strlen(out));
+}

src/WebSockets.h

@@ -34,11 +34,14 @@
 
 #include <functional>
 
+#ifndef NODEBUG_WEBSOCKETS
 #ifdef DEBUG_ESP_PORT
 #define DEBUG_WEBSOCKETS(...) DEBUG_ESP_PORT.printf( __VA_ARGS__ )
 #else
 //#define DEBUG_WEBSOCKETS(...) os_printf( __VA_ARGS__ )
 #endif
+#endif
+
 
 #ifndef DEBUG_WEBSOCKETS
 #define DEBUG_WEBSOCKETS(...)
@@ -267,6 +270,8 @@ class WebSockets {
         String base64_encode(uint8_t * data, size_t length);
 
         bool readCb(WSclient_t * client, uint8_t *out, size_t n, WSreadWaitCb cb);
+        virtual size_t write(WSclient_t * client, uint8_t *out, size_t n);
+        size_t write(WSclient_t * client, const char *out);
 
 
 };

src/WebSocketsClient.cpp

@@ -75,6 +75,9 @@ void WebSocketsClient::begin(const char *host, uint16_t port, const char * url,
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
     asyncConnect();
 #endif
+
+    _lastConnectionFail = 0;
+    _reconnectInterval = 500;
 }
 
 void WebSocketsClient::begin(String host, uint16_t port, String url, String protocol) {
@@ -121,6 +124,10 @@ void WebSocketsClient::beginSocketIOSSL(String host, uint16_t port, String url,
  */
 void WebSocketsClient::loop(void) {
     if(!clientIsConnected(&_client)) {
+    	// do not flood the server
+    	if((millis() - _lastConnectionFail) < _reconnectInterval) {
+    		return;
+    	}
 
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
         if(_client.isSSL) {
@@ -151,9 +158,11 @@ void WebSocketsClient::loop(void) {
 
         if(_client.tcp->connect(_host.c_str(), _port)) {
             connectedCb();
+            _lastConnectionFail = 0;
         } else {
             connectFailedCb();
-            delay(10); //some little delay to not flood the server
+            _lastConnectionFail = millis();
+
         }
     } else {
         handleClientData();
@@ -284,6 +293,16 @@ void WebSocketsClient::setExtraHeaders(const char * extraHeaders) {
     _client.extraHeaders = extraHeaders;
 }
 
+
+/**
+ * set the reconnect Interval
+ * how long to wait after a connection initiate failed
+ * @param time in ms
+ */
+void WebSocketsClient::setReconnectInterval(unsigned long time) {
+	_reconnectInterval = time;
+}
+
 //#################################################################################
 //#################################################################################
 //#################################################################################
@@ -509,7 +528,7 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
 	handshake += NEW_LINE;
 
     DEBUG_WEBSOCKETS("[WS-Client][sendHeader] handshake %s", (uint8_t*)handshake.c_str());
-    client->tcp->write((uint8_t*)handshake.c_str(), handshake.length());
+    write(client, (uint8_t*)handshake.c_str(), handshake.length());
 
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
         client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine)));
@@ -604,6 +623,7 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
                     ok = false;
                     DEBUG_WEBSOCKETS("[WS-Client][handleHeader] serverCode is not 101 (%d)\n", client->cCode);
                     clientDisconnect(client);
+                    _lastConnectionFail = millis();
                     break;
             }
         }
@@ -627,15 +647,15 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
             DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Websocket connection init done.\n");
             headerDone(client);
 
-
             runCbEvent(WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length());
 
 		} else if(clientIsConnected(client) && client->isSocketIO && client->cSessionId.length() > 0) {
 			sendHeader(client);
 		} else {
 			DEBUG_WEBSOCKETS("[WS-Client][handleHeader] no Websocket connection close.\n");
+			_lastConnectionFail = millis();
 			if(clientIsConnected(client)) {
-				client->tcp->write("This is a webSocket client!");
+				write(client, "This is a webSocket client!");
 			}
 			clientDisconnect(client);
 		}

src/WebSocketsClient.h

@@ -83,6 +83,8 @@ class WebSocketsClient: private WebSockets {
 	
         void setExtraHeaders(const char * extraHeaders = NULL);
 
+        void setReconnectInterval(unsigned long time);
+
     protected:
         String _host;
         uint16_t _port;
@@ -94,6 +96,9 @@ class WebSocketsClient: private WebSockets {
 
         WebSocketClientEvent _cbEvent;
 
+        unsigned long _lastConnectionFail;
+        unsigned long _reconnectInterval;
+
         void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin);
 
         void clientDisconnect(WSclient_t * client);

src/WebSocketsServer.cpp

@@ -809,7 +809,7 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
 
             DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] handshake %s",  client->num, (uint8_t*)handshake.c_str());
 
-            client->tcp->write((uint8_t*)handshake.c_str(), handshake.length());
+            write(client, (uint8_t*)handshake.c_str(), handshake.length());
 
             headerDone(client);