Merge branch 'master' into set_pins

sabas1080 · web-flow · commit 520157a1fbfe · 2019-06-02T20:57:33.000-05:00
diff --git a/.travis.yml b/.travis.yml
@@ -5,7 +5,7 @@ env:
   matrix:
     - BOARD="arduino:samd:mkrwifi1010"
     - BOARD="arduino:samd_beta:mkrvidor4000"
-    - BOARD="arduino:megaavr:uno2018"
+    - BOARD="arduino:megaavr:uno2018:mode=on"
 before_install:
   - wget http://downloads.arduino.cc/arduino-$IDE_VERSION-linux64.tar.xz
   - tar xf arduino-$IDE_VERSION-linux64.tar.xz
diff --git a/CHANGELOG b/CHANGELOG
@@ -1,5 +1,11 @@
 WiFiNINA ?.?.? - ????.??.??
 
+WiFiNINA 1.4.0 - 2019.03.27
+
+* Improved connection time, by increasing poll time of checking connection status to 100ms on begin
+* Added WiFiClass::setTimeout(...) API to set timeout of begin
+* Fixed issue of WiFiServer:available() only reporting the first byte in the WiFiChatServer example
+
 WiFiNINA 1.3.0 - 2018.11.13
 
 * Added Tools/CheckFirmwareVersion example to check NINA firmware version
diff --git a/keywords.txt b/keywords.txt
@@ -21,6 +21,7 @@ WiFiUDP	KEYWORD1
 
 firmwareVersion	KEYWORD2
 status	KEYWORD2
+reasonCode	KEYWORD2
 connect	KEYWORD2
 write	KEYWORD2
 available	KEYWORD2
@@ -54,6 +55,7 @@ lowPowerMode	KEYWORD2
 noLowPowerMode	KEYWORD2
 ping	KEYWORD2
 beginMulticast	KEYWORD2
+setTimeout	KEYWORD2
 
 
 #######################################
diff --git a/library.properties b/library.properties
@@ -1,5 +1,5 @@
 name=WiFiNINA
-version=1.3.0
+version=1.4.0
 author=Arduino
 maintainer=Arduino <info@arduino.cc>
 sentence=Enables network connection (local and Internet) with the Arduino MKR WiFi 1010, Arduino MKR VIDOR 4000 and Arduino UNO WiFi Rev.2.
diff --git a/src/WiFi.cpp b/src/WiFi.cpp
@@ -30,7 +30,7 @@ extern "C" {
   #include "utility/debug.h"
 }
 
-WiFiClass::WiFiClass()
+WiFiClass::WiFiClass() : _timeout(50000)
 {
 }
 
@@ -64,16 +64,17 @@ const char* WiFiClass::firmwareVersion()
 int WiFiClass::begin(const char* ssid)
 {
 	uint8_t status = WL_IDLE_STATUS;
-	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
 
    if (WiFiDrv::wifiSetNetwork(ssid, strlen(ssid)) != WL_FAILURE)
    {
-	   do
+	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
 	   {
 		   delay(WL_DELAY_START_CONNECTION);
 		   status = WiFiDrv::getConnectionStatus();
+		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+		     break;
+		   }
 	   }
-	   while (((status == WL_IDLE_STATUS)||(status == WL_NO_SSID_AVAIL)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
    }else
    {
 	   status = WL_CONNECT_FAILED;
@@ -84,16 +85,18 @@ int WiFiClass::begin(const char* ssid)
 int WiFiClass::begin(const char* ssid, uint8_t key_idx, const char *key)
 {
 	uint8_t status = WL_IDLE_STATUS;
-	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
 
 	// set encryption key
    if (WiFiDrv::wifiSetKey(ssid, strlen(ssid), key_idx, key, strlen(key)) != WL_FAILURE)
    {
-	   do
+	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
 	   {
 		   delay(WL_DELAY_START_CONNECTION);
 		   status = WiFiDrv::getConnectionStatus();
-	   }while ((( status == WL_IDLE_STATUS)||(status == WL_NO_SSID_AVAIL)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
+		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+		     break;
+		   }
+	   }
    }else{
 	   status = WL_CONNECT_FAILED;
    }
@@ -103,17 +106,18 @@ int WiFiClass::begin(const char* ssid, uint8_t key_idx, const char *key)
 int WiFiClass::begin(const char* ssid, const char *passphrase)
 {
 	uint8_t status = WL_IDLE_STATUS;
-	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
 
     // set passphrase
     if (WiFiDrv::wifiSetPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase))!= WL_FAILURE)
     {
- 	   do
+	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
  	   {
  		   delay(WL_DELAY_START_CONNECTION);
  		   status = WiFiDrv::getConnectionStatus();
+		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+		     break;
+		   }
  	   }
-	   while ((( status == WL_IDLE_STATUS)||(status == WL_NO_SSID_AVAIL)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
     }else{
     	status = WL_CONNECT_FAILED;
     }
@@ -128,16 +132,17 @@ uint8_t WiFiClass::beginAP(const char *ssid)
 uint8_t WiFiClass::beginAP(const char *ssid, uint8_t channel)
 {
 	uint8_t status = WL_IDLE_STATUS;
-	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
 
    if (WiFiDrv::wifiSetApNetwork(ssid, strlen(ssid), channel) != WL_FAILURE)
    {
-	   do
+	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
 	   {
 		   delay(WL_DELAY_START_CONNECTION);
 		   status = WiFiDrv::getConnectionStatus();
+		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+		     break;
+		   }
 	   }
-	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
    }else
    {
 	   status = WL_AP_FAILED;
@@ -153,17 +158,18 @@ uint8_t WiFiClass::beginAP(const char *ssid, const char* passphrase)
 uint8_t WiFiClass::beginAP(const char *ssid, const char* passphrase, uint8_t channel)
 {
 	uint8_t status = WL_IDLE_STATUS;
-	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
 
     // set passphrase
     if (WiFiDrv::wifiSetApPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase), channel)!= WL_FAILURE)
     {
- 	   do
- 	   {
+	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
+	   {
  		   delay(WL_DELAY_START_CONNECTION);
  		   status = WiFiDrv::getConnectionStatus();
+		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+		     break;
+		   }
  	   }
-	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
     }else{
     	status = WL_AP_FAILED;
     }
@@ -315,6 +321,11 @@ uint8_t WiFiClass::status()
     return WiFiDrv::getConnectionStatus();
 }
 
+uint8_t WiFiClass::reasonCode()
+{
+	return WiFiDrv::getReasonCode();
+}
+
 int WiFiClass::hostByName(const char* aHostname, IPAddress& aResult)
 {
 	return WiFiDrv::getHostByName(aHostname, aResult);
@@ -356,4 +367,8 @@ int WiFiClass::ping(IPAddress host, uint8_t ttl)
 	return WiFiDrv::ping(host, ttl);
 }
 
+void WiFiClass::setTimeout(unsigned long timeout)
+{
+	_timeout = timeout;
+}
 WiFiClass WiFi;
diff --git a/src/WiFi.h b/src/WiFi.h
@@ -42,6 +42,7 @@ class WiFiClass
 private:
 
     static void init();
+    unsigned long _timeout;
 public:
     WiFiClass();
 
@@ -244,6 +245,13 @@ class WiFiClass
      */
     uint8_t status();
 
+    /*
+     * Return The deauthentication reason code.
+     *
+     * return: the deauthentication reason code
+     */
+    uint8_t reasonCode();
+
     /*
      * Resolve the given hostname to an IP address.
      * param aHostname: Name to be resolved
@@ -262,8 +270,10 @@ class WiFiClass
     int ping(const String &hostname, uint8_t ttl = 128);
     int ping(IPAddress host, uint8_t ttl = 128);
 
+
     void setPins(int8_t cs=10, int8_t ready=7, int8_t reset=5, int8_t gpio0=6, SPIClass *spi = &SPI);
     void setLEDs(uint8_t red, uint8_t green, uint8_t blue);
+    void setTimeout(unsigned long timeout);
 };
 
 extern WiFiClass WiFi;
diff --git a/src/WiFiServer.cpp b/src/WiFiServer.cpp
@@ -30,7 +30,8 @@ extern "C" {
 #include "WiFiServer.h"
 
 WiFiServer::WiFiServer(uint16_t port) :
-  _sock(NO_SOCKET_AVAIL)
+  _sock(NO_SOCKET_AVAIL),
+  _lastSock(NO_SOCKET_AVAIL)
 {
     _port = port;
 }
@@ -49,7 +50,19 @@ WiFiClient WiFiServer::available(byte* status)
     int sock = NO_SOCKET_AVAIL;
 
     if (_sock != NO_SOCKET_AVAIL) {
-        sock = ServerDrv::availServer(_sock);
+      // check previous received client socket
+      if (_lastSock != NO_SOCKET_AVAIL) {
+          WiFiClient client(_lastSock);
+
+          if (client.connected() && client.available()) {
+              sock = _lastSock;
+          }
+      }
+
+      if (sock == NO_SOCKET_AVAIL) {
+          // check for new client socket
+          sock = ServerDrv::availServer(_sock);
+      }
     }
 
     if (sock != NO_SOCKET_AVAIL) {
@@ -59,6 +72,8 @@ WiFiClient WiFiServer::available(byte* status)
             *status = client.status();
         }
 
+        _lastSock = sock;
+
         return client;
     }
 
diff --git a/src/WiFiServer.h b/src/WiFiServer.h
@@ -32,6 +32,7 @@ class WiFiClient;
 class WiFiServer : public Server {
 private:
   uint8_t _sock;
+  uint8_t _lastSock;
   uint16_t _port;
   void*     pcb;
 public:
diff --git a/src/utility/wifi_drv.cpp b/src/utility/wifi_drv.cpp
@@ -328,6 +328,28 @@ int8_t WiFiDrv::disconnect()
     return result;
 }
 
+uint8_t WiFiDrv::getReasonCode()
+{
+    WAIT_FOR_SLAVE_SELECT();
+
+    // Send Command
+    SpiDrv::sendCmd(GET_REASON_CODE_CMD, PARAM_NUMS_0);
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 1;
+    uint8_t _dataLen = 0;
+    SpiDrv::waitResponseCmd(GET_REASON_CODE_CMD, PARAM_NUMS_1, &_data, &_dataLen);
+
+    SpiDrv::spiSlaveDeselect();
+
+    return _data;
+}
+
 uint8_t WiFiDrv::getConnectionStatus()
 {
 	WAIT_FOR_SLAVE_SELECT();
diff --git a/src/utility/wifi_drv.h b/src/utility/wifi_drv.h
@@ -29,8 +29,8 @@
 
 // Key index length
 #define KEY_IDX_LEN     1
-// 5 secs of delay to have the connection established
-#define WL_DELAY_START_CONNECTION 5000
+// 100 msecs of delay to have the connection established
+#define WL_DELAY_START_CONNECTION 100
 // firmware version string length
 #define WL_FW_VER_LENGTH 6
 
@@ -144,6 +144,8 @@ class WiFiDrv
      */
     static int8_t disconnect();
 
+    static uint8_t getReasonCode();
+
     /*
      * Disconnect from the network
      *
diff --git a/src/utility/wifi_spi.h b/src/utility/wifi_spi.h
@@ -56,6 +56,7 @@ enum {
 	SET_AP_PASSPHRASE_CMD = 0x19,
 	SET_DEBUG_CMD		= 0x1A,
 	GET_TEMPERATURE_CMD = 0x1B,
+	GET_REASON_CODE_CMD = 0x1F,
 
 	GET_CONN_STATUS_CMD	= 0x20,
 	GET_IPADDR_CMD		= 0x21,
diff --git a/src/utility/wl_definitions.h b/src/utility/wl_definitions.h
@@ -45,8 +45,6 @@
 #define SOCK_NOT_AVAIL  255
 // Default state value for Wifi state field
 #define NA_STATE -1
-//Maximum number of attempts to establish wifi connection
-#define WL_MAX_ATTEMPT_CONNECTION	10
 
 typedef enum {
 	WL_NO_SHIELD = 255,

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ extern "C" {`
`30`	`30`	`#include "utility/debug.h"`
`31`	`31`	`}`
`32`	`32`
`33`		`-WiFiClass::WiFiClass()`
	`33`	`+WiFiClass::WiFiClass() : _timeout(50000)`
`34`	`34`	`{`
`35`	`35`	`}`
`36`	`36`
`@@ -64,16 +64,17 @@ const char* WiFiClass::firmwareVersion()`
`64`	`64`	`int WiFiClass::begin(const char* ssid)`
`65`	`65`	`{`
`66`	`66`	`uint8_t status = WL_IDLE_STATUS;`
`67`		`- uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;`
`68`	`67`
`69`	`68`	`if (WiFiDrv::wifiSetNetwork(ssid, strlen(ssid)) != WL_FAILURE)`
`70`	`69`	`{`
`71`		`- do`
	`70`	`+ for (unsigned long start = millis(); (millis() - start) < _timeout;)`
`72`	`71`	`{`
`73`	`72`	`delay(WL_DELAY_START_CONNECTION);`
`74`	`73`	`status = WiFiDrv::getConnectionStatus();`
	`74`	`+ if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {`
	`75`	`+ break;`
	`76`	`+ }`
`75`	`77`	`}`
`76`		`- while (((status == WL_IDLE_STATUS)\|\|(status == WL_NO_SSID_AVAIL)\|\|(status == WL_SCAN_COMPLETED))&&(--attempts>0));`
`77`	`78`	`}else`
`78`	`79`	`{`
`79`	`80`	`status = WL_CONNECT_FAILED;`
`@@ -84,16 +85,18 @@ int WiFiClass::begin(const char* ssid)`
`84`	`85`	`int WiFiClass::begin(const char* ssid, uint8_t key_idx, const char *key)`
`85`	`86`	`{`
`86`	`87`	`uint8_t status = WL_IDLE_STATUS;`
`87`		`- uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;`
`88`	`88`
`89`	`89`	`// set encryption key`
`90`	`90`	`if (WiFiDrv::wifiSetKey(ssid, strlen(ssid), key_idx, key, strlen(key)) != WL_FAILURE)`
`91`	`91`	`{`
`92`		`- do`
	`92`	`+ for (unsigned long start = millis(); (millis() - start) < _timeout;)`
`93`	`93`	`{`
`94`	`94`	`delay(WL_DELAY_START_CONNECTION);`
`95`	`95`	`status = WiFiDrv::getConnectionStatus();`
`96`		`- }while ((( status == WL_IDLE_STATUS)\|\|(status == WL_NO_SSID_AVAIL)\|\|(status == WL_SCAN_COMPLETED))&&(--attempts>0));`
	`96`	`+ if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {`
	`97`	`+ break;`
	`98`	`+ }`
	`99`	`+ }`
`97`	`100`	`}else{`
`98`	`101`	`status = WL_CONNECT_FAILED;`
`99`	`102`	`}`
`@@ -103,17 +106,18 @@ int WiFiClass::begin(const char* ssid, uint8_t key_idx, const char *key)`
`103`	`106`	`int WiFiClass::begin(const char* ssid, const char *passphrase)`
`104`	`107`	`{`
`105`	`108`	`uint8_t status = WL_IDLE_STATUS;`
`106`		`- uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;`
`107`	`109`
`108`	`110`	`// set passphrase`
`109`	`111`	`if (WiFiDrv::wifiSetPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase))!= WL_FAILURE)`
`110`	`112`	`{`
`111`		`- do`
	`113`	`+ for (unsigned long start = millis(); (millis() - start) < _timeout;)`
`112`	`114`	`{`
`113`	`115`	`delay(WL_DELAY_START_CONNECTION);`
`114`	`116`	`status = WiFiDrv::getConnectionStatus();`
	`117`	`+ if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {`
	`118`	`+ break;`
	`119`	`+ }`
`115`	`120`	`}`
`116`		`- while ((( status == WL_IDLE_STATUS)\|\|(status == WL_NO_SSID_AVAIL)\|\|(status == WL_SCAN_COMPLETED))&&(--attempts>0));`
`117`	`121`	`}else{`
`118`	`122`	`status = WL_CONNECT_FAILED;`
`119`	`123`	`}`
`@@ -128,16 +132,17 @@ uint8_t WiFiClass::beginAP(const char *ssid)`
`128`	`132`	`uint8_t WiFiClass::beginAP(const char *ssid, uint8_t channel)`
`129`	`133`	`{`
`130`	`134`	`uint8_t status = WL_IDLE_STATUS;`
`131`		`- uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;`
`132`	`135`
`133`	`136`	`if (WiFiDrv::wifiSetApNetwork(ssid, strlen(ssid), channel) != WL_FAILURE)`
`134`	`137`	`{`
`135`		`- do`
	`138`	`+ for (unsigned long start = millis(); (millis() - start) < _timeout;)`
`136`	`139`	`{`
`137`	`140`	`delay(WL_DELAY_START_CONNECTION);`
`138`	`141`	`status = WiFiDrv::getConnectionStatus();`
	`142`	`+ if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {`
	`143`	`+ break;`
	`144`	`+ }`
`139`	`145`	`}`
`140`		`- while ((( status == WL_IDLE_STATUS)\|\|(status == WL_SCAN_COMPLETED))&&(--attempts>0));`
`141`	`146`	`}else`
`142`	`147`	`{`
`143`	`148`	`status = WL_AP_FAILED;`
`@@ -153,17 +158,18 @@ uint8_t WiFiClass::beginAP(const char ssid, const char passphrase)`
`153`	`158`	`uint8_t WiFiClass::beginAP(const char ssid, const char passphrase, uint8_t channel)`
`154`	`159`	`{`
`155`	`160`	`uint8_t status = WL_IDLE_STATUS;`
`156`		`- uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;`
`157`	`161`
`158`	`162`	`// set passphrase`
`159`	`163`	`if (WiFiDrv::wifiSetApPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase), channel)!= WL_FAILURE)`
`160`	`164`	`{`
`161`		`- do`
`162`		`- {`
	`165`	`+ for (unsigned long start = millis(); (millis() - start) < _timeout;)`
	`166`	`+ {`
`163`	`167`	`delay(WL_DELAY_START_CONNECTION);`
`164`	`168`	`status = WiFiDrv::getConnectionStatus();`
	`169`	`+ if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {`
	`170`	`+ break;`
	`171`	`+ }`
`165`	`172`	`}`
`166`		`- while ((( status == WL_IDLE_STATUS)\|\|(status == WL_SCAN_COMPLETED))&&(--attempts>0));`
`167`	`173`	`}else{`
`168`	`174`	`status = WL_AP_FAILED;`
`169`	`175`	`}`
`@@ -315,6 +321,11 @@ uint8_t WiFiClass::status()`
`315`	`321`	`return WiFiDrv::getConnectionStatus();`
`316`	`322`	`}`
`317`	`323`
	`324`	`+uint8_t WiFiClass::reasonCode()`
	`325`	`+{`
	`326`	`+ return WiFiDrv::getReasonCode();`
	`327`	`+}`
	`328`	`+`
`318`	`329`	`int WiFiClass::hostByName(const char* aHostname, IPAddress& aResult)`
`319`	`330`	`{`
`320`	`331`	`return WiFiDrv::getHostByName(aHostname, aResult);`
`@@ -356,4 +367,8 @@ int WiFiClass::ping(IPAddress host, uint8_t ttl)`
`356`	`367`	`return WiFiDrv::ping(host, ttl);`
`357`	`368`	`}`
`358`	`369`
	`370`	`+void WiFiClass::setTimeout(unsigned long timeout)`
	`371`	`+{`
	`372`	`+ _timeout = timeout;`
	`373`	`+}`
`359`	`374`	`WiFiClass WiFi;`