IP Configuration

lib/WiFiNINA/src/WiFi.cpp

@@ -0,0 +1,385 @@
+/*
+  WiFi.cpp - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "utility/wifi_drv.h"
+#include "WiFi.h"
+
+extern "C" {
+  #include "utility/wl_definitions.h"
+  #include "utility/wl_types.h"
+  #include "utility/debug.h"
+}
+
+WiFiClass::WiFiClass() : _timeout(50000)
+{
+}
+
+void WiFiClass::init()
+{
+    WiFiDrv::wifiDriverInit();
+}
+
+const char* WiFiClass::firmwareVersion()
+{
+	return WiFiDrv::getFwVersion();
+}
+
+int WiFiClass::begin(const char* ssid)
+{
+	uint8_t status = WL_IDLE_STATUS;
+
+   if (WiFiDrv::wifiSetNetwork(ssid, strlen(ssid)) != WL_FAILURE)
+   {
+	   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;
+		   }
+	   }
+   }else
+   {
+	   status = WL_CONNECT_FAILED;
+   }
+   return status;
+}
+
+int WiFiClass::begin(const char* ssid, uint8_t key_idx, const char *key)
+{
+	uint8_t status = WL_IDLE_STATUS;
+
+	// set encryption key
+   if (WiFiDrv::wifiSetKey(ssid, strlen(ssid), key_idx, key, strlen(key)) != WL_FAILURE)
+   {
+	   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;
+		   }
+	   }
+   }else{
+	   status = WL_CONNECT_FAILED;
+   }
+   return status;
+}
+
+int WiFiClass::begin(const char* ssid, const char *passphrase)
+{
+	uint8_t status = WL_IDLE_STATUS;
+
+    // set passphrase
+    if (WiFiDrv::wifiSetPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase))!= WL_FAILURE)
+    {
+	   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;
+		   }
+ 	   }
+    }else{
+    	status = WL_CONNECT_FAILED;
+    }
+    return status;
+}
+
+uint8_t WiFiClass::beginAP(const char *ssid)
+{
+	return beginAP(ssid, 1);
+}
+
+uint8_t WiFiClass::beginAP(const char *ssid, uint8_t channel)
+{
+	uint8_t status = WL_IDLE_STATUS;
+
+   if (WiFiDrv::wifiSetApNetwork(ssid, strlen(ssid), channel) != WL_FAILURE)
+   {
+	   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;
+		   }
+	   }
+   }else
+   {
+	   status = WL_AP_FAILED;
+   }
+   return status;
+}
+
+uint8_t WiFiClass::beginAP(const char *ssid, const char* passphrase)
+{
+	return beginAP(ssid, passphrase, 1);
+}
+
+uint8_t WiFiClass::beginAP(const char *ssid, const char* passphrase, uint8_t channel)
+{
+	uint8_t status = WL_IDLE_STATUS;
+
+    // set passphrase
+    if (WiFiDrv::wifiSetApPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase), channel)!= WL_FAILURE)
+    {
+	   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;
+		   }
+ 	   }
+    }else{
+    	status = WL_AP_FAILED;
+    }
+    return status;
+}
+
+uint8_t WiFiClass::beginEnterprise(const char* ssid, const char* username, const char* password)
+{
+	return beginEnterprise(ssid, username, password, "");
+}
+
+uint8_t WiFiClass::beginEnterprise(const char* ssid, const char* username, const char* password, const char* identity)
+{
+	return beginEnterprise(ssid, username, password, identity, "");
+}
+
+uint8_t WiFiClass::beginEnterprise(const char* ssid, const char* username, const char* password, const char* identity, const char* ca)
+{
+	uint8_t status = WL_IDLE_STATUS;
+
+	// set passphrase
+	if (WiFiDrv::wifiSetEnterprise(0 /*PEAP/MSCHAPv2*/, ssid, strlen(ssid), username, strlen(username), password, strlen(password), identity, strlen(identity), ca, strlen(ca) + 1)!= WL_FAILURE)
+	{
+		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;
+			}
+		}
+	} else {
+		status = WL_CONNECT_FAILED;
+	}
+	return status;
+}
+
+void WiFiClass::config(IPAddress local_ip)
+{
+	WiFiDrv::config(1, (uint32_t)local_ip, 0, 0);
+}
+
+void WiFiClass::config(IPAddress local_ip, IPAddress dns_server)
+{
+	WiFiDrv::config(1, (uint32_t)local_ip, 0, 0);
+	WiFiDrv::setDNS(1, (uint32_t)dns_server, 0);
+}
+
+void WiFiClass::config(IPAddress local_ip, IPAddress dns_server, IPAddress gateway)
+{
+	WiFiDrv::config(2, (uint32_t)local_ip, (uint32_t)gateway, 0);
+	WiFiDrv::setDNS(1, (uint32_t)dns_server, 0);
+}
+
+void WiFiClass::config(IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet)
+{
+	WiFiDrv::config(3, (uint32_t)local_ip, (uint32_t)gateway, (uint32_t)subnet);
+	WiFiDrv::setDNS(1, (uint32_t)dns_server, 0);
+}
+
+void WiFiClass::setDNS(IPAddress dns_server1)
+{
+	WiFiDrv::setDNS(1, (uint32_t)dns_server1, 0);
+}
+
+void WiFiClass::setDNS(IPAddress dns_server1, IPAddress dns_server2)
+{
+	WiFiDrv::setDNS(2, (uint32_t)dns_server1, (uint32_t)dns_server2);
+}
+
+void WiFiClass::setHostname(const char* name)
+{
+	WiFiDrv::setHostname(name);
+}
+
+int WiFiClass::disconnect()
+{
+    return WiFiDrv::disconnect();
+}
+
+void WiFiClass::end(void)
+{
+	WiFiDrv::wifiDriverDeinit();
+}
+
+uint8_t* WiFiClass::macAddress(uint8_t* mac)
+{
+	uint8_t* _mac = WiFiDrv::getMacAddress();
+	memcpy(mac, _mac, WL_MAC_ADDR_LENGTH);
+    return mac;
+}
+   
+IPAddress WiFiClass::localIP()
+{
+	IPAddress ret;
+	WiFiDrv::getIpAddress(ret);
+	return ret;
+}
+
+IPAddress WiFiClass::subnetMask()
+{
+	IPAddress ret;
+	WiFiDrv::getSubnetMask(ret);
+	return ret;
+}
+
+IPAddress WiFiClass::gatewayIP()
+{
+	IPAddress ret;
+	WiFiDrv::getGatewayIP(ret);
+	return ret;
+}
+
+const char* WiFiClass::SSID()
+{
+    return WiFiDrv::getCurrentSSID();
+}
+
+uint8_t* WiFiClass::BSSID(uint8_t* bssid)
+{
+	uint8_t* _bssid = WiFiDrv::getCurrentBSSID();
+	memcpy(bssid, _bssid, WL_MAC_ADDR_LENGTH);
+    return bssid;
+}
+
+int32_t WiFiClass::RSSI()
+{
+    return WiFiDrv::getCurrentRSSI();
+}
+
+uint8_t WiFiClass::encryptionType()
+{
+    return WiFiDrv::getCurrentEncryptionType();
+}
+
+
+int8_t WiFiClass::scanNetworks()
+{
+	uint8_t attempts = 10;
+	uint8_t numOfNetworks = 0;
+
+	if (WiFiDrv::startScanNetworks() == WL_FAILURE)
+		return WL_FAILURE;
+ 	do
+ 	{
+ 		delay(2000);
+ 		numOfNetworks = WiFiDrv::getScanNetworks();
+ 	}
+	while (( numOfNetworks == 0)&&(--attempts>0));
+	return numOfNetworks;
+}
+
+const char* WiFiClass::SSID(uint8_t networkItem)
+{
+	return WiFiDrv::getSSIDNetoworks(networkItem);
+}
+
+int32_t WiFiClass::RSSI(uint8_t networkItem)
+{
+	return WiFiDrv::getRSSINetoworks(networkItem);
+}
+
+uint8_t WiFiClass::encryptionType(uint8_t networkItem)
+{
+    return WiFiDrv::getEncTypeNetowrks(networkItem);
+}
+
+uint8_t* WiFiClass::BSSID(uint8_t networkItem, uint8_t* bssid)
+{
+	return WiFiDrv::getBSSIDNetowrks(networkItem, bssid);
+}
+
+uint8_t WiFiClass::channel(uint8_t networkItem)
+{
+	return WiFiDrv::getChannelNetowrks(networkItem);
+}
+
+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);
+}
+
+unsigned long WiFiClass::getTime()
+{
+	return WiFiDrv::getTime();
+}
+
+void WiFiClass::lowPowerMode()
+{
+	WiFiDrv::setPowerMode(1);
+}
+
+void WiFiClass::noLowPowerMode()
+{
+	WiFiDrv::setPowerMode(0);
+}
+
+int WiFiClass::ping(const char* hostname, uint8_t ttl)
+{
+	IPAddress ip;
+
+	if (!hostByName(hostname, ip)) {
+		return WL_PING_UNKNOWN_HOST;
+	}
+
+	return ping(ip, ttl);
+}
+
+int WiFiClass::ping(const String &hostname, uint8_t ttl)
+{
+	return ping(hostname.c_str(), ttl);
+}
+
+int WiFiClass::ping(IPAddress host, uint8_t ttl)
+{
+	return WiFiDrv::ping(host, ttl);
+}
+
+void WiFiClass::setTimeout(unsigned long timeout)
+{
+	_timeout = timeout;
+}
+WiFiClass WiFi;

lib/WiFiNINA/src/WiFi.h

@@ -0,0 +1,281 @@
+/*
+  WiFi.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef WiFi_h
+#define WiFi_h
+
+#define WIFI_FIRMWARE_LATEST_VERSION "1.4.4"
+
+#include <inttypes.h>
+
+extern "C" {
+	#include "utility/wl_definitions.h"
+	#include "utility/wl_types.h"
+}
+
+#include "IPAddress.h"
+#include "WiFiClient.h"
+#include "WiFiSSLClient.h"
+#include "WiFiServer.h"
+#include "WiFiStorage.h"
+
+class WiFiClass
+{
+private:
+
+    static void init();
+    unsigned long _timeout;
+public:
+    WiFiClass();
+
+    /*
+     * Get firmware version
+     */
+    static const char* firmwareVersion();
+
+
+    /* Start WiFi connection for OPEN networks
+     *
+     * param ssid: Pointer to the SSID string.
+     */
+    int begin(const char* ssid);
+
+    /* Start WiFi connection with WEP encryption.
+     * Configure a key into the device. The key type (WEP-40, WEP-104)
+     * is determined by the size of the key (5 bytes for WEP-40, 13 bytes for WEP-104).
+     *
+     * param ssid: Pointer to the SSID string.
+     * param key_idx: The key index to set. Valid values are 0-3.
+     * param key: Key input buffer.
+     */
+    int begin(const char* ssid, uint8_t key_idx, const char* key);
+
+    /* Start WiFi connection with passphrase
+     * the most secure supported mode will be automatically selected
+     *
+     * param ssid: Pointer to the SSID string.
+     * param passphrase: Passphrase. Valid characters in a passphrase
+     *        must be between ASCII 32-126 (decimal).
+     */
+    int begin(const char* ssid, const char *passphrase);
+
+    uint8_t beginAP(const char *ssid);
+    uint8_t beginAP(const char *ssid, uint8_t channel);
+    uint8_t beginAP(const char *ssid, const char* passphrase);
+    uint8_t beginAP(const char *ssid, const char* passphrase, uint8_t channel);
+
+    uint8_t beginEnterprise(const char* ssid, const char* username, const char* password);
+    uint8_t beginEnterprise(const char* ssid, const char* username, const char* password, const char* identity);
+    uint8_t beginEnterprise(const char* ssid, const char* username, const char* password, const char* identity, const char* ca);
+
+    /* Change Ip configuration settings disabling the dhcp client
+        *
+        * param local_ip: 	Static ip configuration
+        */
+    void config(IPAddress local_ip);
+
+    /* Change Ip configuration settings disabling the dhcp client
+        *
+        * param local_ip: 	Static ip configuration
+	* param dns_server:     IP configuration for DNS server 1
+        */
+    void config(IPAddress local_ip, IPAddress dns_server);
+
+    /* Change Ip configuration settings disabling the dhcp client
+        *
+        * param local_ip: 	Static ip configuration
+	* param dns_server:     IP configuration for DNS server 1
+        * param gateway : 	Static gateway configuration
+        */
+    void config(IPAddress local_ip, IPAddress dns_server, IPAddress gateway);
+
+    /* Change Ip configuration settings disabling the dhcp client
+        *
+        * param local_ip: 	Static ip configuration
+	* param dns_server:     IP configuration for DNS server 1
+        * param gateway: 	Static gateway configuration
+        * param subnet:		Static Subnet mask
+        */
+    void config(IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet);
+
+    /* Change DNS Ip configuration
+     *
+     * param dns_server1: ip configuration for DNS server 1
+     */
+    void setDNS(IPAddress dns_server1);
+
+    /* Change DNS Ip configuration
+     *
+     * param dns_server1: ip configuration for DNS server 1
+     * param dns_server2: ip configuration for DNS server 2
+     *
+     */
+    void setDNS(IPAddress dns_server1, IPAddress dns_server2);
+
+
+    /* Set the hostname used for DHCP requests
+     *
+     * param name: hostname to set
+     *
+     */
+    void setHostname(const char* name);
+
+    /*
+     * Disconnect from the network
+     *
+     * return: one value of wl_status_t enum
+     */
+    int disconnect(void);
+
+    void end(void);
+
+    /*
+     * Get the interface MAC address.
+     *
+     * return: pointer to uint8_t array with length WL_MAC_ADDR_LENGTH
+     */
+    uint8_t* macAddress(uint8_t* mac);
+
+    /*
+     * Get the interface IP address.
+     *
+     * return: Ip address value
+     */
+    IPAddress localIP();
+
+    /*
+     * Get the interface subnet mask address.
+     *
+     * return: subnet mask address value
+     */
+    IPAddress subnetMask();
+
+    /*
+     * Get the gateway ip address.
+     *
+     * return: gateway ip address value
+     */
+   IPAddress gatewayIP();
+
+    /*
+     * Return the current SSID associated with the network
+     *
+     * return: ssid string
+     */
+    const char* SSID();
+
+    /*
+      * Return the current BSSID associated with the network.
+      * It is the MAC address of the Access Point
+      *
+      * return: pointer to uint8_t array with length WL_MAC_ADDR_LENGTH
+      */
+    uint8_t* BSSID(uint8_t* bssid);
+
+    /*
+      * Return the current RSSI /Received Signal Strength in dBm)
+      * associated with the network
+      *
+      * return: signed value
+      */
+    int32_t RSSI();
+
+    /*
+      * Return the Encryption Type associated with the network
+      *
+      * return: one value of wl_enc_type enum
+      */
+    uint8_t	encryptionType();
+
+    /*
+     * Start scan WiFi networks available
+     *
+     * return: Number of discovered networks
+     */
+    int8_t scanNetworks();
+
+    /*
+     * Return the SSID discovered during the network scan.
+     *
+     * param networkItem: specify from which network item want to get the information
+	 *
+     * return: ssid string of the specified item on the networks scanned list
+     */
+    const char*	SSID(uint8_t networkItem);
+
+    /*
+     * Return the encryption type of the networks discovered during the scanNetworks
+     *
+     * param networkItem: specify from which network item want to get the information
+	 *
+     * return: encryption type (enum wl_enc_type) of the specified item on the networks scanned list
+     */
+    uint8_t	encryptionType(uint8_t networkItem);
+
+    uint8_t* BSSID(uint8_t networkItem, uint8_t* bssid);
+    uint8_t channel(uint8_t networkItem);
+
+    /*
+     * Return the RSSI of the networks discovered during the scanNetworks
+     *
+     * param networkItem: specify from which network item want to get the information
+	 *
+     * return: signed value of RSSI of the specified item on the networks scanned list
+     */
+    int32_t RSSI(uint8_t networkItem);
+
+    /*
+     * Return Connection status.
+     *
+     * return: one of the value defined in wl_status_t
+     */
+    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
+     * param aResult: IPAddress structure to store the returned IP address
+     * result: 1 if aIPAddrString was successfully converted to an IP address,
+     *          else error code
+     */
+    int hostByName(const char* aHostname, IPAddress& aResult);
+
+    unsigned long getTime();
+
+    void lowPowerMode();
+    void noLowPowerMode();
+
+    int ping(const char* hostname, uint8_t ttl = 128);
+    int ping(const String &hostname, uint8_t ttl = 128);
+    int ping(IPAddress host, uint8_t ttl = 128);
+
+    void setTimeout(unsigned long timeout);
+};
+
+extern WiFiClass WiFi;
+
+#endif

lib/WiFiNINA/src/WiFiClient.cpp

@@ -0,0 +1,363 @@
+/*
+  WiFiClient.cpp - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+extern "C" {
+  #include "utility/wl_definitions.h"
+  #include "utility/wl_types.h"
+  #include "string.h"
+  #include "utility/debug.h"
+}
+
+
+#include "utility/server_drv.h"
+#include "utility/wifi_drv.h"
+#include "utility/WiFiSocketBuffer.h"
+
+#include "WiFi.h"
+#include "WiFiClient.h"
+
+uint16_t WiFiClient::_srcport = 1024;
+
+WiFiClient::WiFiClient() : _sock(NO_SOCKET_AVAIL), _retrySend(true) {
+}
+
+WiFiClient::WiFiClient(uint8_t sock) : _sock(sock), _retrySend(true) {
+}
+
+int WiFiClient::connect(const char* host, uint16_t port) {
+	IPAddress remote_addr;
+	if (WiFi.hostByName(host, remote_addr))
+	{
+		return connect(remote_addr, port);
+	}
+	return 0;
+}
+
+int WiFiClient::connect(IPAddress ip, uint16_t port) {
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      stop();
+    }
+
+    _sock = ServerDrv::getSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+    	ServerDrv::startClient(uint32_t(ip), port, _sock);
+
+    	unsigned long start = millis();
+
+    	// wait 4 second for the connection to close
+    	while (!connected() && millis() - start < 10000)
+    		delay(1);
+
+    	if (!connected())
+       	{
+    		return 0;
+    	}
+    } else {
+    	Serial.println("No Socket available");
+    	return 0;
+    }
+    return 1;
+}
+
+int WiFiClient::connectSSL(IPAddress ip, uint16_t port)
+{
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      stop();
+    }
+
+    _sock = ServerDrv::getSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      ServerDrv::startClient(uint32_t(ip), port, _sock, TLS_MODE);
+
+      unsigned long start = millis();
+
+      // wait 4 second for the connection to close
+      while (!connected() && millis() - start < 10000)
+        delay(1);
+
+      if (!connected())
+        {
+        return 0;
+      }
+    } else {
+      Serial.println("No Socket available");
+      return 0;
+    }
+    return 1;
+}
+
+int WiFiClient::connectSSL(const char *host, uint16_t port)
+{
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      stop();
+    }
+
+    _sock = ServerDrv::getSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      ServerDrv::startClient(host, strlen(host), uint32_t(0), port, _sock, TLS_MODE);
+
+      unsigned long start = millis();
+
+      // wait 4 second for the connection to close
+      while (!connected() && millis() - start < 10000)
+        delay(1);
+
+      if (!connected())
+        {
+        return 0;
+      }
+    } else {
+      Serial.println("No Socket available");
+      return 0;
+    }
+    return 1;
+}
+
+int WiFiClient::connectBearSSL(IPAddress ip, uint16_t port)
+{
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      stop();
+    }
+
+    _sock = ServerDrv::getSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      ServerDrv::startClient(uint32_t(ip), port, _sock, TLS_BEARSSL_MODE);
+
+      unsigned long start = millis();
+
+      // wait 4 second for the connection to close
+      while (!connected() && millis() - start < 10000)
+        delay(1);
+
+      if (!connected())
+        {
+        return 0;
+      }
+    } else {
+      Serial.println("No Socket available");
+      return 0;
+    }
+    return 1;
+}
+
+int WiFiClient::connectBearSSL(const char *host, uint16_t port)
+{
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      stop();
+    }
+
+    _sock = ServerDrv::getSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+      ServerDrv::startClient(host, strlen(host), uint32_t(0), port, _sock, TLS_BEARSSL_MODE);
+
+      unsigned long start = millis();
+
+      // wait 4 second for the connection to close
+      while (!connected() && millis() - start < 10000)
+        delay(1);
+
+      if (!connected())
+        {
+        return 0;
+      }
+    } else {
+      Serial.println("No Socket available");
+      return 0;
+    }
+    return 1;
+}
+
+size_t WiFiClient::write(uint8_t b) {
+	  return write(&b, 1);
+}
+
+size_t WiFiClient::write(const uint8_t *buf, size_t size) {
+  if (_sock == NO_SOCKET_AVAIL)
+  {
+	  setWriteError();
+	  return 0;
+  }
+  if (size==0)
+  {
+	  setWriteError();
+    return 0;
+  }
+
+  size_t written = ServerDrv::sendData(_sock, buf, size);
+  if (!written && _retrySend) {
+    written = retry(buf, size, true);
+  }
+  if(!written){
+    // close socket
+    ServerDrv::stopClient(_sock);
+    setWriteError();
+    return 0;
+  }
+
+  if (!ServerDrv::checkDataSent(_sock))
+  {
+    setWriteError();
+    return 0;
+  }
+
+  return written;
+}
+
+size_t WiFiClient::retry(const uint8_t *buf, size_t size, bool write) {
+  size_t rec_bytes = 0;
+
+  if (write) {
+
+    //RETRY WRITE
+    for (int i=0; i<5; i++) {
+      rec_bytes = ServerDrv::sendData(_sock, buf, size);
+      if (rec_bytes) {
+        break;
+      }
+    }
+    return rec_bytes;
+
+  } else {
+	  return rec_bytes;
+      //RETRY READ
+      // To be implemented, if needed
+  }
+
+}
+
+int WiFiClient::available() {
+  if (_sock != 255)
+  {
+      return WiFiSocketBuffer.available(_sock);
+  }
+   
+  return 0;
+}
+
+int WiFiClient::read() {
+  if (!available())
+  {
+    return -1;
+  }
+
+  uint8_t b;
+
+  WiFiSocketBuffer.read(_sock, &b, sizeof(b));
+
+  return b;
+}
+
+
+int WiFiClient::read(uint8_t* buf, size_t size) {
+  return  WiFiSocketBuffer.read(_sock, buf, size);
+}
+
+int WiFiClient::peek() {
+  return WiFiSocketBuffer.peek(_sock);
+}
+
+void WiFiClient::setRetry(bool retry) {
+  _retrySend = retry;
+}
+
+void WiFiClient::flush() {
+  // TODO: a real check to ensure transmission has been completed
+}
+
+void WiFiClient::stop() {
+
+  if (_sock == 255)
+    return;
+
+  ServerDrv::stopClient(_sock);
+
+  int count = 0;
+  // wait maximum 5 secs for the connection to close
+  while (status() != CLOSED && ++count < 50)
+    delay(100);
+
+  WiFiSocketBuffer.close(_sock);
+  _sock = 255;
+}
+
+uint8_t WiFiClient::connected() {
+
+  if (_sock == 255) {
+    return 0;
+  } else if (available()) {
+    return 1;
+  } else {
+    uint8_t s = status();
+
+    uint8_t result =  !(s == LISTEN || s == CLOSED || s == FIN_WAIT_1 ||
+                      s == FIN_WAIT_2 || s == TIME_WAIT ||
+                      s == SYN_SENT || s== SYN_RCVD ||
+                      (s == CLOSE_WAIT));
+
+    if (result == 0) {
+      WiFiSocketBuffer.close(_sock);
+      _sock = 255;
+    }
+
+    return result;
+  }
+}
+
+uint8_t WiFiClient::status() {
+    if (_sock == 255) {
+    return CLOSED;
+  } else {
+    return ServerDrv::getClientState(_sock);
+  }
+}
+
+WiFiClient::operator bool() {
+  return _sock != 255;
+}
+
+IPAddress  WiFiClient::remoteIP()
+{
+  uint8_t _remoteIp[4] = {0};
+  uint8_t _remotePort[2] = {0};
+
+  WiFiDrv::getRemoteData(_sock, _remoteIp, _remotePort);
+  IPAddress ip(_remoteIp);
+  return ip;
+}
+
+uint16_t  WiFiClient::remotePort()
+{
+  uint8_t _remoteIp[4] = {0};
+  uint8_t _remotePort[2] = {0};
+
+  WiFiDrv::getRemoteData(_sock, _remoteIp, _remotePort);
+  uint16_t port = (_remotePort[0]<<8)+_remotePort[1];
+  return port;
+}

lib/WiFiNINA/src/WiFiClient.h

@@ -0,0 +1,69 @@
+/*
+  WiFiClient.cpp - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef wificlient_h
+#define wificlient_h
+#include "Arduino.h"	
+#include "Print.h"
+#include "Client.h"
+#include "IPAddress.h"
+
+class WiFiClient : public Client {
+
+public:
+  WiFiClient();
+  WiFiClient(uint8_t sock);
+
+  uint8_t status();
+  virtual int connect(IPAddress ip, uint16_t port);
+  virtual int connect(const char *host, uint16_t port);
+  virtual int connectSSL(IPAddress ip, uint16_t port);
+  virtual int connectSSL(const char *host, uint16_t port);
+  virtual int connectBearSSL(IPAddress ip, uint16_t port);
+  virtual int connectBearSSL(const char *host, uint16_t port);
+  virtual size_t write(uint8_t);
+  virtual size_t write(const uint8_t *buf, size_t size);
+  virtual size_t retry(const uint8_t *buf, size_t size, bool write);
+  virtual int available();
+  virtual int read();
+  virtual int read(uint8_t *buf, size_t size);
+  virtual int peek();
+  virtual void setRetry(bool retry);
+  virtual void flush();
+  virtual void stop();
+  virtual uint8_t connected();
+  virtual operator bool();
+
+  virtual IPAddress remoteIP();
+  virtual uint16_t remotePort();
+
+  friend class WiFiServer;
+  friend class WiFiDrv;
+
+  using Print::write;
+
+private:
+  static uint16_t _srcport;
+  uint8_t _sock;   //not used
+  uint16_t  _socket;
+  bool _retrySend;
+};
+
+#endif

lib/WiFiNINA/src/WiFiNINA.h

@@ -0,0 +1,25 @@
+/*
+  This file is part of the WiFiNINA library.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef WiFiNINA_h
+#define WiFiNINA_h
+
+#include "WiFi.h"
+
+#endif

lib/WiFiNINA/src/WiFiSSLClient.cpp

@@ -0,0 +1,60 @@
+/*
+  This file is part of the WiFiNINA library.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "WiFiSSLClient.h"
+
+WiFiSSLClient::WiFiSSLClient() : 
+	WiFiClient()
+{
+}
+
+WiFiSSLClient::WiFiSSLClient(uint8_t sock) :
+	WiFiClient(sock)
+{  
+}
+
+int WiFiSSLClient::connect(IPAddress ip, uint16_t port)
+{
+	return WiFiClient::connectSSL(ip, port);
+}
+
+int WiFiSSLClient::connect(const char* host, uint16_t port)
+{
+	return WiFiClient::connectSSL(host, port);
+}
+
+WiFiBearSSLClient::WiFiBearSSLClient() :
+	WiFiClient()
+{
+}
+
+WiFiBearSSLClient::WiFiBearSSLClient(uint8_t sock) :
+	WiFiClient(sock)
+{
+}
+
+int WiFiBearSSLClient::connect(IPAddress ip, uint16_t port)
+{
+	return WiFiClient::connectBearSSL(ip, port);
+}
+
+int WiFiBearSSLClient::connect(const char* host, uint16_t port)
+{
+	return WiFiClient::connectBearSSL(host, port);
+}

lib/WiFiNINA/src/WiFiSSLClient.h

@@ -0,0 +1,45 @@
+/*
+  This file is part of the WiFiNINA library.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef WIFISSLCLIENT_H
+#define WIFISSLCLIENT_H
+
+#include "WiFiClient.h"
+
+class WiFiSSLClient : public WiFiClient {
+
+public:
+	WiFiSSLClient();
+	WiFiSSLClient(uint8_t sock);
+
+	virtual int connect(IPAddress ip, uint16_t port);
+	virtual int connect(const char* host, uint16_t port);
+};
+
+class WiFiBearSSLClient : public WiFiClient {
+
+public:
+	WiFiBearSSLClient();
+	WiFiBearSSLClient(uint8_t sock);
+
+	virtual int connect(IPAddress ip, uint16_t port);
+	virtual int connect(const char* host, uint16_t port);
+};
+
+#endif /* WIFISSLCLIENT_H */

lib/WiFiNINA/src/WiFiServer.cpp

@@ -0,0 +1,119 @@
+/*
+  WiFiServer.cpp - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <string.h>
+#include "utility/server_drv.h"
+
+extern "C" {
+  #include "utility/debug.h"
+}
+
+#include "WiFi.h"
+#include "WiFiClient.h"
+#include "WiFiServer.h"
+
+WiFiServer::WiFiServer(uint16_t port) :
+  _sock(NO_SOCKET_AVAIL),
+  _lastSock(NO_SOCKET_AVAIL)
+{
+    _port = port;
+}
+
+void WiFiServer::begin()
+{
+    _sock = ServerDrv::getSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+        ServerDrv::startServer(_port, _sock);
+    }
+}
+
+WiFiClient WiFiServer::available(byte* status)
+{
+    int sock = NO_SOCKET_AVAIL;
+
+    if (_sock != NO_SOCKET_AVAIL) {
+      // 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) {
+        WiFiClient client(sock);
+
+        if (status != NULL) {
+            *status = client.status();
+        }
+
+        _lastSock = sock;
+
+        return client;
+    }
+
+    return WiFiClient(255);
+}
+
+uint8_t WiFiServer::status() {
+    if (_sock == NO_SOCKET_AVAIL) {
+        return CLOSED;
+    } else {
+        return ServerDrv::getServerState(_sock);
+    }
+}
+
+
+size_t WiFiServer::write(uint8_t b)
+{
+    return write(&b, 1);
+}
+
+size_t WiFiServer::write(const uint8_t *buffer, size_t size)
+{
+    if (size==0)
+    {
+        setWriteError();
+        return 0;
+    }
+
+    size_t written = ServerDrv::sendData(_sock, buffer, size);
+    if (!written)
+    {
+        setWriteError();
+        return 0;
+    }
+
+    if (!ServerDrv::checkDataSent(_sock))
+    {
+        setWriteError();
+        return 0;
+    }
+
+    return written;
+}

lib/WiFiNINA/src/WiFiServer.h

@@ -0,0 +1,49 @@
+/*
+  WiFiServer.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef wifiserver_h
+#define wifiserver_h
+
+extern "C" {
+  #include "utility/wl_definitions.h"
+}
+
+#include "Server.h"
+
+class WiFiClient;
+
+class WiFiServer : public Server {
+private:
+  uint8_t _sock;
+  uint8_t _lastSock;
+  uint16_t _port;
+  void*     pcb;
+public:
+  WiFiServer(uint16_t);
+  WiFiClient available(uint8_t* status = NULL);
+  void begin();
+  virtual size_t write(uint8_t);
+  virtual size_t write(const uint8_t *buf, size_t size);
+  uint8_t status();
+
+  using Print::write;
+};
+
+#endif

lib/WiFiNINA/src/WiFiStorage.cpp

@@ -0,0 +1,30 @@
+/*
+  WiFiStorage.cpp - Library for Arduino boards based on NINA WiFi module.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "WiFiStorage.h"
+
+WiFiStorageFile WiFiStorageClass::open(const char *filename) {
+	WiFiStorageFile file(filename);
+	file.size();
+	return file;
+}
+
+WiFiStorageFile WiFiStorageClass::open(String filename) {
+	return open(filename.c_str());
+}

lib/WiFiNINA/src/WiFiStorage.h

@@ -0,0 +1,151 @@
+/*
+  WiFiStorage.h - Library for Arduino boards based on NINA WiFi module.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef wifistorage_h
+#define wifistorage_h
+
+#include "utility/wifi_drv.h"
+
+class WiFiStorageFile;
+
+class WiFiStorageClass
+{
+public:
+	static bool begin();
+
+	static WiFiStorageFile open(const char *filename);
+	static WiFiStorageFile open(String filename);
+
+	static bool exists(const char *filename) {
+		uint32_t len;
+		return (WiFiDrv::existsFile(filename, strlen(filename), &len) > 0);
+	}
+	static bool exists(const char *filename, uint32_t* len) {
+		return (WiFiDrv::existsFile(filename, strlen(filename), len) > 0);
+	}
+	static bool remove(const char *filename) {
+		WiFiDrv::deleteFile(filename, strlen(filename));
+		return true;
+	}
+	static bool rename(const char * old_file_name, const char * new_file_name) {
+		return (WiFiDrv::renameFile(old_file_name, strlen(old_file_name), new_file_name, strlen(new_file_name)) == 0);
+	}
+	static bool read(const char *filename, uint32_t offset, uint8_t* buffer, uint32_t buffer_len) {
+		WiFiDrv::readFile(filename, strlen(filename), offset, buffer, buffer_len);
+		return true;
+	}
+	static bool write(const char *filename, uint32_t offset, uint8_t* buffer, uint32_t buffer_len) {
+		WiFiDrv::writeFile(filename, strlen(filename), offset, buffer, buffer_len);
+		return true;
+	}
+	static bool download(const char* url, const char *filename) {
+		WiFiDrv::downloadFile(url, strlen(url), filename, strlen(filename));
+		return true;
+	}
+    static bool downloadOTA(const char * url, uint8_t * res_ota_download = NULL) {
+		/* The buffer within the nina firmware allows a maximum
+		 * url size of 128 bytes. It's better to prevent the
+		 * transmission of over-sized URL as soon as possible.
+		 */
+		if (strlen(url) > 128)
+			return false;
+
+		uint8_t const res = WiFiDrv::downloadOTA(url, strlen(url));
+		if (res_ota_download)
+		  *res_ota_download = res;
+		bool const success = (res == 0);
+        return success;
+    }
+
+
+    static bool remove(String filename) {
+    	return remove(filename.c_str());
+	}
+	static bool rename(String old_file_name, String new_file_name) {
+		return rename(old_file_name.c_str(), new_file_name.c_str());
+	}
+	static bool read(String filename, uint32_t offset, uint8_t* buffer, uint32_t buffer_len) {
+		return read(filename.c_str(), offset, buffer, buffer_len);
+	}
+	static bool write(String filename, uint32_t offset, uint8_t* buffer, uint32_t buffer_len) {
+		return write(filename.c_str(), offset, buffer, buffer_len);
+	}
+    static bool download(String url, String filename) {
+    	return download(url.c_str(), filename.c_str());
+    }
+    static bool download(String url, uint8_t * res_ota_download = NULL) {
+        return downloadOTA(url.c_str(), res_ota_download);
+    }
+};
+
+extern WiFiStorageClass WiFiStorage;
+
+
+class WiFiStorageFile
+{
+public:
+	constexpr WiFiStorageFile(const char* _filename) : filename(_filename) { }
+
+	operator bool() {
+		return WiFiStorage.exists(filename, &length);
+	}
+	uint32_t read(void *buf, uint32_t rdlen) {
+		if (offset + rdlen > length) {
+			if (offset >= length) return 0;
+			rdlen = length - offset;
+		}
+		WiFiStorage.read(filename, offset, (uint8_t*)buf, rdlen);
+		offset += rdlen;
+		return rdlen;
+	}
+	uint32_t write(const void *buf, uint32_t wrlen) {
+		WiFiStorage.write(filename, offset, (uint8_t*)buf, wrlen);
+		offset += wrlen;
+		return wrlen;
+	}
+	void seek(uint32_t n) {
+		offset = n;
+	}
+	uint32_t position() {
+		return offset;
+	}
+	uint32_t size() {
+		WiFiStorage.exists(filename, &length);
+		return length;
+	}
+	uint32_t available() {
+		WiFiStorage.exists(filename, &length);
+		return length - offset;
+	}
+	void erase() {
+		offset = 0;
+		WiFiStorage.remove(filename);
+	}
+	void flush();
+	void close() {
+		offset = 0;
+	}
+protected:
+	friend class WiFiStorageClass;
+	uint32_t offset = 0;
+	uint32_t length = 0;
+	const char* filename;
+};
+
+#endif

lib/WiFiNINA/src/WiFiUdp.cpp

@@ -0,0 +1,217 @@
+/*
+  WiFiUdp.cpp - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <string.h>
+
+extern "C" {
+  #include "utility/debug.h"
+  #include "utility/wifi_spi.h"
+}
+
+#include "utility/server_drv.h"
+#include "utility/wifi_drv.h"
+#include "utility/WiFiSocketBuffer.h"
+
+#include "WiFi.h"
+#include "WiFiUdp.h"
+#include "WiFiClient.h"
+#include "WiFiServer.h"
+
+
+/* Constructor */
+WiFiUDP::WiFiUDP() : _sock(NO_SOCKET_AVAIL), _parsed(0) {}
+
+/* Start WiFiUDP socket, listening at local port PORT */
+uint8_t WiFiUDP::begin(uint16_t port) {
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+        stop();
+    }
+
+    uint8_t sock = ServerDrv::getSocket();
+    if (sock != NO_SOCKET_AVAIL)
+    {
+        ServerDrv::startServer(port, sock, UDP_MODE);
+        _sock = sock;
+        _port = port;
+        _parsed = 0;
+        return 1;
+    }
+    return 0;
+}
+
+uint8_t WiFiUDP::beginMulticast(IPAddress ip, uint16_t port) {
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+        stop();
+    }
+
+    uint8_t sock = ServerDrv::getSocket();
+    if (sock != NO_SOCKET_AVAIL)
+    {
+        ServerDrv::startServer(ip, port, sock, UDP_MULTICAST_MODE);
+        _sock = sock;
+        _port = port;
+        _parsed = 0;
+        return 1;
+    }
+    return 0;
+}
+
+/* return number of bytes available in the current packet,
+   will return zero if parsePacket hasn't been called yet */
+int WiFiUDP::available() {
+	 return _parsed;
+}
+
+/* Release any resources being used by this WiFiUDP instance */
+void WiFiUDP::stop()
+{
+	  if (_sock == NO_SOCKET_AVAIL)
+	    return;
+
+	  ServerDrv::stopClient(_sock);
+
+	  WiFiSocketBuffer.close(_sock);
+	  _sock = NO_SOCKET_AVAIL;
+}
+
+int WiFiUDP::beginPacket(const char *host, uint16_t port)
+{
+	// Look up the host first
+	int ret = 0;
+	IPAddress remote_addr;
+	if (WiFi.hostByName(host, remote_addr))
+	{
+		return beginPacket(remote_addr, port);
+	}
+	return ret;
+}
+
+int WiFiUDP::beginPacket(IPAddress ip, uint16_t port)
+{
+  if (_sock == NO_SOCKET_AVAIL)
+	  _sock = ServerDrv::getSocket();
+  if (_sock != NO_SOCKET_AVAIL)
+  {
+	  ServerDrv::startClient(uint32_t(ip), port, _sock, UDP_MODE);
+	  return 1;
+  }
+  return 0;
+}
+
+int WiFiUDP::endPacket()
+{
+	return ServerDrv::sendUdpData(_sock);
+}
+
+size_t WiFiUDP::write(uint8_t byte)
+{
+  return write(&byte, 1);
+}
+
+size_t WiFiUDP::write(const uint8_t *buffer, size_t size)
+{
+	ServerDrv::insertDataBuf(_sock, buffer, size);
+	return size;
+}
+
+int WiFiUDP::parsePacket()
+{
+	while (_parsed--)
+	{
+	  // discard previously parsed packet data
+	  uint8_t b;
+
+	  WiFiSocketBuffer.read(_sock, &b, sizeof(b));
+	}
+
+	_parsed = ServerDrv::availData(_sock);
+
+	return _parsed;
+}
+
+int WiFiUDP::read()
+{
+  if (_parsed < 1)
+  {
+    return -1;
+  }
+
+  uint8_t b;
+
+  WiFiSocketBuffer.read(_sock, &b, sizeof(b));
+  _parsed--;
+
+  return b;
+}
+
+int WiFiUDP::read(unsigned char* buffer, size_t len)
+{
+  if (_parsed < 1)
+  {
+    return 0;
+  }
+
+  int result = WiFiSocketBuffer.read(_sock, buffer, len);
+
+  if (result > 0)
+  {
+    _parsed -= result;
+  }
+
+  return result;
+}
+
+int WiFiUDP::peek()
+{
+  if (_parsed < 1)
+  {
+    return -1;
+  }
+
+  return WiFiSocketBuffer.peek(_sock);
+}
+
+void WiFiUDP::flush()
+{
+  // TODO: a real check to ensure transmission has been completed
+}
+
+IPAddress  WiFiUDP::remoteIP()
+{
+	uint8_t _remoteIp[4] = {0};
+	uint8_t _remotePort[2] = {0};
+
+	WiFiDrv::getRemoteData(_sock, _remoteIp, _remotePort);
+	IPAddress ip(_remoteIp);
+	return ip;
+}
+
+uint16_t  WiFiUDP::remotePort()
+{
+	uint8_t _remoteIp[4] = {0};
+	uint8_t _remotePort[2] = {0};
+
+	WiFiDrv::getRemoteData(_sock, _remoteIp, _remotePort);
+	uint16_t port = (_remotePort[0]<<8)+_remotePort[1];
+	return port;
+}
+

lib/WiFiNINA/src/WiFiUdp.h

@@ -0,0 +1,83 @@
+/*
+  WiFiUdp.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino LLC.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef wifiudp_h
+#define wifiudp_h
+
+#include <Udp.h>
+
+#define UDP_TX_PACKET_MAX_SIZE 24
+
+class WiFiUDP : public UDP {
+private:
+  uint8_t _sock;  // socket ID for Wiz5100
+  uint16_t _port; // local port to listen on
+  int _parsed;
+
+public:
+  WiFiUDP();  // Constructor
+  virtual uint8_t begin(uint16_t);	// initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
+  virtual uint8_t beginMulticast(IPAddress, uint16_t);  // initialize, start listening on specified multicast IP address and port. Returns 1 if successful, 0 if there are no sockets available to use
+  virtual void stop();  // Finish with the UDP socket
+
+  // Sending UDP packets
+  
+  // Start building up a packet to send to the remote host specific in ip and port
+  // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
+  virtual int beginPacket(IPAddress ip, uint16_t port);
+  // Start building up a packet to send to the remote host specific in host and port
+  // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
+  virtual int beginPacket(const char *host, uint16_t port);
+  // Finish off this packet and send it
+  // Returns 1 if the packet was sent successfully, 0 if there was an error
+  virtual int endPacket();
+  // Write a single byte into the packet
+  virtual size_t write(uint8_t);
+  // Write size bytes from buffer into the packet
+  virtual size_t write(const uint8_t *buffer, size_t size);
+  
+  using Print::write;
+
+  // Start processing the next available incoming packet
+  // Returns the size of the packet in bytes, or 0 if no packets are available
+  virtual int parsePacket();
+  // Number of bytes remaining in the current packet
+  virtual int available();
+  // Read a single byte from the current packet
+  virtual int read();
+  // Read up to len bytes from the current packet and place them into buffer
+  // Returns the number of bytes read, or 0 if none are available
+  virtual int read(unsigned char* buffer, size_t len);
+  // Read up to len characters from the current packet and place them into buffer
+  // Returns the number of characters read, or 0 if none are available
+  virtual int read(char* buffer, size_t len) { return read((unsigned char*)buffer, len); };
+  // Return the next byte from the current packet without moving on to the next byte
+  virtual int peek();
+  virtual void flush();	// Finish reading the current packet
+
+  // Return the IP address of the host who sent the current incoming packet
+  virtual IPAddress remoteIP();
+  // Return the port of the host who sent the current incoming packet
+  virtual uint16_t remotePort();
+
+  friend class WiFiDrv;
+};
+
+#endif

lib/WiFiNINA/src/utility/WiFiSocketBuffer.cpp

@@ -0,0 +1,104 @@
+/*
+  This file is part of the WiFiNINA library.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "utility/server_drv.h"
+
+#include "WiFiSocketBuffer.h"
+
+#define WIFI_SOCKET_NUM_BUFFERS (sizeof(_buffers) / sizeof(_buffers[0]))
+
+#ifdef __AVR__
+#define WIFI_SOCKET_BUFFER_SIZE 64
+#else
+#define WIFI_SOCKET_BUFFER_SIZE 1500
+#endif
+
+WiFiSocketBufferClass::WiFiSocketBufferClass()
+{
+  memset(&_buffers, 0x00, sizeof(_buffers));
+}
+
+WiFiSocketBufferClass::~WiFiSocketBufferClass()
+{
+  for (unsigned int i = 0; i < WIFI_SOCKET_NUM_BUFFERS; i++) {
+    close(i);
+  }
+}
+
+void WiFiSocketBufferClass::close(int socket)
+{
+  if (_buffers[socket].data) {
+    free(_buffers[socket].data);
+    _buffers[socket].data = _buffers[socket].head = NULL;
+    _buffers[socket].length = 0;
+  }
+}
+
+int WiFiSocketBufferClass::available(int socket)
+{
+  if (_buffers[socket].length == 0) {
+    if (_buffers[socket].data == NULL) {
+      _buffers[socket].data = _buffers[socket].head = (uint8_t*)malloc(WIFI_SOCKET_BUFFER_SIZE);
+      _buffers[socket].length = 0;
+    }
+
+    // sizeof(size_t) is architecture dependent
+    // but we need a 16 bit data type here
+    uint16_t size = WIFI_SOCKET_BUFFER_SIZE;
+    if (ServerDrv::getDataBuf(socket, _buffers[socket].data, &size)) {
+      _buffers[socket].head = _buffers[socket].data;
+      _buffers[socket].length = size;
+    }
+  }
+
+  return _buffers[socket].length;
+}
+
+int WiFiSocketBufferClass::peek(int socket)
+{
+  if (!available(socket)) {
+    return -1;
+  }
+
+  return *_buffers[socket].head;
+}
+
+int WiFiSocketBufferClass::read(int socket, uint8_t* data, size_t length)
+{
+  int avail = available(socket);
+
+  if (!avail) {
+    return 0;
+  }
+
+  if (avail < (int)length) {
+    length = avail;
+  }
+
+  memcpy(data, _buffers[socket].head, length);
+  _buffers[socket].head += length;
+  _buffers[socket].length -= length;
+
+  return length;
+}
+
+WiFiSocketBufferClass WiFiSocketBuffer;

lib/WiFiNINA/src/utility/WiFiSocketBuffer.h

@@ -0,0 +1,52 @@
+/*
+  This file is part of the WiFiNINA library.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef WiFiSocketBuffer_h
+#define WiFiSocketBuffer_h
+
+#include <stddef.h>
+#include <stdint.h>
+
+extern "C" {
+  #include "utility/wl_definitions.h"
+}
+
+class WiFiSocketBufferClass {
+
+public:
+  WiFiSocketBufferClass();
+  ~WiFiSocketBufferClass();
+
+  void close(int socket);
+
+  int available(int socket);
+  int peek(int socket);
+  int read(int socket, uint8_t* data, size_t length);
+
+private:
+  struct {
+    uint8_t* data;
+    uint8_t* head;
+    int length;
+  } _buffers[WIFI_MAX_SOCK_NUM];
+};
+
+extern WiFiSocketBufferClass WiFiSocketBuffer;
+
+#endif

lib/WiFiNINA/src/utility/debug.h

@@ -0,0 +1,95 @@
+/*
+  debug.h - Library for Arduino Wifi shield.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+//*********************************************/
+// 
+//  File:   debug.h
+// 
+//  Author: dlf (Metodo2 srl)
+// 
+//********************************************/
+
+
+#ifndef Debug_H
+#define Debug_H
+
+#include <stdio.h>
+#include <string.h>
+
+#define PRINT_FILE_LINE() do { 						\
+		Serial.print("[");Serial.print(__FILE__);		\
+		Serial.print("::");Serial.print(__LINE__);Serial.print("]");\
+}while (0);
+
+#ifdef _DEBUG_
+
+#define INFO(format, args...) do { \
+	char buf[250];	\
+	sprintf(buf, format, args); \
+	Serial.println(buf); \
+} while(0);
+
+#define INFO1(x) do { PRINT_FILE_LINE() Serial.print("-I-");\
+		Serial.println(x);    			\
+}while (0);
+
+
+#define INFO2(x,y) do { PRINT_FILE_LINE() Serial.print("-I-");\
+		Serial.print(x,16);Serial.print(",");Serial.println(y,16); \
+}while (0);
+
+
+#else
+#define INFO1(x) do {} while(0);
+#define INFO2(x,y) do {} while(0);
+#define INFO(format, args...) do {} while(0);
+#endif
+
+#if 0
+#define WARN(args) do { PRINT_FILE_LINE()			\
+		Serial.print("-W-"); Serial.println(args);	\
+}while (0);
+#else
+#define WARN(args) do {} while (0);
+#endif
+
+#if _DEBUG_SPI_
+#define DBG_PIN2 5
+#define DBG_PIN 4
+
+#define START()         digitalWrite(DBG_PIN2, HIGH);
+#define END()           digitalWrite(DBG_PIN2, LOW);
+#define SET_TRIGGER()   digitalWrite(DBG_PIN, HIGH);
+#define RST_TRIGGER()   digitalWrite(DBG_PIN, LOW);
+
+#define INIT_TRIGGER()  pinMode(DBG_PIN, OUTPUT); \
+                        pinMode(DBG_PIN2, OUTPUT); \
+                        RST_TRIGGER()
+#define TOGGLE_TRIGGER() SET_TRIGGER() \
+                           delayMicroseconds(2);    \
+                               RST_TRIGGER()
+#else
+#define START()
+#define END()
+#define SET_TRIGGER()
+#define RST_TRIGGER()
+#define INIT_TRIGGER()
+#define TOGGLE_TRIGGER()
+#endif
+
+#endif

lib/WiFiNINA/src/utility/server_drv.cpp

@@ -0,0 +1,520 @@
+/*
+  server_drv.cpp - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+//#define _DEBUG_
+
+#include "utility/server_drv.h"
+
+#include "Arduino.h"
+#include "utility/spi_drv.h"
+
+extern "C" {
+#include "utility/wl_types.h"
+#include "utility/debug.h"
+}
+
+
+// Start server TCP on port specified
+void ServerDrv::startServer(uint16_t port, uint8_t sock, uint8_t protMode)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(START_SERVER_TCP_CMD, PARAM_NUMS_3);
+    SpiDrv::sendParam(port);
+    SpiDrv::sendParam(&sock, 1);
+    SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(START_SERVER_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+}
+
+void ServerDrv::startServer(uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode)
+{
+    WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(START_SERVER_TCP_CMD, PARAM_NUMS_4);
+    SpiDrv::sendParam((uint8_t*)&ipAddress, sizeof(ipAddress));
+    SpiDrv::sendParam(port);
+    SpiDrv::sendParam(&sock, 1);
+    SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(START_SERVER_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+}
+
+// Start server TCP on port specified
+void ServerDrv::startClient(uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_4);
+    SpiDrv::sendParam((uint8_t*)&ipAddress, sizeof(ipAddress));
+    SpiDrv::sendParam(port);
+    SpiDrv::sendParam(&sock, 1);
+    SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+}
+
+void ServerDrv::startClient(const char* host, uint8_t host_len, uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode)
+{
+    WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_5);
+    SpiDrv::sendParam((uint8_t*)host, host_len);
+    SpiDrv::sendParam((uint8_t*)&ipAddress, sizeof(ipAddress));
+    SpiDrv::sendParam(port);
+    SpiDrv::sendParam(&sock, 1);
+    SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
+
+    // pad to multiple of 4
+    int commandSize = 17 + host_len;
+    while (commandSize % 4) {
+        SpiDrv::readChar();
+        commandSize++;
+    }
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady(/* feed_watchdog = */ (protMode == TLS_BEARSSL_MODE));
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();  
+}
+
+// Start server TCP on port specified
+void ServerDrv::stopClient(uint8_t sock)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(STOP_CLIENT_TCP_CMD, PARAM_NUMS_1);
+    SpiDrv::sendParam(&sock, 1, LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(STOP_CLIENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+}
+
+
+uint8_t ServerDrv::getServerState(uint8_t sock)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(GET_STATE_TCP_CMD, PARAM_NUMS_1);
+    SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(GET_STATE_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+   return _data;
+}
+
+uint8_t ServerDrv::getClientState(uint8_t sock)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(GET_CLIENT_STATE_TCP_CMD, PARAM_NUMS_1);
+    SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(GET_CLIENT_STATE_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+   return _data;
+}
+
+uint16_t ServerDrv::availData(uint8_t sock)
+{
+    if (!SpiDrv::available()) {
+        return 0;
+    }
+
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1);
+    SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _dataLen = 0;
+	uint16_t len = 0;
+
+    SpiDrv::waitResponseCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1, (uint8_t*)&len,  &_dataLen);
+
+    SpiDrv::spiSlaveDeselect();
+
+    return len;
+}
+
+uint8_t ServerDrv::availServer(uint8_t sock)
+{
+    if (!SpiDrv::available()) {
+        return 255;
+    }
+
+    WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1);
+    SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _dataLen = 0;
+    uint16_t socket = 0;
+
+    SpiDrv::waitResponseCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1, (uint8_t*)&socket,  &_dataLen);
+
+    SpiDrv::spiSlaveDeselect();
+
+    return socket;
+}
+
+bool ServerDrv::getData(uint8_t sock, uint8_t *data, uint8_t peek)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(GET_DATA_TCP_CMD, PARAM_NUMS_2);
+    SpiDrv::sendParam(&sock, sizeof(sock));
+    SpiDrv::sendParam(peek, LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseData8(GET_DATA_TCP_CMD, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+    if (_dataLen!=0)
+    {
+        *data = _data;
+        return true;
+    }
+    return false;
+}
+
+bool ServerDrv::getDataBuf(uint8_t sock, uint8_t *_data, uint16_t *_dataLen)
+{
+    if (!SpiDrv::available())
+    {
+        *_dataLen = 0;
+        return false;
+    }
+    
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(GET_DATABUF_TCP_CMD, PARAM_NUMS_2);
+    SpiDrv::sendBuffer(&sock, sizeof(sock));
+    SpiDrv::sendBuffer((uint8_t *)_dataLen, sizeof(*_dataLen), LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    if (!SpiDrv::waitResponseData16(GET_DATABUF_TCP_CMD, _data, _dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+    if (*_dataLen!=0)
+    {
+        return true;
+    }
+    return false;
+}
+
+bool ServerDrv::insertDataBuf(uint8_t sock, const uint8_t *data, uint16_t _len)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(INSERT_DATABUF_CMD, PARAM_NUMS_2);
+    SpiDrv::sendBuffer(&sock, sizeof(sock));
+    SpiDrv::sendBuffer((uint8_t *)data, _len, LAST_PARAM);
+
+    // pad to multiple of 4
+    int commandSize = 9 + _len;
+    while (commandSize % 4) {
+        SpiDrv::readChar();
+        commandSize++;
+    }
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseData8(INSERT_DATABUF_CMD, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+    if (_dataLen!=0)
+    {
+        return (_data == 1);
+    }
+    return false;
+}
+
+bool ServerDrv::sendUdpData(uint8_t sock)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(SEND_DATA_UDP_CMD, PARAM_NUMS_1);
+    SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
+
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseData8(SEND_DATA_UDP_CMD, &_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+    if (_dataLen!=0)
+    {
+        return (_data == 1);
+    }
+    return false;
+}
+
+
+uint16_t ServerDrv::sendData(uint8_t sock, const uint8_t *data, uint16_t len)
+{
+	WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(SEND_DATA_TCP_CMD, PARAM_NUMS_2);
+    SpiDrv::sendBuffer(&sock, sizeof(sock));
+    SpiDrv::sendBuffer((uint8_t *)data, len, LAST_PARAM);
+
+    // pad to multiple of 4
+    int commandSize = 9 + len;
+    while (commandSize % 4) {
+        SpiDrv::readChar();
+        commandSize++;
+    }
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint16_t _data = 0;
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseData8(SEND_DATA_TCP_CMD, (uint8_t*)&_data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+
+    return _data;
+}
+
+
+uint8_t ServerDrv::checkDataSent(uint8_t sock)
+{
+	const uint16_t TIMEOUT_DATA_SENT = 25;
+    uint16_t timeout = 0;
+	uint8_t _data = 0;
+	uint8_t _dataLen = 0;
+
+	do {
+		WAIT_FOR_SLAVE_SELECT();
+		// Send Command
+		SpiDrv::sendCmd(DATA_SENT_TCP_CMD, PARAM_NUMS_1);
+		SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
+
+        // pad to multiple of 4
+        SpiDrv::readChar();
+        SpiDrv::readChar();
+
+        SpiDrv::spiSlaveDeselect();
+        //Wait the reply elaboration
+        SpiDrv::waitForSlaveReady();
+        SpiDrv::spiSlaveSelect();
+
+		// Wait for reply
+		if (!SpiDrv::waitResponseCmd(DATA_SENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
+		{
+			WARN("error waitResponse isDataSent");
+		}
+		SpiDrv::spiSlaveDeselect();
+
+		if (_data) timeout = 0;
+		else{
+			++timeout;
+			delay(100);
+		}
+
+	}while((_data==0)&&(timeout<TIMEOUT_DATA_SENT));
+    return (timeout==TIMEOUT_DATA_SENT)?0:1;
+}
+
+uint8_t ServerDrv::getSocket()
+{
+    WAIT_FOR_SLAVE_SELECT();
+
+    // Send Command
+    SpiDrv::sendCmd(GET_SOCKET_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_SOCKET_CMD, PARAM_NUMS_1, &_data, &_dataLen);
+
+    SpiDrv::spiSlaveDeselect();
+
+    return _data;
+}
+
+ServerDrv serverDrv;

lib/WiFiNINA/src/utility/server_drv.h

@@ -0,0 +1,69 @@
+/*
+  server_drv.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef Server_Drv_h
+#define Server_Drv_h
+
+#include <inttypes.h>
+#include "utility/wifi_spi.h"
+
+typedef enum eProtMode {TCP_MODE, UDP_MODE, TLS_MODE, UDP_MULTICAST_MODE, TLS_BEARSSL_MODE}tProtMode;
+
+class ServerDrv
+{
+public:
+
+    // Start server TCP on port specified
+    static void startServer(uint16_t port, uint8_t sock, uint8_t protMode=TCP_MODE);
+
+    static void startServer(uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode=TCP_MODE);
+
+    static void startClient(uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode=TCP_MODE);
+
+    static void startClient(const char* host, uint8_t host_len, uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode=TCP_MODE);
+
+    static void stopClient(uint8_t sock);
+                                                                                  
+    static uint8_t getServerState(uint8_t sock);
+
+    static uint8_t getClientState(uint8_t sock);
+
+    static bool getData(uint8_t sock, uint8_t *data, uint8_t peek = 0);
+
+    static bool getDataBuf(uint8_t sock, uint8_t *data, uint16_t *len);
+
+    static bool insertDataBuf(uint8_t sock, const uint8_t *_data, uint16_t _dataLen);
+
+    static uint16_t sendData(uint8_t sock, const uint8_t *data, uint16_t len);
+
+    static bool sendUdpData(uint8_t sock);
+
+    static uint16_t availData(uint8_t sock);
+
+    static uint8_t availServer(uint8_t sock);
+
+    static uint8_t checkDataSent(uint8_t sock);
+
+    static uint8_t getSocket();
+};
+
+extern ServerDrv serverDrv;
+
+#endif

lib/WiFiNINA/src/utility/spi_drv.cpp

@@ -0,0 +1,605 @@
+/*
+  spi_drv.cpp - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "Arduino.h"
+#include <SPI.h>
+#include "utility/spi_drv.h"
+#include "pins_arduino.h"
+
+#ifdef ARDUINO_SAMD_MKRVIDOR4000
+
+// check if a bitstream is already included
+#if __has_include(<VidorFPGA.h>)
+// yes, so use the existing VidorFPGA include
+#include <VidorFPGA.h>
+#else
+// otherwise, fallback to VidorPeripherals and it's bitstream
+#include <VidorPeripherals.h>
+#endif
+
+#define NINA_GPIO0    FPGA_NINA_GPIO0
+#define SPIWIFI_SS    FPGA_SPIWIFI_SS
+#define SPIWIFI_ACK   FPGA_SPIWIFI_ACK
+#define SPIWIFI_RESET FPGA_SPIWIFI_RESET
+
+#define pinMode(pin, mode)       FPGA.pinMode(pin, mode)
+#define digitalRead(pin)         FPGA.digitalRead(pin)
+#define digitalWrite(pin, value) FPGA.digitalWrite(pin, value)
+#endif
+
+//#define _DEBUG_
+extern "C" {
+#include "utility/debug.h"
+}
+
+static uint8_t SLAVESELECT = 10; // ss
+static uint8_t SLAVEREADY  = 7;  // handshake pin
+static uint8_t SLAVERESET  = 5;  // reset pin
+
+static bool inverted_reset = false;
+
+#define DELAY_TRANSFER()
+
+#ifndef SPIWIFI
+#define SPIWIFI SPI
+#endif
+
+#ifndef NINA_GPIOIRQ
+#define NINA_GPIOIRQ    NINA_GPIO0
+#endif
+
+bool SpiDrv::initialized = false;
+
+__attribute__((weak)) void wifi_nina_feed_watchdog()
+{
+    /* This function can be overwritten by a "strong" implementation
+     * in a higher level application, such as the ArduinoIoTCloud
+     * firmware stack.
+     */
+}
+
+void SpiDrv::begin()
+{
+#ifdef ARDUINO_SAMD_MKRVIDOR4000
+      FPGA.begin();
+#endif
+
+#ifdef SPIWIFI_SS
+      SLAVESELECT = SPIWIFI_SS;
+#endif
+
+#ifdef SPIWIFI_ACK
+      SLAVEREADY = SPIWIFI_ACK;
+#endif
+
+#ifdef SPIWIFI_RESET
+      SLAVERESET = (uint8_t)SPIWIFI_RESET;
+#endif
+
+#ifdef ARDUINO_SAMD_MKRVIDOR4000
+      inverted_reset = false;
+#else
+      if (SLAVERESET > PINS_COUNT) {
+        inverted_reset = true;
+        SLAVERESET = ~SLAVERESET;
+      }      
+#endif
+
+      pinMode(SLAVESELECT, OUTPUT);
+      pinMode(SLAVEREADY, INPUT);
+      pinMode(SLAVERESET, OUTPUT);
+      pinMode(NINA_GPIO0, OUTPUT);
+
+      digitalWrite(NINA_GPIO0, HIGH);
+      digitalWrite(SLAVESELECT, HIGH);
+      digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);
+      delay(10);
+      digitalWrite(SLAVERESET, inverted_reset ? LOW : HIGH);
+      delay(750);
+
+      digitalWrite(NINA_GPIO0, LOW);
+      pinMode(NINA_GPIOIRQ, INPUT);
+
+      SPIWIFI.begin();
+
+#ifdef _DEBUG_
+	  INIT_TRIGGER()
+#endif
+
+      initialized = true;
+}
+
+void SpiDrv::end() {
+    digitalWrite(SLAVERESET, inverted_reset ? HIGH : LOW);
+
+    pinMode(SLAVESELECT, INPUT);
+
+    SPIWIFI.end();
+
+    initialized = false;
+}
+
+void SpiDrv::spiSlaveSelect()
+{
+    SPIWIFI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
+    digitalWrite(SLAVESELECT,LOW);
+
+    // wait for up to 5 ms for the NINA to indicate it is not ready for transfer
+    // the timeout is only needed for the case when the shield or module is not present
+    for (unsigned long start = millis(); (digitalRead(SLAVEREADY) != HIGH) && (millis() - start) < 5;);
+}
+
+
+void SpiDrv::spiSlaveDeselect()
+{
+    digitalWrite(SLAVESELECT,HIGH);
+    SPIWIFI.endTransaction();
+}
+
+
+char SpiDrv::spiTransfer(volatile char data)
+{
+    char result = SPIWIFI.transfer(data);
+    DELAY_TRANSFER();
+
+    return result;                    // return the received byte
+}
+
+int SpiDrv::waitSpiChar(unsigned char waitChar)
+{
+    int timeout = TIMEOUT_CHAR;
+    unsigned char _readChar = 0;
+    do{
+        _readChar = readChar(); //get data byte
+        if (_readChar == ERR_CMD)
+        {
+        	WARN("Err cmd received\n");
+        	return -1;
+        }
+    }while((timeout-- > 0) && (_readChar != waitChar));
+    return  (_readChar == waitChar);
+}
+
+int SpiDrv::readAndCheckChar(char checkChar, char* readChar)
+{
+    getParam((uint8_t*)readChar);
+
+    return  (*readChar == checkChar);
+}
+
+char SpiDrv::readChar()
+{
+	uint8_t readChar = 0;
+	getParam(&readChar);
+	return readChar;
+}
+
+#define WAIT_START_CMD(x) waitSpiChar(START_CMD)
+
+#define IF_CHECK_START_CMD(x)                      \
+    if (!WAIT_START_CMD(_data))                 \
+    {                                           \
+        TOGGLE_TRIGGER()                        \
+        WARN("Error waiting START_CMD");        \
+        return 0;                               \
+    }else                                       \
+
+#define CHECK_DATA(check, x)                   \
+        if (!readAndCheckChar(check, &x))   \
+        {                                               \
+        	TOGGLE_TRIGGER()                        \
+            WARN("Reply error");                        \
+            INFO2(check, (uint8_t)x);							\
+            return 0;                                   \
+        }else                                           \
+
+#define waitSlaveReady() (digitalRead(SLAVEREADY) == LOW)
+#define waitSlaveSign() (digitalRead(SLAVEREADY) == HIGH)
+#define waitSlaveSignalH() while(digitalRead(SLAVEREADY) != HIGH){}
+#define waitSlaveSignalL() while(digitalRead(SLAVEREADY) != LOW){}
+
+void SpiDrv::waitForSlaveSign()
+{
+	while (!waitSlaveSign());
+}
+
+void SpiDrv::waitForSlaveReady(bool const feed_watchdog)
+{
+    unsigned long const start = millis();
+	while (!waitSlaveReady())
+    {
+        if (feed_watchdog) {
+            if ((millis() - start) < 10000) {
+                wifi_nina_feed_watchdog();
+            }
+        }
+    }
+}
+
+void SpiDrv::getParam(uint8_t* param)
+{
+    // Get Params data
+    *param = spiTransfer(DUMMY_DATA);
+    DELAY_TRANSFER();
+}
+
+int SpiDrv::waitResponseCmd(uint8_t cmd, uint8_t numParam, uint8_t* param, uint8_t* param_len)
+{
+    char _data = 0;
+    int ii = 0;
+
+    IF_CHECK_START_CMD(_data)
+    {
+        CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+        CHECK_DATA(numParam, _data)
+        {
+            readParamLen8(param_len);
+            for (ii=0; ii<(*param_len); ++ii)
+            {
+                // Get Params data
+                //param[ii] = spiTransfer(DUMMY_DATA);
+                getParam(&param[ii]);
+            } 
+        }         
+
+        readAndCheckChar(END_CMD, &_data);
+    }     
+    
+    return 1;
+}
+/*
+int SpiDrv::waitResponse(uint8_t cmd, uint8_t numParam, uint8_t* param, uint16_t* param_len)
+{
+    char _data = 0;
+    int i =0, ii = 0;
+
+    IF_CHECK_START_CMD(_data)
+    {
+        CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+        CHECK_DATA(numParam, _data);
+        {
+            readParamLen16(param_len);
+            for (ii=0; ii<(*param_len); ++ii)
+            {
+                // Get Params data
+                param[ii] = spiTransfer(DUMMY_DATA);
+            } 
+        }         
+
+        readAndCheckChar(END_CMD, &_data);
+    }     
+    
+    return 1;
+}
+*/
+
+int SpiDrv::waitResponseData16(uint8_t cmd, uint8_t* param, uint16_t* param_len)
+{
+    char _data = 0;
+    uint16_t ii = 0;
+
+    IF_CHECK_START_CMD(_data)
+    {
+        CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+        uint8_t numParam = readChar();
+        if (numParam != 0)
+        {        
+            readParamLen16(param_len);
+            for (ii=0; ii<(*param_len); ++ii)
+            {
+                // Get Params data
+                param[ii] = spiTransfer(DUMMY_DATA);
+            } 
+        }         
+
+        readAndCheckChar(END_CMD, &_data);
+    }     
+    
+    return 1;
+}
+
+int SpiDrv::waitResponseData8(uint8_t cmd, uint8_t* param, uint8_t* param_len)
+{
+    char _data = 0;
+    int ii = 0;
+
+    IF_CHECK_START_CMD(_data)
+    {
+        CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+        uint8_t numParam = readChar();
+        if (numParam != 0)
+        {        
+            readParamLen8(param_len);
+            for (ii=0; ii<(*param_len); ++ii)
+            {
+                // Get Params data
+                param[ii] = spiTransfer(DUMMY_DATA);
+            } 
+        }         
+
+        readAndCheckChar(END_CMD, &_data);
+    }     
+    
+    return 1;
+}
+
+int SpiDrv::waitResponseParams(uint8_t cmd, uint8_t numParam, tParam* params)
+{
+    char _data = 0;
+    int i =0, ii = 0;
+
+
+    IF_CHECK_START_CMD(_data)
+    {
+        CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+        uint8_t _numParam = readChar();
+        if (_numParam != 0)
+        {        
+            for (i=0; i<_numParam; ++i)
+            {
+                params[i].paramLen = readParamLen8();
+                for (ii=0; ii<params[i].paramLen; ++ii)
+                {
+                    // Get Params data
+                    params[i].param[ii] = spiTransfer(DUMMY_DATA);
+                } 
+            }
+        } else
+        {
+            WARN("Error numParam == 0");
+            return 0;
+        }
+
+        if (numParam != _numParam)
+        {
+            WARN("Mismatch numParam");
+            return 0;
+        }
+
+        readAndCheckChar(END_CMD, &_data);
+    }         
+    return 1;
+}
+
+/*
+int SpiDrv::waitResponse(uint8_t cmd, tParam* params, uint8_t* numParamRead, uint8_t maxNumParams)
+{
+    char _data = 0;
+    int i =0, ii = 0;
+
+    IF_CHECK_START_CMD(_data)
+    {
+        CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+        uint8_t numParam = readChar();
+
+        if (numParam > maxNumParams)
+        {
+            numParam = maxNumParams;
+        }
+        *numParamRead = numParam;
+        if (numParam != 0)
+        {
+            for (i=0; i<numParam; ++i)
+            {
+                params[i].paramLen = readParamLen8();
+
+                for (ii=0; ii<params[i].paramLen; ++ii)
+                {
+                    // Get Params data
+                    params[i].param[ii] = spiTransfer(DUMMY_DATA);
+                } 
+            }
+        } else
+        {
+            WARN("Error numParams == 0");
+            Serial.println(cmd, 16);
+            return 0;
+        }
+        readAndCheckChar(END_CMD, &_data);
+    }         
+    return 1;
+}
+*/
+
+int SpiDrv::waitResponse(uint8_t cmd, uint8_t* numParamRead, uint8_t** params, uint8_t maxNumParams)
+{
+    char _data = 0;
+    int i =0, ii = 0;
+
+    char    *index[WL_SSID_MAX_LENGTH];
+
+    for (i = 0 ; i < WL_NETWORKS_LIST_MAXNUM ; i++)
+            index[i] = (char *)params + WL_SSID_MAX_LENGTH*i;
+
+    IF_CHECK_START_CMD(_data)
+    {
+        CHECK_DATA(cmd | REPLY_FLAG, _data){};
+
+        uint8_t numParam = readChar();
+
+        if (numParam > maxNumParams)
+        {
+            numParam = maxNumParams;
+        }
+        *numParamRead = numParam;
+        if (numParam != 0)
+        {
+            for (i=0; i<numParam; ++i)
+            {
+            	uint8_t paramLen = readParamLen8();
+                for (ii=0; ii<paramLen; ++ii)
+                {
+                	//ssid[ii] = spiTransfer(DUMMY_DATA);
+                    // Get Params data
+                    index[i][ii] = (uint8_t)spiTransfer(DUMMY_DATA);
+
+                }
+                index[i][ii]=0;
+            }
+        } else
+        {
+            WARN("Error numParams == 0");
+            readAndCheckChar(END_CMD, &_data);
+            return 0;
+        }
+        readAndCheckChar(END_CMD, &_data);
+    }
+    return 1;
+}
+
+void SpiDrv::sendParamNoLen(uint8_t* param, size_t param_len, uint8_t lastParam)
+{
+    size_t i = 0;
+    // Send Spi paramLen
+    sendParamLen8(0);
+
+    // Send Spi param data
+    for (i=0; i<param_len; ++i)
+    {
+        spiTransfer(param[i]);
+    }
+
+    // if lastParam==1 Send Spi END CMD
+    if (lastParam == 1)
+        spiTransfer(END_CMD);
+}
+
+void SpiDrv::sendParam(uint8_t* param, uint8_t param_len, uint8_t lastParam)
+{
+    int i = 0;
+    // Send Spi paramLen
+    sendParamLen8(param_len);
+
+    // Send Spi param data
+    for (i=0; i<param_len; ++i)
+    {
+        spiTransfer(param[i]);
+    }
+
+    // if lastParam==1 Send Spi END CMD
+    if (lastParam == 1)
+        spiTransfer(END_CMD);
+}
+
+void SpiDrv::sendParamLen8(uint8_t param_len)
+{
+    // Send Spi paramLen
+    spiTransfer(param_len);
+}
+
+void SpiDrv::sendParamLen16(uint16_t param_len)
+{
+    // Send Spi paramLen
+    spiTransfer((uint8_t)((param_len & 0xff00)>>8));
+    spiTransfer((uint8_t)(param_len & 0xff));
+}
+
+uint8_t SpiDrv::readParamLen8(uint8_t* param_len)
+{
+    uint8_t _param_len = spiTransfer(DUMMY_DATA);
+    if (param_len != NULL)
+    {
+        *param_len = _param_len;
+    }
+    return _param_len;
+}
+
+uint16_t SpiDrv::readParamLen16(uint16_t* param_len)
+{
+    uint16_t _param_len = spiTransfer(DUMMY_DATA)<<8 | (spiTransfer(DUMMY_DATA)& 0xff);
+    if (param_len != NULL)
+    {
+        *param_len = _param_len;
+    }
+    return _param_len;
+}
+
+
+void SpiDrv::sendBuffer(uint8_t* param, uint16_t param_len, uint8_t lastParam)
+{
+    uint16_t i = 0;
+
+    // Send Spi paramLen
+    sendParamLen16(param_len);
+
+    // Send Spi param data
+    for (i=0; i<param_len; ++i)
+    {
+        spiTransfer(param[i]);
+    }
+
+    // if lastParam==1 Send Spi END CMD
+    if (lastParam == 1)
+        spiTransfer(END_CMD);
+}
+
+
+void SpiDrv::sendParam(uint16_t param, uint8_t lastParam)
+{
+    // Send Spi paramLen
+    sendParamLen8(2);
+
+    spiTransfer((uint8_t)((param & 0xff00)>>8));
+    spiTransfer((uint8_t)(param & 0xff));
+
+    // if lastParam==1 Send Spi END CMD
+    if (lastParam == 1)
+        spiTransfer(END_CMD);
+}
+
+/* Cmd Struct Message */
+/* _________________________________________________________________________________  */
+/*| START CMD | C/R  | CMD  |[TOT LEN]| N.PARAM | PARAM LEN | PARAM  | .. | END CMD | */
+/*|___________|______|______|_________|_________|___________|________|____|_________| */
+/*|   8 bit   | 1bit | 7bit |  8bit   |  8bit   |   8bit    | nbytes | .. |   8bit  | */
+/*|___________|______|______|_________|_________|___________|________|____|_________| */
+
+void SpiDrv::sendCmd(uint8_t cmd, uint8_t numParam)
+{
+    // Send Spi START CMD
+    spiTransfer(START_CMD);
+
+    // Send Spi C + cmd
+    spiTransfer(cmd & ~(REPLY_FLAG));
+
+    // Send Spi totLen
+    //spiTransfer(totLen);
+
+    // Send Spi numParam
+    spiTransfer(numParam);
+
+    // If numParam == 0 send END CMD
+    if (numParam == 0)
+        spiTransfer(END_CMD);
+
+}
+
+int SpiDrv::available()
+{
+    return (digitalRead(NINA_GPIOIRQ) != LOW);
+}
+
+SpiDrv spiDrv;

lib/WiFiNINA/src/utility/spi_drv.h

@@ -0,0 +1,109 @@
+/*
+  spi_drv.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef SPI_Drv_h
+#define SPI_Drv_h
+
+#include <inttypes.h>
+#include "utility/wifi_spi.h"
+
+#define SPI_START_CMD_DELAY 	10
+
+#define NO_LAST_PARAM   0
+#define LAST_PARAM      1
+
+#define DUMMY_DATA  0xFF
+
+#define WAIT_FOR_SLAVE_SELECT()	      \
+	if (!SpiDrv::initialized) {           \
+		SpiDrv::begin();      \
+	}                             \
+	SpiDrv::waitForSlaveReady();  \
+	SpiDrv::spiSlaveSelect();
+
+class SpiDrv
+{
+private:
+	//static bool waitSlaveReady();
+	static void waitForSlaveSign();
+	static void getParam(uint8_t* param);
+public:
+    static bool initialized;
+
+    static void begin();
+
+    static void end();
+    
+    static void spiDriverInit();
+        
+    static void spiSlaveSelect();
+    
+    static void spiSlaveDeselect();
+    
+    static char spiTransfer(volatile char data);
+
+    static void waitForSlaveReady(bool const feed_watchdog = false);
+
+    //static int waitSpiChar(char waitChar, char* readChar);
+
+    static int waitSpiChar(unsigned char waitChar);
+    
+    static int readAndCheckChar(char checkChar, char* readChar);
+
+    static char readChar();
+
+    static int waitResponseParams(uint8_t cmd, uint8_t numParam, tParam* params);
+    
+    static int waitResponseCmd(uint8_t cmd, uint8_t numParam, uint8_t* param, uint8_t* param_len);
+
+    static int waitResponseData8(uint8_t cmd, uint8_t* param, uint8_t* param_len);
+     
+    static int waitResponseData16(uint8_t cmd, uint8_t* param, uint16_t* param_len);
+ /*
+    static int waitResponse(uint8_t cmd, tParam* params, uint8_t* numParamRead, uint8_t maxNumParams);
+    
+    static int waitResponse(uint8_t cmd, uint8_t numParam, uint8_t* param, uint16_t* param_len);
+*/
+    static int waitResponse(uint8_t cmd, uint8_t* numParamRead, uint8_t** params, uint8_t maxNumParams);
+
+    static void sendParam(uint8_t* param, uint8_t param_len, uint8_t lastParam = NO_LAST_PARAM);
+
+    static void sendParamNoLen(uint8_t* param, size_t param_len, uint8_t lastParam = NO_LAST_PARAM);
+
+    static void sendParamLen8(uint8_t param_len);
+
+    static void sendParamLen16(uint16_t param_len);
+
+    static uint8_t readParamLen8(uint8_t* param_len = NULL);
+
+    static uint16_t readParamLen16(uint16_t* param_len = NULL);
+
+    static void sendBuffer(uint8_t* param, uint16_t param_len, uint8_t lastParam = NO_LAST_PARAM);
+
+    static void sendParam(uint16_t param, uint8_t lastParam = NO_LAST_PARAM);
+    
+    static void sendCmd(uint8_t cmd, uint8_t numParam);
+
+    static int available();
+};                                                                 
+
+extern SpiDrv spiDrv;
+
+#endif

lib/WiFiNINA/src/utility/wifi_drv.h

@@ -0,0 +1,326 @@
+/*
+  wifi_drv.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef WiFi_Drv_h
+#define WiFi_Drv_h
+
+#include <inttypes.h>
+#include "utility/wifi_spi.h"
+#include "IPAddress.h"
+#include "WiFiUdp.h"
+#include "WiFiClient.h"
+
+// Key index length
+#define KEY_IDX_LEN     1
+// 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
+
+class WiFiDrv
+{
+private:
+	// settings of requested network
+	static char 	_networkSsid[WL_NETWORKS_LIST_MAXNUM][WL_SSID_MAX_LENGTH];
+
+	// firmware version string in the format a.b.c
+	static char 	fwVersion[WL_FW_VER_LENGTH];
+
+	// settings of current selected network
+	static char 	_ssid[WL_SSID_MAX_LENGTH];
+	static uint8_t 	_bssid[WL_MAC_ADDR_LENGTH];
+	static uint8_t 	_mac[WL_MAC_ADDR_LENGTH];
+	static uint8_t  _localIp[WL_IPV4_LENGTH];
+	static uint8_t  _subnetMask[WL_IPV4_LENGTH];
+	static uint8_t  _gatewayIp[WL_IPV4_LENGTH];
+
+	/*
+	 * Get network Data information
+	 */
+    static void getNetworkData(uint8_t *ip, uint8_t *mask, uint8_t *gwip);
+
+    static uint8_t reqHostByName(const char* aHostname);
+
+    static int getHostByName(IPAddress& aResult);
+
+    /*
+     * Get remote Data information on UDP socket
+     */
+    static void getRemoteData(uint8_t sock, uint8_t *ip, uint8_t *port);
+
+public:
+
+    /*
+     * Driver initialization
+     */
+    static void wifiDriverInit();
+
+    static void wifiDriverDeinit();
+
+    /*
+     * Set the desired network which the connection manager should try to
+     * connect to.
+     *
+     * The ssid of the desired network should be specified.
+     *
+     * param ssid: The ssid of the desired network.
+     * param ssid_len: Length of ssid string.
+     * return: WL_SUCCESS or WL_FAILURE
+	 */
+    static int8_t wifiSetNetwork(const char* ssid, uint8_t ssid_len);
+
+    /* Start WiFi connection with passphrase
+     * the most secure supported mode will be automatically selected
+     *
+     * param ssid: Pointer to the SSID string.
+     * param ssid_len: Length of ssid string.
+     * param passphrase: Passphrase. Valid characters in a passphrase
+     *        must be between ASCII 32-126 (decimal).
+     * param len: Length of passphrase string.
+     * return: WL_SUCCESS or WL_FAILURE
+     */
+    static int8_t wifiSetPassphrase(const char* ssid, uint8_t ssid_len, const char *passphrase, const uint8_t len);
+
+    /* Start WiFi connection with WEP encryption.
+     * Configure a key into the device. The key type (WEP-40, WEP-104)
+     * is determined by the size of the key (5 bytes for WEP-40, 13 bytes for WEP-104).
+     *
+     * param ssid: Pointer to the SSID string.
+     * param ssid_len: Length of ssid string.
+     * param key_idx: The key index to set. Valid values are 0-3.
+     * param key: Key input buffer.
+     * param len: Length of key string.
+     * return: WL_SUCCESS or WL_FAILURE
+     */
+    static int8_t wifiSetKey(const char* ssid, uint8_t ssid_len, uint8_t key_idx, const void *key, const uint8_t len);
+
+    static int8_t wifiSetApNetwork(const char* ssid, uint8_t ssid_len);
+    static int8_t wifiSetApPassphrase(const char* ssid, uint8_t ssid_len, const char *passphrase, const uint8_t len);
+
+    /* Set ip configuration disabling dhcp client
+        *
+        * param validParams: set the number of parameters that we want to change
+        * 					 i.e. validParams = 1 means that we'll change only ip address
+        * 					 	  validParams = 3 means that we'll change ip address, gateway and netmask
+        * param local_ip: 	Static ip configuration
+        * param gateway: 	Static gateway configuration
+        * param subnet: 	Static subnet mask configuration
+        */
+    static void config(uint8_t validParams, uint32_t local_ip, uint32_t gateway, uint32_t subnet);
+
+    /* Set DNS ip configuration
+           *
+           * param validParams: set the number of parameters that we want to change
+           * 					 i.e. validParams = 1 means that we'll change only dns_server1
+           * 					 	  validParams = 2 means that we'll change dns_server1 and dns_server2
+           * param dns_server1: Static DNS server1 configuration
+           * param dns_server2: Static DNS server2 configuration
+           */
+    static void setDNS(uint8_t validParams, uint32_t dns_server1, uint32_t dns_server2);
+
+    static void setHostname(const char* hostname);
+
+    /*
+     * Disconnect from the network
+     *
+     * return: WL_SUCCESS or WL_FAILURE
+     */
+    static int8_t disconnect();
+
+    static uint8_t getReasonCode();
+
+    /*
+     * Disconnect from the network
+     *
+     * return: one value of wl_status_t enum
+     */
+    static uint8_t getConnectionStatus();
+
+    /*
+     * Get the interface MAC address.
+     *
+     * return: pointer to uint8_t array with length WL_MAC_ADDR_LENGTH
+     */
+    static uint8_t* getMacAddress();
+
+    /*
+     * Get the interface IP address.
+     *
+     * return: copy the ip address value in IPAddress object
+     */
+    static void getIpAddress(IPAddress& ip);
+
+    /*
+     * Get the interface subnet mask address.
+     *
+     * return: copy the subnet mask address value in IPAddress object
+     */
+    static void getSubnetMask(IPAddress& mask);
+
+    /*
+     * Get the gateway ip address.
+     *
+     * return: copy the gateway ip address value in IPAddress object
+     */
+    static void getGatewayIP(IPAddress& ip);
+
+    /*
+     * Return the current SSID associated with the network
+     *
+     * return: ssid string
+     */
+    static const char* getCurrentSSID();
+
+    /*
+     * Return the current BSSID associated with the network.
+     * It is the MAC address of the Access Point
+     *
+     * return: pointer to uint8_t array with length WL_MAC_ADDR_LENGTH
+     */
+    static uint8_t* getCurrentBSSID();
+
+    /*
+     * Return the current RSSI /Received Signal Strength in dBm)
+     * associated with the network
+     *
+     * return: signed value
+     */
+    static int32_t getCurrentRSSI();
+
+    /*
+     * Return the Encryption Type associated with the network
+     *
+     * return: one value of wl_enc_type enum
+     */
+    static uint8_t getCurrentEncryptionType();
+
+    /*
+     * Start scan WiFi networks available
+     *
+     * return: Number of discovered networks
+     */
+    static int8_t startScanNetworks();
+
+    /*
+     * Get the networks available
+     *
+     * return: Number of discovered networks
+     */
+    static uint8_t getScanNetworks();
+
+    /*
+     * Return the SSID discovered during the network scan.
+     *
+     * param networkItem: specify from which network item want to get the information
+	 *
+     * return: ssid string of the specified item on the networks scanned list
+     */
+    static const char* getSSIDNetoworks(uint8_t networkItem);
+
+    /*
+     * Return the RSSI of the networks discovered during the scanNetworks
+     *
+     * param networkItem: specify from which network item want to get the information
+	 *
+     * return: signed value of RSSI of the specified item on the networks scanned list
+     */
+    static int32_t getRSSINetoworks(uint8_t networkItem);
+
+    /*
+     * Return the encryption type of the networks discovered during the scanNetworks
+     *
+     * param networkItem: specify from which network item want to get the information
+	 *
+     * return: encryption type (enum wl_enc_type) of the specified item on the networks scanned list
+     */
+    static uint8_t getEncTypeNetowrks(uint8_t networkItem);
+
+    static uint8_t* getBSSIDNetowrks(uint8_t networkItem, uint8_t* bssid);
+
+    static uint8_t getChannelNetowrks(uint8_t networkItem);
+
+    /*
+     * Resolve the given hostname to an IP address.
+     * param aHostname: Name to be resolved
+     * param aResult: IPAddress structure to store the returned IP address
+     * result: 1 if aIPAddrString was successfully converted to an IP address,
+     *          else error code
+     */
+    static int getHostByName(const char* aHostname, IPAddress& aResult);
+
+    /*
+     * Get the firmware version
+     * result: version as string with this format a.b.c
+     */
+    static const char* getFwVersion();
+
+    static uint32_t getTime();
+
+    static void setPowerMode(uint8_t mode);
+
+    static int8_t wifiSetApNetwork(const char* ssid, uint8_t ssid_len, uint8_t channel);
+    static int8_t wifiSetApPassphrase(const char* ssid, uint8_t ssid_len, const char *passphrase, const uint8_t len, uint8_t channel);
+    static int8_t wifiSetEnterprise(uint8_t eapType,
+                                    const char* ssid, uint8_t ssid_len,
+                                    const char *username, const uint8_t username_len,
+                                    const char *password, const uint8_t password_len,
+                                    const char *identity, const uint8_t identity_len,
+                                    const char* ca_cert, uint16_t ca_cert_len);
+
+
+    static int16_t ping(uint32_t ipAddress, uint8_t ttl);
+
+    static void debug(uint8_t on);
+    static float getTemperature();
+    static void pinMode(uint8_t pin, uint8_t mode);
+    static void digitalWrite(uint8_t pin, uint8_t value);
+    static void analogWrite(uint8_t pin, uint8_t value);
+
+    static int8_t downloadFile(const char* url, uint8_t url_len, const char *filename, uint8_t filename_len);
+    static int8_t downloadOTA(const char* url, uint8_t url_len);
+    static int8_t renameFile(const char * old_file_name, uint8_t const old_file_name_len, const char * new_file_name, uint8_t const new_file_name_len);
+
+    static int8_t fileOperation(uint8_t operation, const char *filename, uint8_t filename_len, uint32_t offset, uint8_t* buffer, uint32_t len);
+
+    static int8_t readFile(const char *filename, uint8_t filename_len, uint32_t offset, uint8_t* buffer, uint32_t buffer_len) {
+        return fileOperation(READ_FILE, filename, filename_len, offset, buffer, buffer_len);
+    };
+    static int8_t writeFile(const char *filename, uint8_t filename_len, uint32_t offset, uint8_t* buffer, uint32_t buffer_len) {
+        return fileOperation(WRITE_FILE, filename, filename_len, offset, buffer, buffer_len);
+    };
+    static int8_t deleteFile(const char *filename, uint8_t filename_len)  {
+        return fileOperation(DELETE_FILE, filename, filename_len, 0, NULL, 0);
+    };
+    static int8_t existsFile(const char *filename, uint8_t filename_len, uint32_t* len)  {
+        int32_t length = 0;
+        fileOperation(EXISTS_FILE, filename, filename_len, 0, (uint8_t*)&length, sizeof(length));
+        *len = length;
+        return length >= 0;
+    };
+
+    static void applyOTA();
+
+    friend class WiFiUDP;
+    friend class WiFiClient;
+};
+
+extern WiFiDrv wiFiDrv;
+
+#endif

lib/WiFiNINA/src/utility/wifi_spi.h

@@ -0,0 +1,203 @@
+/*
+  wifi_spi.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef WiFi_Spi_h
+#define WiFi_Spi_h
+
+#include <inttypes.h>
+#include "utility/wl_definitions.h"
+
+#define CMD_FLAG        0
+#define REPLY_FLAG      1<<7
+#define DATA_FLAG 		0x40
+
+#define WIFI_SPI_ACK        1
+#define WIFI_SPI_ERR        0xFF
+
+#define TIMEOUT_CHAR    1000
+
+//#define	MAX_SOCK_NUM		4	/**< Maxmium number of socket  */
+#define NO_SOCKET_AVAIL     255
+
+#define START_CMD   0xE0
+#define END_CMD     0xEE
+#define ERR_CMD   	0xEF
+#define CMD_POS			1		// Position of Command OpCode on SPI stream
+#define PARAM_LEN_POS 	2		// Position of Param len on SPI stream
+
+  
+enum {
+	SET_NET_CMD 		= 0x10,
+	SET_PASSPHRASE_CMD	= 0x11,
+	SET_KEY_CMD	        = 0x12,
+//	TEST_CMD	        = 0x13,
+	SET_IP_CONFIG_CMD	= 0x14,
+	SET_DNS_CONFIG_CMD	= 0x15,
+	SET_HOSTNAME_CMD	= 0x16,
+	SET_POWER_MODE_CMD	= 0x17,
+	SET_AP_NET_CMD		= 0x18,
+	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,
+	GET_MACADDR_CMD		= 0x22,
+	GET_CURR_SSID_CMD	= 0x23,
+	GET_CURR_BSSID_CMD	= 0x24,
+	GET_CURR_RSSI_CMD	= 0x25,
+	GET_CURR_ENCT_CMD	= 0x26,
+	SCAN_NETWORKS		= 0x27,
+	START_SERVER_TCP_CMD= 0x28,
+	GET_STATE_TCP_CMD   = 0x29,
+	DATA_SENT_TCP_CMD	= 0x2A,
+    AVAIL_DATA_TCP_CMD	= 0x2B,
+    GET_DATA_TCP_CMD	= 0x2C,
+    START_CLIENT_TCP_CMD= 0x2D,
+    STOP_CLIENT_TCP_CMD = 0x2E,
+    GET_CLIENT_STATE_TCP_CMD= 0x2F,
+    DISCONNECT_CMD		= 0x30,
+//	GET_IDX_SSID_CMD	= 0x31,
+	GET_IDX_RSSI_CMD	= 0x32,
+	GET_IDX_ENCT_CMD	= 0x33,
+	REQ_HOST_BY_NAME_CMD= 0x34,
+	GET_HOST_BY_NAME_CMD= 0x35,
+	START_SCAN_NETWORKS	= 0x36,
+	GET_FW_VERSION_CMD	= 0x37,
+//	GET_TEST_CMD		= 0x38,
+	SEND_DATA_UDP_CMD	= 0x39,
+	GET_REMOTE_DATA_CMD = 0x3A,
+	GET_TIME_CMD		= 0x3B,
+	GET_IDX_BSSID		= 0x3C,
+	GET_IDX_CHANNEL_CMD = 0x3D,
+	PING_CMD			= 0x3E,
+	GET_SOCKET_CMD		= 0x3F,
+
+    // All command with DATA_FLAG 0x40 send a 16bit Len
+	SET_ENT_CMD			= 0x40,
+
+	SEND_DATA_TCP_CMD		= 0x44,
+    GET_DATABUF_TCP_CMD		= 0x45,
+    INSERT_DATABUF_CMD		= 0x46,
+
+    // regular format commands
+    SET_PIN_MODE		= 0x50,
+    SET_DIGITAL_WRITE	= 0x51,
+    SET_ANALOG_WRITE	= 0x52,
+
+    // regular format commands
+    WRITE_FILE			= 0x60,
+    READ_FILE			= 0x61,
+    DELETE_FILE			= 0x62,
+    EXISTS_FILE			= 0x63,
+    DOWNLOAD_FILE		= 0x64,
+    APPLY_OTA_COMMAND	= 0x65,
+	RENAME_FILE			= 0x66,
+	DOWNLOAD_OTA		= 0x67,
+};
+
+
+enum wl_tcp_state {
+  CLOSED      = 0,
+  LISTEN      = 1,
+  SYN_SENT    = 2,
+  SYN_RCVD    = 3,
+  ESTABLISHED = 4,
+  FIN_WAIT_1  = 5,
+  FIN_WAIT_2  = 6,
+  CLOSE_WAIT  = 7,
+  CLOSING     = 8,
+  LAST_ACK    = 9,
+  TIME_WAIT   = 10
+};
+
+
+enum numParams{
+    PARAM_NUMS_0,
+    PARAM_NUMS_1,
+    PARAM_NUMS_2,
+    PARAM_NUMS_3,
+    PARAM_NUMS_4,
+    PARAM_NUMS_5,
+    PARAM_NUMS_6,
+    MAX_PARAM_NUMS
+};
+
+#define MAX_PARAMS MAX_PARAM_NUMS-1
+#define PARAM_LEN_SIZE 1
+
+typedef struct  __attribute__((__packed__))
+{
+	uint8_t     paramLen;
+	char*	    param;
+}tParam;
+
+typedef struct  __attribute__((__packed__))
+{
+	uint16_t     dataLen;
+	char*	     data;
+}tDataParam;
+
+
+typedef struct  __attribute__((__packed__))
+{
+	unsigned char	cmd;
+	unsigned char	tcmd;
+	unsigned char	nParam;
+	tParam	params[MAX_PARAMS];
+}tSpiMsg;
+
+typedef struct  __attribute__((__packed__))
+{
+	unsigned char	cmd;
+	unsigned char	tcmd;
+	unsigned char	nParam;
+	tDataParam		params[MAX_PARAMS];
+}tSpiMsgData;
+
+
+typedef struct  __attribute__((__packed__))
+{
+	unsigned char	cmd;
+	unsigned char	tcmd;
+	//unsigned char	totLen;
+	unsigned char	nParam;
+}tSpiHdr;
+
+typedef struct  __attribute__((__packed__))
+{
+	uint8_t     paramLen;
+	uint32_t	param;
+}tLongParam;
+
+typedef struct  __attribute__((__packed__))
+{
+	uint8_t     paramLen;
+	uint16_t	param;
+}tIntParam;
+
+typedef struct  __attribute__((__packed__))
+{
+	uint8_t     paramLen;
+	uint8_t	param;
+}tByteParam;
+
+#endif

lib/WiFiNINA/src/utility/wl_definitions.h

@@ -0,0 +1,77 @@
+/*
+  wl_definitions.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+ * wl_definitions.h
+ *
+ *  Created on: Mar 6, 2011
+ *      Author: dlafauci
+ */
+
+#ifndef WL_DEFINITIONS_H_
+#define WL_DEFINITIONS_H_
+
+// Maximum size of a SSID
+#define WL_SSID_MAX_LENGTH 32
+// Length of passphrase. Valid lengths are 8-63.
+#define WL_WPA_KEY_MAX_LENGTH 63
+// Length of key in bytes. Valid values are 5 and 13.
+#define WL_WEP_KEY_MAX_LENGTH 13
+// Size of a MAC-address or BSSID
+#define WL_MAC_ADDR_LENGTH 6
+// Size of a MAC-address or BSSID
+#define WL_IPV4_LENGTH 4
+// Maximum size of a SSID list
+#define WL_NETWORKS_LIST_MAXNUM	10
+// Maxmium number of socket
+#define	WIFI_MAX_SOCK_NUM	10
+// Socket not available constant
+#define SOCK_NOT_AVAIL  255
+// Default state value for WiFi state field
+#define NA_STATE -1
+
+typedef enum {
+	WL_NO_SHIELD = 255,
+        WL_NO_MODULE = WL_NO_SHIELD,
+        WL_IDLE_STATUS = 0,
+        WL_NO_SSID_AVAIL,
+        WL_SCAN_COMPLETED,
+        WL_CONNECTED,
+        WL_CONNECT_FAILED,
+        WL_CONNECTION_LOST,
+        WL_DISCONNECTED,
+        WL_AP_LISTENING,
+        WL_AP_CONNECTED,
+        WL_AP_FAILED
+} wl_status_t;
+
+/* Encryption modes */
+enum wl_enc_type {  /* Values map to 802.11 encryption suites... */
+        ENC_TYPE_WEP  = 5,
+        ENC_TYPE_TKIP = 2,
+        ENC_TYPE_CCMP = 4,
+        /* ... except these two, 7 and 8 are reserved in 802.11-2007 */
+        ENC_TYPE_NONE = 7,
+        ENC_TYPE_AUTO = 8,
+
+        ENC_TYPE_UNKNOWN = 255
+};
+
+
+#endif /* WL_DEFINITIONS_H_ */

lib/WiFiNINA/src/utility/wl_types.h

@@ -0,0 +1,57 @@
+/*
+  wl_types.h - Library for Arduino Wifi shield.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+  Copyright (c) 2011-2014 Arduino.  All right reserved.
+
+  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
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+ * wl_types.h
+ *
+ *  Created on: Jul 30, 2010
+ *      Author: dlafauci
+ */
+
+
+#ifndef	_WL_TYPES_H_
+#define	_WL_TYPES_H_
+
+#include <inttypes.h>
+
+typedef enum {
+        WL_FAILURE = -1,
+        WL_SUCCESS = 1,
+} wl_error_code_t;
+
+/* Authentication modes */
+enum wl_auth_mode {
+        AUTH_MODE_INVALID,
+        AUTH_MODE_AUTO,
+        AUTH_MODE_OPEN_SYSTEM,
+        AUTH_MODE_SHARED_KEY,
+        AUTH_MODE_WPA,
+        AUTH_MODE_WPA2,
+        AUTH_MODE_WPA_PSK,
+        AUTH_MODE_WPA2_PSK
+};
+
+typedef enum {
+  WL_PING_DEST_UNREACHABLE = -1,
+  WL_PING_TIMEOUT = -2,
+  WL_PING_UNKNOWN_HOST = -3,
+  WL_PING_ERROR = -4
+} wl_ping_result_t;
+
+#endif //_WL_TYPES_H_