Moved WiFi library in the proper place

30 files changed, 4275 insertions, 0 deletions

diff --git a/libraries/WiFi/WiFi.cpp b/libraries/WiFi/WiFi.cpp
new file mode 100755
index 0000000..c0cb001
--- /dev/null
+++ b/libraries/WiFi/WiFi.cpp
@@ -0,0 +1,199 @@
+#include "wifi_drv.h"
+#include "WiFi.h"
+
+extern "C" {
+  #include "utility/wl_definitions.h"
+  #include "utility/wl_types.h"
+  #include "debug.h"
+}
+
+// XXX: don't make assumptions about the value of MAX_SOCK_NUM.
+int16_t 	WiFiClass::_state[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+uint16_t 	WiFiClass::_server_port[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+
+WiFiClass::WiFiClass()
+{
+	// Driver initialization
+	init();
+}
+
+void WiFiClass::init()
+{
+    WiFiDrv::wifiDriverInit();
+}
+
+uint8_t WiFiClass::getSocket()
+{
+    for (uint8_t i = 0; i < MAX_SOCK_NUM; ++i)
+    {
+        if (WiFiClass::_server_port[i] == 0)
+        {
+             return i;
+        }
+    }
+    return NO_SOCKET_AVAIL;
+}
+
+char* WiFiClass::firmwareVersion()
+{
+	return WiFiDrv::getFwVersion();
+}
+
+int WiFiClass::begin(char* ssid)
+{
+	uint8_t status = WL_IDLE_STATUS;
+	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
+
+   if (WiFiDrv::wifiSetNetwork(ssid, strlen(ssid)) != WL_FAILURE)
+   {
+	   do
+	   {
+		   delay(WL_DELAY_START_CONNECTION);
+		   status = WiFiDrv::getConnectionStatus();
+	   }
+	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
+   }else
+   {
+	   status = WL_CONNECT_FAILED;
+   }
+   return status;
+}
+
+int WiFiClass::begin(char* ssid, uint8_t key_idx, const char *key)
+{
+	uint8_t status = WL_IDLE_STATUS;
+	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
+
+	// set encryption key
+   if (WiFiDrv::wifiSetKey(ssid, strlen(ssid), key_idx, key, strlen(key)) != WL_FAILURE)
+   {
+	   do
+	   {
+		   delay(WL_DELAY_START_CONNECTION);
+		   status = WiFiDrv::getConnectionStatus();
+	   }
+	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
+   }else{
+	   status = WL_CONNECT_FAILED;
+   }
+   return status;
+}
+
+int WiFiClass::begin(char* ssid, const char *passphrase)
+{
+	uint8_t status = WL_IDLE_STATUS;
+	uint8_t attempts = WL_MAX_ATTEMPT_CONNECTION;
+
+    // set passphrase
+    if (WiFiDrv::wifiSetPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase))!= WL_FAILURE)
+    {
+ 	   do
+ 	   {
+ 		   delay(WL_DELAY_START_CONNECTION);
+ 		   status = WiFiDrv::getConnectionStatus();
+ 	   }
+	   while ((( status == WL_IDLE_STATUS)||(status == WL_SCAN_COMPLETED))&&(--attempts>0));
+    }else{
+    	status = WL_CONNECT_FAILED;
+    }
+    return status;
+}
+
+int WiFiClass::disconnect()
+{
+    return WiFiDrv::disconnect();
+}
+
+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;
+}
+
+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;
+}
+
+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::status()
+{
+    return WiFiDrv::getConnectionStatus();
+}
+
+int WiFiClass::hostByName(const char* aHostname, IPAddress& aResult)
+{
+	return WiFiDrv::getHostByName(aHostname, aResult);
+}
+
+WiFiClass WiFi;
diff --git a/libraries/WiFi/WiFi.h b/libraries/WiFi/WiFi.h
new file mode 100755
index 0000000..9a86701
--- /dev/null
+++ b/libraries/WiFi/WiFi.h
@@ -0,0 +1,183 @@
+#ifndef WiFi_h
+#define WiFi_h
+
+#include <inttypes.h>
+
+extern "C" {
+	#include "utility/wl_definitions.h"
+	#include "utility/wl_types.h"
+}
+
+#include "IPAddress.h"
+#include "WiFiClient.h"
+#include "WiFiServer.h"
+
+class WiFiClass
+{
+private:
+
+    static void init();
+public:
+    static int16_t 	_state[MAX_SOCK_NUM];
+    static uint16_t _server_port[MAX_SOCK_NUM];
+
+    WiFiClass();
+
+    /*
+     * Get the first socket available
+     */
+    static uint8_t getSocket();
+
+    /*
+     * Get firmware version
+     */
+    static char* firmwareVersion();
+
+
+    /* Start Wifi connection for OPEN networks
+     *
+     * param ssid: Pointer to the SSID string.
+     */
+    int begin(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(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(char* ssid, const char *passphrase);
+
+    /*
+     * Disconnect from the network
+     *
+     * return: one value of wl_status_t enum
+     */
+    int disconnect(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
+     */
+    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
+     */
+    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);
+
+    /*
+     * 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();
+
+    /*
+     * 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);
+
+    friend class WiFiClient;
+    friend class WiFiServer;
+};
+
+extern WiFiClass WiFi;
+
+#endif
diff --git a/libraries/WiFi/WiFiClient.cpp b/libraries/WiFi/WiFiClient.cpp
new file mode 100755
index 0000000..83c0d10
--- /dev/null
+++ b/libraries/WiFi/WiFiClient.cpp
@@ -0,0 +1,179 @@
+extern "C" {
+  #include "utility/wl_definitions.h"
+  #include "utility/wl_types.h"
+  #include "socket.h"
+  #include "string.h"
+  #include "utility/debug.h"
+}
+
+#include "WiFi.h"
+#include "WiFiClient.h"
+#include "WiFiServer.h"
+#include "server_drv.h"
+
+
+uint16_t WiFiClient::_srcport = 1024;
+
+WiFiClient::WiFiClient() : _sock(MAX_SOCK_NUM) {
+}
+
+WiFiClient::WiFiClient(uint8_t sock) : _sock(sock) {
+}
+
+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) {
+    _sock = getFirstSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+    	ServerDrv::startClient(uint32_t(ip), port, _sock);
+    	WiFiClass::_state[_sock] = _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;
+}
+
+size_t WiFiClient::write(uint8_t b) {
+	  return write(&b, 1);
+}
+
+size_t WiFiClient::write(const uint8_t *buf, size_t size) {
+  if (_sock >= MAX_SOCK_NUM)
+  {
+	  setWriteError();
+	  return 0;
+  }
+  if (size==0)
+  {
+	  setWriteError();
+      return 0;
+  }
+
+
+  if (!ServerDrv::sendData(_sock, buf, size))
+  {
+	  setWriteError();
+      return 0;
+  }
+  if (!ServerDrv::checkDataSent(_sock))
+  {
+	  setWriteError();
+      return 0;
+  }
+
+  return size;
+}
+
+int WiFiClient::available() {
+  if (_sock != 255)
+  {
+      return ServerDrv::availData(_sock);
+  }
+   
+  return 0;
+}
+
+int WiFiClient::read() {
+  uint8_t b;
+  if (!available())
+    return -1;
+
+  ServerDrv::getData(_sock, &b);
+  return b;
+}
+
+
+int WiFiClient::read(uint8_t* buf, size_t size) {
+  if (!ServerDrv::getDataBuf(_sock, buf, &size))
+      return -1;
+  return 0;
+}
+
+int WiFiClient::peek() {
+	  uint8_t b;
+	  if (!available())
+	    return -1;
+
+	  ServerDrv::getData(_sock, &b, 1);
+	  return b;
+}
+
+void WiFiClient::flush() {
+  while (available())
+    read();
+}
+
+void WiFiClient::stop() {
+
+  if (_sock == 255)
+    return;
+
+  ServerDrv::stopClient(_sock);
+
+  unsigned long start = millis();
+  
+
+  // wait a second for the connection to close
+  while (status() != CLOSED && millis() - start < 1000)
+    delay(1);
+  _sock = 255;
+}
+
+uint8_t WiFiClient::connected() {
+
+  if (_sock == 255) {
+    return 0;
+  } else {
+    uint8_t s = status();
+
+    return !(s == LISTEN || s == CLOSED || s == FIN_WAIT_1 ||
+    		s == FIN_WAIT_2 || s == TIME_WAIT ||
+    		s == SYN_SENT || s== SYN_RCVD ||
+             (s == CLOSE_WAIT && !available()));
+  }
+}
+
+uint8_t WiFiClient::status() {
+    if (_sock == 255) {
+    return CLOSED;
+  } else {
+    return ServerDrv::getClientState(_sock);
+  }
+}
+
+WiFiClient::operator bool() {
+  return _sock != 255;
+}
+
+// Private Methods
+uint8_t WiFiClient::getFirstSocket()
+{
+    for (int i = 0; i < MAX_SOCK_NUM; i++) {
+      if (WiFiClass::_state[i] == 0)
+      {
+          return i;
+      }
+    }
+    return SOCK_NOT_AVAIL;
+}
+
diff --git a/libraries/WiFi/WiFiClient.h b/libraries/WiFi/WiFiClient.h
new file mode 100755
index 0000000..5a7f0f3
--- /dev/null
+++ b/libraries/WiFi/WiFiClient.h
@@ -0,0 +1,40 @@
+#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 size_t write(uint8_t);
+  virtual size_t write(const uint8_t *buf, size_t size);
+  virtual int available();
+  virtual int read();
+  virtual int read(uint8_t *buf, size_t size);
+  virtual int peek();
+  virtual void flush();
+  virtual void stop();
+  virtual uint8_t connected();
+  virtual operator bool();
+
+  friend class WiFiServer;
+
+  using Print::write;
+
+private:
+  static uint16_t _srcport;
+  uint8_t _sock;   //not used
+  uint16_t  _socket;
+
+  uint8_t getFirstSocket();
+};
+
+#endif
diff --git a/libraries/WiFi/WiFiServer.cpp b/libraries/WiFi/WiFiServer.cpp
new file mode 100644
index 0000000..77dbac0
--- /dev/null
+++ b/libraries/WiFi/WiFiServer.cpp
@@ -0,0 +1,88 @@
+#include <string.h>
+#include "server_drv.h"
+
+extern "C" {
+  #include "utility/debug.h"
+}
+
+#include "WiFi.h"
+#include "WiFiClient.h"
+#include "WiFiServer.h"
+
+WiFiServer::WiFiServer(uint16_t port)
+{
+    _port = port;
+}
+
+void WiFiServer::begin()
+{
+    uint8_t _sock = WiFiClass::getSocket();
+    if (_sock != NO_SOCKET_AVAIL)
+    {
+        ServerDrv::startServer(_port, _sock);
+        WiFiClass::_server_port[_sock] = _port;
+    }
+}
+
+WiFiClient WiFiServer::available(byte* status)
+{
+	static int cycle_server_down = 0;
+	const int TH_SERVER_DOWN = 50;
+
+    for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
+    {
+        if (WiFiClass::_server_port[sock] == _port)
+        {
+        	WiFiClient client(sock);
+            uint8_t _status = client.status();
+            uint8_t _ser_status = this->status();
+
+            if (status != NULL)
+            	*status = _status;
+
+            //server not in listen state, restart it
+            if ((_ser_status == 0)&&(cycle_server_down++ > TH_SERVER_DOWN))
+            {
+            	ServerDrv::startServer(_port, sock);
+            	cycle_server_down = 0;
+            }
+
+            if (_status == ESTABLISHED)
+            {                
+                return client;  //TODO 
+            }
+        }
+    }
+
+    return WiFiClient(255);
+}
+
+uint8_t WiFiServer::status() {
+    return ServerDrv::getServerState(0);
+}
+
+
+size_t WiFiServer::write(uint8_t b)
+{
+    return write(&b, 1);
+}
+
+size_t WiFiServer::write(const uint8_t *buffer, size_t size)
+{
+	size_t n = 0;
+
+    for (int sock = 0; sock < MAX_SOCK_NUM; sock++)
+    {
+        if (WiFiClass::_server_port[sock] != 0)
+        {
+        	WiFiClient client(sock);
+
+            if (WiFiClass::_server_port[sock] == _port &&
+                client.status() == ESTABLISHED)
+            {                
+                n+=client.write(buffer, size);
+            }
+        }
+    }
+    return n;
+}
diff --git a/libraries/WiFi/WiFiServer.h b/libraries/WiFi/WiFiServer.h
new file mode 100755
index 0000000..68b574c
--- /dev/null
+++ b/libraries/WiFi/WiFiServer.h
@@ -0,0 +1,27 @@
+#ifndef wifiserver_h
+#define wifiserver_h
+
+extern "C" {
+  #include "utility/wl_definitions.h"
+}
+
+#include "Server.h"
+
+class WiFiClient;
+
+class WiFiServer : public Server {
+private:
+  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
diff --git a/libraries/WiFi/examples/ConnectNoEncryption/ConnectNoEncryption.ino b/libraries/WiFi/examples/ConnectNoEncryption/ConnectNoEncryption.ino
new file mode 100644
index 0000000..f42a7f3
--- /dev/null
+++ b/libraries/WiFi/examples/ConnectNoEncryption/ConnectNoEncryption.ino
@@ -0,0 +1,121 @@
+/*
+ 
+ This example connects to an unencrypted Wifi network. 
+ Then it prints the  MAC address of the Wifi shield,
+ the IP address obtained, and other network details.
+
+ Circuit:
+ * WiFi shield attached
+ 
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 31 May 2012
+ by Tom Igoe
+ */
+ #include <WiFi.h>
+
+char ssid[] = "yourNetwork";     // the name of your network
+int status = WL_IDLE_STATUS;     // the Wifi radio's status
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+ // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to open SSID: ");
+    Serial.println(ssid);
+    status = WiFi.begin(ssid);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  }
+   
+  // you're connected now, so print out the data:
+  Serial.print("You're connected to the network");
+  printCurrentNet();
+  printWifiData();
+}
+
+void loop() {
+  // check the network connection once every 10 seconds:
+  delay(10000);
+  printCurrentNet();
+}
+
+void printWifiData() {
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+    Serial.print("IP Address: ");
+  Serial.println(ip);
+  Serial.println(ip);
+  
+  // print your MAC address:
+  byte mac[6];  
+  WiFi.macAddress(mac);
+  Serial.print("MAC address: ");
+  Serial.print(mac[5],HEX);
+  Serial.print(":");
+  Serial.print(mac[4],HEX);
+  Serial.print(":");
+  Serial.print(mac[3],HEX);
+  Serial.print(":");
+  Serial.print(mac[2],HEX);
+  Serial.print(":");
+  Serial.print(mac[1],HEX);
+  Serial.print(":");
+  Serial.println(mac[0],HEX);
+  
+  // print your subnet mask:
+  IPAddress subnet = WiFi.subnetMask();
+  Serial.print("NetMask: ");
+  Serial.println(subnet);
+
+  // print your gateway address:
+  IPAddress gateway = WiFi.gatewayIP();
+  Serial.print("Gateway: ");
+  Serial.println(gateway);
+}
+
+void printCurrentNet() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print the MAC address of the router you're attached to:
+  byte bssid[6];
+  WiFi.BSSID(bssid);    
+  Serial.print("BSSID: ");
+  Serial.print(bssid[5],HEX);
+  Serial.print(":");
+  Serial.print(bssid[4],HEX);
+  Serial.print(":");
+  Serial.print(bssid[3],HEX);
+  Serial.print(":");
+  Serial.print(bssid[2],HEX);
+  Serial.print(":");
+  Serial.print(bssid[1],HEX);
+  Serial.print(":");
+  Serial.println(bssid[0],HEX);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.println(rssi);
+
+  // print the encryption type:
+  byte encryption = WiFi.encryptionType();
+  Serial.print("Encryption Type:");
+  Serial.println(encryption,HEX);
+}
+
diff --git a/libraries/WiFi/examples/ConnectWithWEP/ConnectWithWEP.ino b/libraries/WiFi/examples/ConnectWithWEP/ConnectWithWEP.ino
new file mode 100644
index 0000000..19736b5
--- /dev/null
+++ b/libraries/WiFi/examples/ConnectWithWEP/ConnectWithWEP.ino
@@ -0,0 +1,126 @@
+/*
+ 
+ This example connects to a WEP-encrypted Wifi network. 
+ Then it prints the  MAC address of the Wifi shield,
+ the IP address obtained, and other network details.
+ 
+ If you use 40-bit WEP, you need a key that is 10 characters long, 
+ and the characters must be hexadecimal (0-9 or A-F). 
+ e.g.  for 40-bit, ABBADEAF01 will work, but ABBADEAF won't work 
+ (too short) and ABBAISDEAF won't work (I and S are not 
+ hexadecimal characters). 
+ 
+ For 128-bit, you need a string that is 26 characters long. 
+ D0D0DEADF00DABBADEAFBEADED will work because it's 26 characters, 
+ all in the 0-9, A-F range.
+ 
+ Circuit:
+ * WiFi shield attached
+ 
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 31 May 2012
+ by Tom Igoe
+ */
+#include <WiFi.h>
+
+char ssid[] = "yourNetwork";                     // your network SSID (name) 
+char key[] = "D0D0DEADF00DABBADEAFBEADED";       // your network key
+int keyIndex = 0;                                // your network key Index number
+int status = WL_IDLE_STATUS;                     // the Wifi radio's status
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to WEP network, SSID: ");
+    Serial.println(ssid);
+    status = WiFi.begin(ssid, keyIndex, key);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  }
+
+  // once you are connected :
+  Serial.print("You're connected to the network");
+  printCurrentNet();
+  printWifiData();
+}
+
+void loop() {
+  // check the network connection once every 10 seconds:
+  delay(10000);
+  printCurrentNet();
+}
+
+void printWifiData() {
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+  Serial.println(ip);
+
+  // print your MAC address:
+  byte mac[6];  
+  WiFi.macAddress(mac);
+  Serial.print("MAC address: ");
+  Serial.print(mac[5],HEX);
+  Serial.print(":");
+  Serial.print(mac[4],HEX);
+  Serial.print(":");
+  Serial.print(mac[3],HEX);
+  Serial.print(":");
+  Serial.print(mac[2],HEX);
+  Serial.print(":");
+  Serial.print(mac[1],HEX);
+  Serial.print(":");
+  Serial.println(mac[0],HEX);
+}
+
+void printCurrentNet() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print the MAC address of the router you're attached to:
+  byte bssid[6];
+  WiFi.BSSID(bssid);    
+  Serial.print("BSSID: ");
+  Serial.print(bssid[5],HEX);
+  Serial.print(":");
+  Serial.print(bssid[4],HEX);
+  Serial.print(":");
+  Serial.print(bssid[3],HEX);
+  Serial.print(":");
+  Serial.print(bssid[2],HEX);
+  Serial.print(":");
+  Serial.print(bssid[1],HEX);
+  Serial.print(":");
+  Serial.println(bssid[0],HEX);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.println(rssi);
+
+  // print the encryption type:
+  byte encryption = WiFi.encryptionType();
+  Serial.print("Encryption Type:");
+  Serial.println(encryption,HEX);
+  Serial.println();
+}
+
+
+
diff --git a/libraries/WiFi/examples/ConnectWithWPA/ConnectWithWPA.ino b/libraries/WiFi/examples/ConnectWithWPA/ConnectWithWPA.ino
new file mode 100644
index 0000000..fcc33ec
--- /dev/null
+++ b/libraries/WiFi/examples/ConnectWithWPA/ConnectWithWPA.ino
@@ -0,0 +1,116 @@
+/*
+ 
+ This example connects to an unencrypted Wifi network. 
+ Then it prints the  MAC address of the Wifi shield,
+ the IP address obtained, and other network details.
+
+ Circuit:
+ * WiFi shield attached
+ 
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 31 May 2012
+ by Tom Igoe
+ */
+ #include <WiFi.h>
+
+char ssid[] = "yourNetwork";     //  your network SSID (name) 
+char pass[] = "secretPassword";  // your network password
+int status = WL_IDLE_STATUS;     // the Wifi radio's status
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+ // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to WPA SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network:    
+    status = WiFi.begin(ssid, pass);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  }
+   
+  // you're connected now, so print out the data:
+  Serial.print("You're connected to the network");
+  printCurrentNet();
+  printWifiData();
+
+}
+
+void loop() {
+  // check the network connection once every 10 seconds:
+  delay(10000);
+  printCurrentNet();
+}
+
+void printWifiData() {
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+    Serial.print("IP Address: ");
+  Serial.println(ip);
+  Serial.println(ip);
+  
+  // print your MAC address:
+  byte mac[6];  
+  WiFi.macAddress(mac);
+  Serial.print("MAC address: ");
+  Serial.print(mac[5],HEX);
+  Serial.print(":");
+  Serial.print(mac[4],HEX);
+  Serial.print(":");
+  Serial.print(mac[3],HEX);
+  Serial.print(":");
+  Serial.print(mac[2],HEX);
+  Serial.print(":");
+  Serial.print(mac[1],HEX);
+  Serial.print(":");
+  Serial.println(mac[0],HEX);
+ 
+}
+
+void printCurrentNet() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print the MAC address of the router you're attached to:
+  byte bssid[6];
+  WiFi.BSSID(bssid);    
+  Serial.print("BSSID: ");
+  Serial.print(bssid[5],HEX);
+  Serial.print(":");
+  Serial.print(bssid[4],HEX);
+  Serial.print(":");
+  Serial.print(bssid[3],HEX);
+  Serial.print(":");
+  Serial.print(bssid[2],HEX);
+  Serial.print(":");
+  Serial.print(bssid[1],HEX);
+  Serial.print(":");
+  Serial.println(bssid[0],HEX);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.println(rssi);
+
+  // print the encryption type:
+  byte encryption = WiFi.encryptionType();
+  Serial.print("Encryption Type:");
+  Serial.println(encryption,HEX);
+  Serial.println();
+}
+
diff --git a/libraries/WiFi/examples/ScanNetworks/ScanNetworks.ino b/libraries/WiFi/examples/ScanNetworks/ScanNetworks.ino
new file mode 100644
index 0000000..93b3000
--- /dev/null
+++ b/libraries/WiFi/examples/ScanNetworks/ScanNetworks.ino
@@ -0,0 +1,119 @@
+/*
+ 
+ This example  prints the Wifi shield's MAC address, and
+ scans for available Wifi networks using the Wifi shield.
+ Every ten seconds, it scans again. It doesn't actually 
+ connect to any network, so no encryption scheme is specified.
+ 
+ Circuit:
+ * WiFi shield attached
+ 
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 21 Junn 2012
+ by Tom Igoe and Jaymes Dec
+ */
+
+
+#include <SPI.h>
+#include <WiFi.h>
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+
+  // Print WiFi MAC address:
+  printMacAddress();
+
+  // scan for existing networks:
+  Serial.println("Scanning available networks...");
+  listNetworks();
+}
+
+void loop() {
+  delay(10000);
+  // scan for existing networks:
+  Serial.println("Scanning available networks...");
+  listNetworks();
+}
+
+void printMacAddress() {
+  // the MAC address of your Wifi shield
+  byte mac[6];                     
+
+  // print your MAC address:
+  WiFi.macAddress(mac);
+  Serial.print("MAC: ");
+  Serial.print(mac[5],HEX);
+  Serial.print(":");
+  Serial.print(mac[4],HEX);
+  Serial.print(":");
+  Serial.print(mac[3],HEX);
+  Serial.print(":");
+  Serial.print(mac[2],HEX);
+  Serial.print(":");
+  Serial.print(mac[1],HEX);
+  Serial.print(":");
+  Serial.println(mac[0],HEX);
+}
+
+void listNetworks() {
+  // scan for nearby networks:
+  Serial.println("** Scan Networks **");
+  int numSsid = WiFi.scanNetworks();
+  if (numSsid == -1)
+  { 
+    Serial.println("Couldn't get a wifi connection");
+    while(true);
+  } 
+
+  // print the list of networks seen:
+  Serial.print("number of available networks:");
+  Serial.println(numSsid);
+
+  // print the network number and name for each network found:
+  for (int thisNet = 0; thisNet<numSsid; thisNet++) {
+    Serial.print(thisNet);
+    Serial.print(") ");
+    Serial.print(WiFi.SSID(thisNet));
+    Serial.print("\tSignal: ");
+    Serial.print(WiFi.RSSI(thisNet));
+    Serial.print(" dBm");
+    Serial.print("\tEncryption: ");
+    printEncryptionType(WiFi.encryptionType(thisNet));
+  }
+}
+
+void printEncryptionType(int thisType) {
+  // read the encryption type and print out the name:
+  switch (thisType) {
+  case ENC_TYPE_WEP:
+    Serial.println("WEP");
+    break;
+  case ENC_TYPE_TKIP:
+    Serial.println("WPA");
+    break;
+  case ENC_TYPE_CCMP:
+    Serial.println("WPA2");
+    break;
+  case ENC_TYPE_NONE:
+    Serial.println("None");
+    break;
+  case ENC_TYPE_AUTO:
+    Serial.println("Auto");
+    break;
+  } 
+}
+
+
+
diff --git a/libraries/WiFi/examples/WifiChatServer/WifiChatServer.ino b/libraries/WiFi/examples/WifiChatServer/WifiChatServer.ino
new file mode 100644
index 0000000..e4b1d1a
--- /dev/null
+++ b/libraries/WiFi/examples/WifiChatServer/WifiChatServer.ino
@@ -0,0 +1,111 @@
+/*
+ Chat  Server
+ 
+ A simple server that distributes any incoming messages to all
+ connected clients.  To use telnet to  your device's IP address and type.
+ You can see the client's input in the serial monitor as well.
+ 
+ This example is written for a network using WPA encryption. For 
+ WEP or WPA, change the Wifi.begin() call accordingly.
+ 
+ 
+ Circuit:
+ * WiFi shield attached
+ 
+ created 18 Dec 2009
+ by David A. Mellis
+ modified 31 May 2012
+ by Tom Igoe
+ 
+ */
+
+#include <SPI.h>
+#include <WiFi.h>
+
+char ssid[] = "yourNetwork"; //  your network SSID (name) 
+char pass[] = "secretPassword";    // your network password (use for WPA, or use as key for WEP)
+
+int keyIndex = 0;            // your network key Index number (needed only for WEP)
+
+int status = WL_IDLE_STATUS;
+
+WiFiServer server(23);
+
+boolean alreadyConnected = false; // whether or not the client was connected previously
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
+    status = WiFi.begin(ssid, pass);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  } 
+  // start the server:
+  server.begin();
+  // you're connected now, so print out the status:
+  printWifiStatus();
+ }
+
+
+void loop() {
+  // wait for a new client:
+  WiFiClient client = server.available();
+
+
+  // when the client sends the first byte, say hello:
+  if (client) {
+    if (!alreadyConnected) {
+      // clead out the input buffer:
+      client.flush();    
+      Serial.println("We have a new client");
+      client.println("Hello, client!"); 
+      alreadyConnected = true;
+    } 
+
+    if (client.available() > 0) {
+      // read the bytes incoming from the client:
+      char thisChar = client.read();
+      // echo the bytes back to the client:
+      server.write(thisChar);
+      // echo the bytes to the server as well:
+      Serial.write(thisChar);
+    }
+  }
+}
+
+
+void printWifiStatus() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}
+
+
diff --git a/libraries/WiFi/examples/WifiPachubeClient/WifiPachubeClient.ino b/libraries/WiFi/examples/WifiPachubeClient/WifiPachubeClient.ino
new file mode 100644
index 0000000..f8ffc07
--- /dev/null
+++ b/libraries/WiFi/examples/WifiPachubeClient/WifiPachubeClient.ino
@@ -0,0 +1,190 @@
+/*
+  Wifi Pachube sensor client
+ 
+ This sketch connects an analog sensor to Pachube (http://www.pachube.com)
+ using an Arduino Wifi shield.
+ 
+ This example is written for a network using WPA encryption. For 
+ WEP or WPA, change the Wifi.begin() call accordingly.
+ 
+ This example has been updated to use version 2.0 of the Pachube API. 
+ To make it work, create a feed with a datastream, and give it the ID
+ sensor1. Or change the code below to match your feed.
+ 
+ Circuit:
+ * Analog sensor attached to analog in 0
+ * Wifi shield attached to pins 10, 11, 12, 13
+ 
+ created 13 Mar 2012
+ modified 31 May 2012
+ by Tom Igoe
+ modified 8 Sept 2012
+ by Scott Fitzgerald
+ 
+ This code is in the public domain.
+ 
+ */
+#include <SPI.h>
+#include <WiFi.h>
+
+#define APIKEY         "YOUR API KEY GOES HERE" // replace your pachube api key here
+#define FEEDID         00000                    // replace your feed ID
+#define USERAGENT      "My Arduino Project"     // user agent is the project name
+
+char ssid[] = "yourNetwork";      //  your network SSID (name) 
+char pass[] = "secretPassword";   // your network password
+
+int status = WL_IDLE_STATUS;
+
+// initialize the library instance:
+WiFiClient client;
+// if you don't want to use DNS (and reduce your sketch size)
+// use the numeric IP instead of the name for the server:
+IPAddress server(216,52,233,121);      // numeric IP for api.pachube.com
+//char server[] = "api.pachube.com";   // name address for pachube API
+
+unsigned long lastConnectionTime = 0;          // last time you connected to the server, in milliseconds
+boolean lastConnected = false;                 // state of the connection last time through the main loop
+const unsigned long postingInterval = 10*1000; //delay between updates to pachube.com
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
+    status = WiFi.begin(ssid, pass);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  } 
+  // you're connected now, so print out the status:
+  printWifiStatus();
+}
+
+
+void loop() {
+  // read the analog sensor:
+  int sensorReading = analogRead(A0);   
+
+  // if there's incoming data from the net connection.
+  // send it out the serial port.  This is for debugging
+  // purposes only:
+  while (client.available()) {
+    char c = client.read();
+    Serial.print(c);
+  }
+
+  // if there's no net connection, but there was one last time
+  // through the loop, then stop the client:
+  if (!client.connected() && lastConnected) {
+    Serial.println();
+    Serial.println("disconnecting.");
+    client.stop();
+  }
+
+  // if you're not connected, and ten seconds have passed since
+  // your last connection, then connect again and send data:
+  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
+    sendData(sensorReading);
+  }
+  // store the state of the connection for next time through
+  // the loop:
+  lastConnected = client.connected();
+}
+
+// this method makes a HTTP connection to the server:
+void sendData(int thisData) {
+  // if there's a successful connection:
+  if (client.connect(server, 80)) {
+    Serial.println("connecting...");
+    // send the HTTP PUT request:
+    client.print("PUT /v2/feeds/");
+    client.print(FEEDID);
+    client.println(".csv HTTP/1.1");
+    client.println("Host: api.pachube.com");
+    client.print("X-ApiKey: ");
+    client.println(APIKEY);
+    client.print("User-Agent: ");
+    client.println(USERAGENT);
+    client.print("Content-Length: ");
+
+    // calculate the length of the sensor reading in bytes:
+    // 8 bytes for "sensor1," + number of digits of the data:
+    int thisLength = 8 + getLength(thisData);
+    client.println(thisLength);
+
+    // last pieces of the HTTP PUT request:
+    client.println("Content-Type: text/csv");
+    client.println("Connection: close");
+    client.println();
+
+    // here's the actual content of the PUT request:
+    client.print("sensor1,");
+    client.println(thisData);
+  
+  } 
+  else {
+    // if you couldn't make a connection:
+    Serial.println("connection failed");
+    Serial.println();
+    Serial.println("disconnecting.");
+    client.stop();
+  }
+   // note the time that the connection was made or attempted:
+  lastConnectionTime = millis();
+}
+
+
+// This method calculates the number of digits in the
+// sensor reading.  Since each digit of the ASCII decimal
+// representation is a byte, the number of digits equals
+// the number of bytes:
+
+int getLength(int someValue) {
+  // there's at least one byte:
+  int digits = 1;
+  // continually divide the value by ten, 
+  // adding one to the digit count for each
+  // time you divide, until you're at 0:
+  int dividend = someValue /10;
+  while (dividend > 0) {
+    dividend = dividend /10;
+    digits++;
+  }
+  // return the number of digits:
+  return digits;
+}
+
+void printWifiStatus() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}
+
+
+
diff --git a/libraries/WiFi/examples/WifiPachubeClientString/WifiPachubeClientString.ino b/libraries/WiFi/examples/WifiPachubeClientString/WifiPachubeClientString.ino
new file mode 100644
index 0000000..243fe83
--- /dev/null
+++ b/libraries/WiFi/examples/WifiPachubeClientString/WifiPachubeClientString.ino
@@ -0,0 +1,177 @@
+/*
+  Wifi Pachube sensor client with Strings
+ 
+ This sketch connects an analog sensor to Pachube (http://www.pachube.com)
+ using a Arduino Wifi shield.
+ 
+ This example is written for a network using WPA encryption. For 
+ WEP or WPA, change the Wifi.begin() call accordingly.
+ 
+ This example has been updated to use version 2.0 of the pachube.com API. 
+ To make it work, create a feed with a datastream, and give it the ID
+ sensor1. Or change the code below to match your feed.
+ 
+ This example uses the String library, which is part of the Arduino core from
+ version 0019.  
+ 
+ Circuit:
+ * Analog sensor attached to analog in 0
+ * Wifi shield attached to pins 10, 11, 12, 13
+ 
+ created 16 Mar 2012
+ modified 31 May 2012
+ by Tom Igoe
+ modified 8 Sept 2012
+ by Scott Fitzgerald
+ 
+ This code is in the public domain.
+ 
+ */
+
+#include <SPI.h>
+#include <WiFi.h>
+
+#define APIKEY         "YOUR API KEY GOES HERE" // replace your pachube api key here
+#define FEEDID         00000                    // replace your feed ID
+#define USERAGENT      "My Arduino Project"     // user agent is the project name
+
+char ssid[] = "yourNetwork";      //  your network SSID (name) 
+char pass[] = "secretPassword";   // your network password
+
+int status = WL_IDLE_STATUS;
+
+// initialize the library instance:
+WiFiClient client;
+
+// if you don't want to use DNS (and reduce your sketch size)
+// use the numeric IP instead of the name for the server:
+//IPAddress server(216,52,233,121);      // numeric IP for api.pachube.com
+char server[] = "api.pachube.com";   // name address for pachube API
+
+unsigned long lastConnectionTime = 0;          // last time you connected to the server, in milliseconds
+boolean lastConnected = false;                 // state of the connection last time through the main loop
+const unsigned long postingInterval = 10*1000;  //delay between updates to pachube.com
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
+    status = WiFi.begin(ssid, pass);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  } 
+  // you're connected now, so print out the status:
+  printWifiStatus();
+}
+
+void loop() {
+  // read the analog sensor:
+  int sensorReading = analogRead(A0);   
+  // convert the data to a String to send it:
+
+  String dataString = "sensor1,";
+  dataString += sensorReading;
+
+  // you can append multiple readings to this String if your
+  // pachube feed is set up to handle multiple values:
+  int otherSensorReading = analogRead(A1);
+  dataString += "\nsensor2,";
+  dataString += otherSensorReading;
+
+  // if there's incoming data from the net connection.
+  // send it out the serial port.  This is for debugging
+  // purposes only:
+  while (client.available()) {
+    char c = client.read();
+    Serial.print(c);
+  }
+
+  // if there's no net connection, but there was one last time
+  // through the loop, then stop the client:
+  if (!client.connected() && lastConnected) {
+    Serial.println();
+    Serial.println("disconnecting.");
+    client.stop();
+  }
+
+  // if you're not connected, and ten seconds have passed since
+  // your last connection, then connect again and send data: 
+  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
+    sendData(dataString);
+  }
+  // store the state of the connection for next time through
+  // the loop:
+  lastConnected = client.connected();
+}
+
+// this method makes a HTTP connection to the server:
+void sendData(String thisData) {
+  // if there's a successful connection:
+  if (client.connect(server, 80)) {
+    Serial.println("connecting...");
+    // send the HTTP PUT request:
+    client.print("PUT /v2/feeds/");
+    client.print(FEEDID);
+    client.println(".csv HTTP/1.1");
+    client.println("Host: api.pachube.com");
+    client.print("X-ApiKey: ");
+    client.println(APIKEY);
+    client.print("User-Agent: ");
+    client.println(USERAGENT);
+    client.print("Content-Length: ");
+    client.println(thisData.length());
+
+    // last pieces of the HTTP PUT request:
+    client.println("Content-Type: text/csv");
+    client.println("Connection: close");
+    client.println();
+
+    // here's the actual content of the PUT request:
+    client.println(thisData);
+  } 
+  else {
+    // if you couldn't make a connection:
+    Serial.println("connection failed");
+    Serial.println();
+    Serial.println("disconnecting.");
+    client.stop();
+  }
+  // note the time that the connection was made or attempted:
+  lastConnectionTime = millis();
+}
+
+
+void printWifiStatus() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}
+
+
diff --git a/libraries/WiFi/examples/WifiTwitterClient/WifiTwitterClient.ino b/libraries/WiFi/examples/WifiTwitterClient/WifiTwitterClient.ino
new file mode 100644
index 0000000..3dc2c8d
--- /dev/null
+++ b/libraries/WiFi/examples/WifiTwitterClient/WifiTwitterClient.ino
@@ -0,0 +1,163 @@
+/*
+  Wifi Twitter Client with Strings
+ 
+ This sketch connects to Twitter using using an Arduino WiFi shield. 
+ It parses the XML returned, and looks for <text>this is a tweet</text>
+ 
+ This example is written for a network using WPA encryption. For 
+ WEP or WPA, change the Wifi.begin() call accordingly.
+ 
+ This example uses the String library, which is part of the Arduino core from
+ version 0019.  
+ 
+ Circuit:
+ * WiFi shield attached to pins 10, 11, 12, 13
+ 
+ created 23 apr 2012
+ modified 31 May 2012
+ by Tom Igoe
+ 
+ This code is in the public domain.
+ 
+ */
+#include <SPI.h>
+#include <WiFi.h>
+
+char ssid[] = "yourNetwork"; //  your network SSID (name) 
+char pass[] = "password";    // your network password (use for WPA, or use as key for WEP)
+int keyIndex = 0;            // your network key Index number (needed only for WEP)
+
+int status = WL_IDLE_STATUS; // status of the wifi connection
+
+// initialize the library instance:
+WiFiClient client;
+
+const unsigned long requestInterval = 30*1000;    // delay between requests; 30 seconds
+
+// if you don't want to use DNS (and reduce your sketch size)
+// use the numeric IP instead of the name for the server:
+//IPAddress server(199,59,149,200);    // numeric IP for api.twitter.com
+char server[] = "api.twitter.com";     // name address for twitter API
+
+boolean requested;                     // whether you've made a request since connecting
+unsigned long lastAttemptTime = 0;     // last time you connected to the server, in milliseconds
+
+String currentLine = "";               // string to hold the text from server
+String tweet = "";                     // string to hold the tweet
+boolean readingTweet = false;          // if you're currently reading the tweet
+
+void setup() {
+  // reserve space for the strings:
+  currentLine.reserve(256);
+  tweet.reserve(150);
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
+    status = WiFi.begin(ssid, pass);  
+ 
+    // wait 10 seconds for connection:
+    delay(10000);
+  } 
+  // you're connected now, so print out the status:
+  printWifiStatus();
+  connectToServer();
+}
+
+void loop()
+{
+  if (client.connected()) {
+    if (client.available()) {
+      // read incoming bytes:
+      char inChar = client.read();
+
+      // add incoming byte to end of line:
+      currentLine += inChar; 
+
+      // if you get a newline, clear the line:
+      if (inChar == '\n') {
+        currentLine = "";
+      } 
+      // if the current line ends with <text>, it will
+      // be followed by the tweet:
+      if ( currentLine.endsWith("<text>")) {
+        // tweet is beginning. Clear the tweet string:
+        readingTweet = true; 
+        tweet = "";
+        // break out of the loop so this character isn't added to the tweet:
+        return;
+      }
+      // if you're currently reading the bytes of a tweet,
+      // add them to the tweet String:
+      if (readingTweet) {
+        if (inChar != '<') {
+          tweet += inChar;
+        } 
+        else {
+          // if you got a "<" character,
+          // you've reached the end of the tweet:
+          readingTweet = false;
+          Serial.println(tweet);   
+          // close the connection to the server:
+          client.stop(); 
+        }
+      }
+    }   
+  }
+  else if (millis() - lastAttemptTime > requestInterval) {
+    // if you're not connected, and two minutes have passed since
+    // your last connection, then attempt to connect again:
+    connectToServer();
+  }
+}
+
+void connectToServer() {
+  // attempt to connect, and wait a millisecond:
+  Serial.println("connecting to server...");
+  if (client.connect(server, 80)) {
+    Serial.println("making HTTP request...");
+    // make HTTP GET request to twitter:
+    client.println("GET /1/statuses/user_timeline.xml?screen_name=arduino HTTP/1.1");
+    client.println("Host:api.twitter.com");
+    client.println("Connection:close");
+    client.println();
+  }
+  // note the time of this connect attempt:
+  lastAttemptTime = millis();
+}   
+
+
+void printWifiStatus() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}
+
+
+
+
diff --git a/libraries/WiFi/examples/WifiWebClient/WifiWebClient.ino b/libraries/WiFi/examples/WifiWebClient/WifiWebClient.ino
new file mode 100644
index 0000000..17f44a3
--- /dev/null
+++ b/libraries/WiFi/examples/WifiWebClient/WifiWebClient.ino
@@ -0,0 +1,121 @@
+
+/*
+  Web client
+ 
+ This sketch connects to a website (http://www.google.com)
+ using a WiFi shield.
+ 
+ This example is written for a network using WPA encryption. For 
+ WEP or WPA, change the Wifi.begin() call accordingly.
+ 
+ This example is written for a network using WPA encryption. For 
+ WEP or WPA, change the Wifi.begin() call accordingly.
+ 
+ Circuit:
+ * WiFi shield attached
+ 
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 31 May 2012
+ by Tom Igoe
+ */
+
+
+#include <SPI.h>
+#include <WiFi.h>
+
+char ssid[] = "yourNetwork"; //  your network SSID (name) 
+char pass[] = "secretPassword";    // your network password (use for WPA, or use as key for WEP)
+int keyIndex = 0;            // your network key Index number (needed only for WEP)
+
+int status = WL_IDLE_STATUS;
+// if you don't want to use DNS (and reduce your sketch size)
+// use the numeric IP instead of the name for the server:
+IPAddress server(173,194,73,105);  // numeric IP for Google (no DNS)
+//char server[] = "www.google.com";    // name address for Google (using DNS)
+
+// Initialize the Ethernet client library
+// with the IP address and port of the server 
+// that you want to connect to (port 80 is default for HTTP):
+WiFiClient client;
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
+    status = WiFi.begin(ssid, pass);
+  
+    // wait 10 seconds for connection:
+    delay(10000);
+  } 
+  Serial.println("Connected to wifi");
+  printWifiStatus();
+  
+  Serial.println("\nStarting connection to server...");
+  // if you get a connection, report back via serial:
+  if (client.connect(server, 80)) {
+    Serial.println("connected to server");
+    // Make a HTTP request:
+    client.println("GET /search?q=arduino HTTP/1.1");
+    client.println("Host:www.google.com");
+    client.println("Connection: close");
+    client.println();
+  }
+}
+
+void loop() {
+  // if there are incoming bytes available 
+  // from the server, read them and print them:
+  while (client.available()) {
+    char c = client.read();
+    Serial.write(c);
+  }
+
+  // if the server's disconnected, stop the client:
+  if (!client.connected()) {
+    Serial.println();
+    Serial.println("disconnecting from server.");
+    client.stop();
+
+    // do nothing forevermore:
+    while(true);
+  }
+}
+
+
+void printWifiStatus() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}
+
+
+
+
+
diff --git a/libraries/WiFi/examples/WifiWebClientRepeating/WifiWebClientRepeating.ino b/libraries/WiFi/examples/WifiWebClientRepeating/WifiWebClientRepeating.ino
new file mode 100644
index 0000000..96eb628
--- /dev/null
+++ b/libraries/WiFi/examples/WifiWebClientRepeating/WifiWebClientRepeating.ino
@@ -0,0 +1,138 @@
+/*
+  Repeating Wifi Web client
+ 
+ This sketch connects to a a web server and makes a request
+ using an Arduino Wifi shield.
+ 
+ Circuit:
+ * Wifi shield attached to pins 10, 11, 12, 13
+ 
+ created 23 April 2012
+ modifide 31 May 2012
+ by Tom Igoe
+ 
+ http://arduino.cc/en/Tutorial/WifiWebClientRepeating
+ This code is in the public domain.
+ */
+
+#include <SPI.h>
+#include <WiFi.h>
+
+char ssid[] = "yourNetwork";      //  your network SSID (name) 
+char pass[] = "secretPassword";   // your network password
+int keyIndex = 0;            // your network key Index number (needed only for WEP)
+
+int status = WL_IDLE_STATUS;
+
+// Initialize the Wifi client library
+WiFiClient client;
+
+// server address:
+char server[] = "www.arduino.cc";
+//IPAddress server(64,131,82,241);
+
+unsigned long lastConnectionTime = 0;           // last time you connected to the server, in milliseconds
+boolean lastConnected = false;                  // state of the connection last time through the main loop
+const unsigned long postingInterval = 10*1000;  // delay between updates, in milliseconds
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
+    status = WiFi.begin(ssid, pass);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  } 
+  // you're connected now, so print out the status:
+  printWifiStatus();
+}
+
+void loop() {
+  // if there's incoming data from the net connection.
+  // send it out the serial port.  This is for debugging
+  // purposes only:
+  while (client.available()) {
+    char c = client.read();
+    Serial.write(c);
+  }
+
+  // if there's no net connection, but there was one last time
+  // through the loop, then stop the client:
+  if (!client.connected() && lastConnected) {
+    Serial.println();
+    Serial.println("disconnecting.");
+    client.stop();
+  }
+
+  // if you're not connected, and ten seconds have passed since
+  // your last connection, then connect again and send data:
+  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
+    httpRequest();
+  }
+  // store the state of the connection for next time through
+  // the loop:
+  lastConnected = client.connected();
+}
+
+// this method makes a HTTP connection to the server:
+void httpRequest() {
+  // if there's a successful connection:
+  if (client.connect(server, 80)) {
+    Serial.println("connecting...");
+    // send the HTTP PUT request:
+    client.println("GET /latest.txt HTTP/1.1");
+    client.println("Host: www.arduino.cc");
+    client.println("User-Agent: arduino-ethernet");
+    client.println("Connection: close");
+    client.println();
+
+    // note the time that the connection was made:
+    lastConnectionTime = millis();
+  } 
+  else {
+    // if you couldn't make a connection:
+    Serial.println("connection failed");
+    Serial.println("disconnecting.");
+    client.stop();
+  }
+}
+
+
+void printWifiStatus() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}
+
+
+
+
+
+
diff --git a/libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino b/libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino
new file mode 100644
index 0000000..ac5f056
--- /dev/null
+++ b/libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino
@@ -0,0 +1,132 @@
+/*
+  Web  Server
+ 
+ A simple web server that shows the value of the analog input pins.
+ using a WiFi shield.
+ 
+ This example is written for a network using WPA encryption. For 
+ WEP or WPA, change the Wifi.begin() call accordingly.
+ 
+ Circuit:
+ * WiFi shield attached
+ * Analog inputs attached to pins A0 through A5 (optional)
+ 
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 31 May 2012
+ by Tom Igoe
+ */
+#include <SPI.h>
+#include <WiFi.h>
+
+
+char ssid[] = "yourNetwork";      //  your network SSID (name) 
+char pass[] = "secretPassword";   // your network password
+int keyIndex = 0;                 // your network key Index number (needed only for WEP)
+
+int status = WL_IDLE_STATUS;
+
+WiFiServer server(80);
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600); 
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+  
+  // check for the presence of the shield:
+  if (WiFi.status() == WL_NO_SHIELD) {
+    Serial.println("WiFi shield not present"); 
+    // don't continue:
+    while(true);
+  } 
+  
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) { 
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
+    status = WiFi.begin(ssid, pass);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  } 
+  server.begin();
+  // you're connected now, so print out the status:
+  printWifiStatus();
+}
+
+
+void loop() {
+  // listen for incoming clients
+  WiFiClient client = server.available();
+  if (client) {
+    Serial.println("new client");
+    // an http request ends with a blank line
+    boolean currentLineIsBlank = true;
+    while (client.connected()) {
+      if (client.available()) {
+        char c = client.read();
+        Serial.write(c);
+        // if you've gotten to the end of the line (received a newline
+        // character) and the line is blank, the http request has ended,
+        // so you can send a reply
+        if (c == '\n' && currentLineIsBlank) {
+          // send a standard http response header
+          client.println("HTTP/1.1 200 OK");
+          client.println("Content-Type: text/html");
+          client.println("Connnection: close");
+          client.println();
+          client.println("<!DOCTYPE HTML>");
+          client.println("<html>");
+          // add a meta refresh tag, so the browser pulls again every 5 seconds:
+          client.println("<meta http-equiv=\"refresh\" content=\"5\">");
+          // output the value of each analog input pin
+          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
+            int sensorReading = analogRead(analogChannel);
+            client.print("analog input ");
+            client.print(analogChannel);
+            client.print(" is ");
+            client.print(sensorReading);
+            client.println("<br />");       
+          }
+          client.println("</html>");
+           break;
+        }
+        if (c == '\n') {
+          // you're starting a new line
+          currentLineIsBlank = true;
+        } 
+        else if (c != '\r') {
+          // you've gotten a character on the current line
+          currentLineIsBlank = false;
+        }
+      }
+    }
+    // give the web browser time to receive the data
+    delay(1);
+      // close the connection:
+      client.stop();
+      Serial.println("client disonnected");
+  }
+}
+
+
+void printWifiStatus() {
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // print the received signal strength:
+  long rssi = WiFi.RSSI();
+  Serial.print("signal strength (RSSI):");
+  Serial.print(rssi);
+  Serial.println(" dBm");
+}
+
diff --git a/libraries/WiFi/keywords.txt b/libraries/WiFi/keywords.txt
new file mode 100755
index 0000000..47704cd
--- /dev/null
+++ b/libraries/WiFi/keywords.txt
@@ -0,0 +1,43 @@
+#######################################
+# Syntax Coloring Map For WiFi
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+WiFi	KEYWORD1
+Client	KEYWORD1
+Server	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+status	KEYWORD2
+connect	KEYWORD2
+write	KEYWORD2
+available	KEYWORD2
+read	KEYWORD2
+flush	KEYWORD2
+stop	KEYWORD2
+connected	KEYWORD2
+begin	KEYWORD2
+disconnect	KEYWORD2
+macAddress	KEYWORD2
+localIP	KEYWORD2
+subnetMask	KEYWORD2
+gatewayIP	KEYWORD2
+SSID	KEYWORD2
+BSSID		KEYWORD2
+RSSI	KEYWORD2
+encryptionType	KEYWORD2
+getResult	KEYWORD2
+getSocket	KEYWORD2
+WiFiClient	KEYWORD2
+WiFiServer	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
diff --git a/libraries/WiFi/utility/debug.h b/libraries/WiFi/utility/debug.h
new file mode 100644
index 0000000..9f71055
--- /dev/null
+++ b/libraries/WiFi/utility/debug.h
@@ -0,0 +1,77 @@
+//*********************************************/
+// 
+//  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
diff --git a/libraries/WiFi/utility/server_drv.cpp b/libraries/WiFi/utility/server_drv.cpp
new file mode 100644
index 0000000..ce03604
--- /dev/null
+++ b/libraries/WiFi/utility/server_drv.cpp
@@ -0,0 +1,260 @@
+//#define _DEBUG_

+

+#include "server_drv.h"

+

+#include "Arduino.h"

+#include "spi_drv.h"

+

+extern "C" {

+#include "wl_types.h"

+#include "debug.h"

+}

+

+

+// Start server TCP on port specified

+void ServerDrv::startServer(uint16_t port, uint8_t sock)

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(START_SERVER_TCP_CMD, PARAM_NUMS_2);

+    SpiDrv::sendParam(port);

+    SpiDrv::sendParam(&sock, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // 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)

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_3);

+    SpiDrv::sendParam((uint8_t*)&ipAddress, sizeof(ipAddress));

+    SpiDrv::sendParam(port);

+    SpiDrv::sendParam(&sock, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // 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);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // 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);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // 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);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // 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;

+}

+

+uint8_t ServerDrv::availData(uint8_t sock)

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1);

+    SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+    if (!SpiDrv::waitResponseCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))

+    {

+        WARN("error waitResponse");

+    }

+    SpiDrv::spiSlaveDeselect();

+

+    if (_dataLen!=0)

+    {

+        return (_data == 1);

+    }

+    return false;

+}

+

+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);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // 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)

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(GET_DATABUF_TCP_CMD, PARAM_NUMS_1);

+    SpiDrv::sendBuffer(&sock, sizeof(sock), LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // 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::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);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+    if (!SpiDrv::waitResponseData8(SEND_DATA_TCP_CMD, &_data, &_dataLen))

+    {

+        WARN("error waitResponse");

+    }

+    SpiDrv::spiSlaveDeselect();

+    if (_dataLen!=0)

+    {

+        return (_data == 1);

+    }

+    return false;

+}

+

+

+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);

+

+		//Wait the reply elaboration

+		SpiDrv::waitForSlaveReady();

+

+		// 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;

+}

+

+ServerDrv serverDrv;

diff --git a/libraries/WiFi/utility/server_drv.h b/libraries/WiFi/utility/server_drv.h
new file mode 100644
index 0000000..69ba593
--- /dev/null
+++ b/libraries/WiFi/utility/server_drv.h
@@ -0,0 +1,34 @@
+#ifndef Server_Drv_h

+#define Server_Drv_h

+

+#include <inttypes.h>

+#include "wifi_spi.h"

+

+class ServerDrv

+{

+public:

+    // Start server TCP on port specified

+    static void startServer(uint16_t port, uint8_t sock);

+

+    static void startClient(uint32_t ipAddress, uint16_t port, uint8_t sock);

+

+    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 sendData(uint8_t sock, const uint8_t *data, uint16_t len);

+

+    static uint8_t availData(uint8_t sock);

+

+    static uint8_t checkDataSent(uint8_t sock);

+};

+

+extern ServerDrv serverDrv;

+

+#endif

diff --git a/libraries/WiFi/utility/socket.c b/libraries/WiFi/utility/socket.c
new file mode 100644
index 0000000..665073b
--- /dev/null
+++ b/libraries/WiFi/utility/socket.c
@@ -0,0 +1,20 @@
+/*

+*

+@file		socket.c

+@brief	define function of socket API 

+*

+*/

+#include <inttypes.h>

+#include "socket.h"

+

+SOCKET socket(uint8 protocol) {return 0;} // Opens a socket(TCP or UDP or IP_RAW mode)

+void close(SOCKET s) {} // Close socket

+uint8 connect(SOCKET s, uint8 * addr, uint16 port) {return 0;} // Establish TCP connection (Active connection)

+void disconnect(SOCKET s) {} // disconnect the connection

+uint8 listen(SOCKET s) { return 0;}	// Establish TCP connection (Passive connection)

+uint16 send(SOCKET s, const uint8 * buf, uint16 len) { return 0;} // Send data (TCP)

+uint16 recv(SOCKET s, uint8 * buf, uint16 len) {return 0;}	// Receive data (TCP)

+uint16 sendto(SOCKET s, const uint8 * buf, uint16 len, uint8 * addr, uint16 port) {return 0;} // Send data (UDP/IP RAW)

+uint16 recvfrom(SOCKET s, uint8 * buf, uint16 len, uint8 * addr, uint16  *port) {return 0;} // Receive data (UDP/IP RAW)

+

+uint16 igmpsend(SOCKET s, const uint8 * buf, uint16 len) {return 0;}

diff --git a/libraries/WiFi/utility/socket.h b/libraries/WiFi/utility/socket.h
new file mode 100644
index 0000000..9b06d00
--- /dev/null
+++ b/libraries/WiFi/utility/socket.h
@@ -0,0 +1,87 @@
+/*

+*

+@file		socket.h

+@brief	define function of socket API 

+*

+*/

+

+#ifndef	_SOCKET_H_

+#define	_SOCKET_H_

+

+#define TCP_SOCKET  1

+#define UDP_SOCKET  2

+#define RAW_SOCKET  3

+

+#define SOCK_NOT_AVAIL  255

+

+#include "wl_definitions.h"

+/**

+ * The 8-bit signed data type.

+ */

+typedef char int8;

+/**

+ * The volatile 8-bit signed data type.

+ */

+typedef volatile char vint8;

+/**

+ * The 8-bit unsigned data type.

+ */

+typedef unsigned char uint8;

+/**

+ * The volatile 8-bit unsigned data type.

+ */

+typedef volatile unsigned char vuint8;

+

+/**

+ * The 16-bit signed data type.

+ */

+typedef int int16;

+/**

+ * The volatile 16-bit signed data type.

+ */

+typedef volatile int vint16;

+/**

+ * The 16-bit unsigned data type.

+ */

+typedef unsigned int uint16;

+/**

+ * The volatile 16-bit unsigned data type.

+ */

+typedef volatile unsigned int vuint16;

+/**

+ * The 32-bit signed data type.

+ */

+typedef long int32;

+/**

+ * The volatile 32-bit signed data type.

+ */

+typedef volatile long vint32;

+/**

+ * The 32-bit unsigned data type.

+ */

+typedef unsigned long uint32;

+/**

+ * The volatile 32-bit unsigned data type.

+ */

+typedef volatile unsigned long vuint32;

+

+/* bsd */

+typedef uint8			u_char;		/**< 8-bit value */

+typedef uint16_t 			SOCKET;

+typedef uint16			u_short;	/**< 16-bit value */

+typedef uint16			u_int;		/**< 16-bit value */

+typedef uint32			u_long;		/**< 32-bit value */

+

+extern SOCKET socket(uint8 protocol); // Opens a socket(TCP or UDP or IP_RAW mode)

+extern void close(SOCKET s); // Close socket

+extern uint8 connect(SOCKET s, uint8 * addr, uint16 port); // Establish TCP connection (Active connection)

+extern void disconnect(SOCKET s); // disconnect the connection

+extern uint8 listen(SOCKET s);	// Establish TCP connection (Passive connection)

+extern uint16 send(SOCKET s, const uint8 * buf, uint16 len); // Send data (TCP)

+extern uint16 recv(SOCKET s, uint8 * buf, uint16 len);	// Receive data (TCP)

+extern uint16 sendto(SOCKET s, const uint8 * buf, uint16 len, uint8 * addr, uint16 port); // Send data (UDP/IP RAW)

+extern uint16 recvfrom(SOCKET s, uint8 * buf, uint16 len, uint8 * addr, uint16  *port); // Receive data (UDP/IP RAW)

+

+extern uint16 igmpsend(SOCKET s, const uint8 * buf, uint16 len);

+#endif

+/* _SOCKET_H_ */

diff --git a/libraries/WiFi/utility/spi_drv.cpp b/libraries/WiFi/utility/spi_drv.cpp
new file mode 100644
index 0000000..12a320b
--- /dev/null
+++ b/libraries/WiFi/utility/spi_drv.cpp
@@ -0,0 +1,506 @@
+
+#include "Arduino.h"
+#include "spi_drv.h"                   
+#include "pins_arduino.h"
+//#define _DEBUG_
+extern "C" {
+#include "debug.h"
+}
+
+#define DATAOUT 	11 // MOSI
+#define DATAIN  	12 // MISO
+#define SPICLOCK  	13 // sck
+#define SLAVESELECT 10 // ss
+#define SLAVEREADY 	7  // handshake pin
+#define WIFILED 	9  // led on wifi shield
+
+#define DELAY_100NS do { asm volatile("nop"); }while(0);
+#define DELAY_SPI(X) { int ii=0; do {  asm volatile("nop"); }while(++ii<X);}
+#define DELAY_TRANSFER() DELAY_SPI(10)
+
+void SpiDrv::begin()
+{
+	  // Set direction register for SCK and MOSI pin.
+	  // MISO pin automatically overrides to INPUT.
+	  // When the SS pin is set as OUTPUT, it can be used as
+	  // a general purpose output port (it doesn't influence
+	  // SPI operations).
+
+	  pinMode(SCK, OUTPUT);
+	  pinMode(MOSI, OUTPUT);
+	  pinMode(SS, OUTPUT);
+	  pinMode(SLAVESELECT, OUTPUT);
+	  pinMode(SLAVEREADY, INPUT);
+	  pinMode(WIFILED, OUTPUT);
+
+	  digitalWrite(SCK, LOW);
+	  digitalWrite(MOSI, LOW);
+	  digitalWrite(SS, HIGH);
+	  digitalWrite(SLAVESELECT, HIGH);
+	  digitalWrite(WIFILED, LOW);
+
+#ifdef _DEBUG_
+	  INIT_TRIGGER()
+#endif
+
+	  // Warning: if the SS pin ever becomes a LOW INPUT then SPI
+	  // automatically switches to Slave, so the data direction of
+	  // the SS pin MUST be kept as OUTPUT.
+	  SPCR |= _BV(MSTR);
+	  SPCR |= _BV(SPE);
+	  //SPSR |= _BV(SPI2X);
+}
+
+void SpiDrv::end() {
+  SPCR &= ~_BV(SPE);
+}
+
+void SpiDrv::spiSlaveSelect()
+{
+    digitalWrite(SLAVESELECT,LOW);
+}
+
+
+void SpiDrv::spiSlaveDeselect()
+{
+    digitalWrite(SLAVESELECT,HIGH);
+}
+
+void delaySpi()
+{
+	int i = 0;
+	const int DELAY = 1000;
+	for (;i<DELAY;++i)
+	{
+		int a =a+1;
+	}
+}
+
+char SpiDrv::spiTransfer(volatile char data)
+{
+    SPDR = data;                    // Start the transmission
+    while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
+    {
+    };
+    char result = SPDR;
+    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()
+{
+	while (!waitSlaveReady());
+}
+
+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::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);
+
+    //waitForSlaveSign();
+    //wait the interrupt trigger on slave
+    delayMicroseconds(SPI_START_CMD_DELAY);
+
+    // 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);
+
+}
+
+SpiDrv spiDrv;
diff --git a/libraries/WiFi/utility/spi_drv.h b/libraries/WiFi/utility/spi_drv.h
new file mode 100644
index 0000000..5c2e706
--- /dev/null
+++ b/libraries/WiFi/utility/spi_drv.h
@@ -0,0 +1,83 @@
+#ifndef SPI_Drv_h

+#define SPI_Drv_h

+

+#include <inttypes.h>

+#include "wifi_spi.h"

+

+#define SPI_START_CMD_DELAY 	12

+

+#define NO_LAST_PARAM   0

+#define LAST_PARAM      1

+

+#define DUMMY_DATA  0xFF

+

+#define WAIT_FOR_SLAVE_SELECT()	 \

+	SpiDrv::waitForSlaveReady(); \

+	SpiDrv::spiSlaveSelect();

+

+

+

+class SpiDrv

+{

+private:

+	//static bool waitSlaveReady();

+	static void waitForSlaveSign();

+	static void getParam(uint8_t* param);

+public:

+

+    static void begin();

+

+    static void end();

+    

+    static void spiDriverInit();

+        

+    static void spiSlaveSelect();

+    

+    static void spiSlaveDeselect();

+    

+    static char spiTransfer(volatile char data);

+

+    static void waitForSlaveReady();

+

+    //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 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);

+};                                                                 

+

+extern SpiDrv spiDrv;

+

+#endif

diff --git a/libraries/WiFi/utility/wifi_drv.cpp b/libraries/WiFi/utility/wifi_drv.cpp
new file mode 100644
index 0000000..1ca1696
--- /dev/null
+++ b/libraries/WiFi/utility/wifi_drv.cpp
@@ -0,0 +1,491 @@
+#include <stdio.h>

+#include <string.h>

+#include <stdint.h>

+

+#include "Arduino.h"

+#include "spi_drv.h"

+#include "wifi_drv.h"

+

+#define _DEBUG_

+

+extern "C" {

+#include "wifi_spi.h"

+#include "wl_types.h"

+#include "debug.h"

+}

+

+// Array of data to cache the information related to the networks discovered

+char 	WiFiDrv::_networkSsid[][WL_SSID_MAX_LENGTH] = {{"1"},{"2"},{"3"},{"4"},{"5"}};

+int32_t WiFiDrv::_networkRssi[WL_NETWORKS_LIST_MAXNUM] = { 0 };

+uint8_t WiFiDrv::_networkEncr[WL_NETWORKS_LIST_MAXNUM] = { 0 };

+

+// Cached values of retrieved data

+char 	WiFiDrv::_ssid[] = {0};

+uint8_t	WiFiDrv::_bssid[] = {0};

+uint8_t WiFiDrv::_mac[] = {0};

+uint8_t WiFiDrv::_localIp[] = {0};

+uint8_t WiFiDrv::_subnetMask[] = {0};

+uint8_t WiFiDrv::_gatewayIp[] = {0};

+// Firmware version

+char    WiFiDrv::fwVersion[] = {0};

+

+

+// Private Methods

+

+void WiFiDrv::getNetworkData(uint8_t *ip, uint8_t *mask, uint8_t *gwip)

+{

+    tParam params[PARAM_NUMS_3] = { {0, (char*)ip}, {0, (char*)mask}, {0, (char*)gwip}};

+

+    WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_IPADDR_CMD, PARAM_NUMS_1);

+

+    uint8_t _dummy = DUMMY_DATA;

+    SpiDrv::sendParam(&_dummy, sizeof(_dummy), LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    SpiDrv::waitResponseParams(GET_IPADDR_CMD, PARAM_NUMS_3, params);

+

+    SpiDrv::spiSlaveDeselect();

+}

+

+// Public Methods

+

+

+void WiFiDrv::wifiDriverInit()

+{

+    SpiDrv::begin();

+}

+

+int8_t WiFiDrv::wifiSetNetwork(char* ssid, uint8_t ssid_len)

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(SET_NET_CMD, PARAM_NUMS_1);

+    SpiDrv::sendParam((uint8_t*)ssid, ssid_len, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+    if (!SpiDrv::waitResponseCmd(SET_NET_CMD, PARAM_NUMS_1, &_data, &_dataLen))

+    {

+        WARN("error waitResponse");

+        _data = WL_FAILURE;

+    }

+    SpiDrv::spiSlaveDeselect();

+

+    return(_data == WIFI_SPI_ACK) ? WL_SUCCESS : WL_FAILURE;

+}

+

+int8_t WiFiDrv::wifiSetPassphrase(char* ssid, uint8_t ssid_len, const char *passphrase, const uint8_t len)

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(SET_PASSPHRASE_CMD, PARAM_NUMS_2);

+    SpiDrv::sendParam((uint8_t*)ssid, ssid_len, NO_LAST_PARAM);

+    SpiDrv::sendParam((uint8_t*)passphrase, len, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+    if (!SpiDrv::waitResponseCmd(SET_PASSPHRASE_CMD, PARAM_NUMS_1, &_data, &_dataLen))

+    {

+        WARN("error waitResponse");

+        _data = WL_FAILURE;

+    }

+    SpiDrv::spiSlaveDeselect();

+    return _data;

+}

+

+

+int8_t WiFiDrv::wifiSetKey(char* ssid, uint8_t ssid_len, uint8_t key_idx, const void *key, const uint8_t len)

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(SET_KEY_CMD, PARAM_NUMS_3);

+    SpiDrv::sendParam((uint8_t*)ssid, ssid_len, NO_LAST_PARAM);

+    SpiDrv::sendParam(&key_idx, KEY_IDX_LEN, NO_LAST_PARAM);

+    SpiDrv::sendParam((uint8_t*)key, len, LAST_PARAM);

+    

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+    if (!SpiDrv::waitResponseCmd(SET_KEY_CMD, PARAM_NUMS_1, &_data, &_dataLen))

+    {

+        WARN("error waitResponse");

+        _data = WL_FAILURE;

+    }

+    SpiDrv::spiSlaveDeselect();

+    return _data;

+}

+                        

+int8_t WiFiDrv::disconnect()

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(DISCONNECT_CMD, PARAM_NUMS_1);

+

+    uint8_t _dummy = DUMMY_DATA;

+    SpiDrv::sendParam(&_dummy, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+    int8_t result = SpiDrv::waitResponseCmd(DISCONNECT_CMD, PARAM_NUMS_1, &_data, &_dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return result;

+}

+

+uint8_t WiFiDrv::getConnectionStatus()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_CONN_STATUS_CMD, PARAM_NUMS_0);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = -1;

+    uint8_t _dataLen = 0;

+    SpiDrv::waitResponseCmd(GET_CONN_STATUS_CMD, PARAM_NUMS_1, &_data, &_dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return _data;

+}

+

+uint8_t* WiFiDrv::getMacAddress()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_MACADDR_CMD, PARAM_NUMS_1);

+

+    uint8_t _dummy = DUMMY_DATA;

+    SpiDrv::sendParam(&_dummy, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _dataLen = 0;

+    SpiDrv::waitResponseCmd(GET_MACADDR_CMD, PARAM_NUMS_1, _mac, &_dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return _mac;

+}

+

+void WiFiDrv::getIpAddress(IPAddress& ip)

+{

+	getNetworkData(_localIp, _subnetMask, _gatewayIp);

+	ip = _localIp;

+}

+

+ void WiFiDrv::getSubnetMask(IPAddress& mask)

+ {

+	getNetworkData(_localIp, _subnetMask, _gatewayIp);

+	mask = _subnetMask;

+ }

+

+ void WiFiDrv::getGatewayIP(IPAddress& ip)

+ {

+	getNetworkData(_localIp, _subnetMask, _gatewayIp);

+	ip = _gatewayIp;

+ }

+

+char* WiFiDrv::getCurrentSSID()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_CURR_SSID_CMD, PARAM_NUMS_1);

+

+    uint8_t _dummy = DUMMY_DATA;

+    SpiDrv::sendParam(&_dummy, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _dataLen = 0;

+    SpiDrv::waitResponseCmd(GET_CURR_SSID_CMD, PARAM_NUMS_1, (uint8_t*)_ssid, &_dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return _ssid;

+}

+

+uint8_t* WiFiDrv::getCurrentBSSID()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_CURR_BSSID_CMD, PARAM_NUMS_1);

+

+    uint8_t _dummy = DUMMY_DATA;

+    SpiDrv::sendParam(&_dummy, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _dataLen = 0;

+    SpiDrv::waitResponseCmd(GET_CURR_BSSID_CMD, PARAM_NUMS_1, _bssid, &_dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return _bssid;

+}

+

+int32_t WiFiDrv::getCurrentRSSI()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_CURR_RSSI_CMD, PARAM_NUMS_1);

+

+    uint8_t _dummy = DUMMY_DATA;

+    SpiDrv::sendParam(&_dummy, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _dataLen = 0;

+    int32_t rssi = 0;

+    SpiDrv::waitResponseCmd(GET_CURR_RSSI_CMD, PARAM_NUMS_1, (uint8_t*)&rssi, &_dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return rssi;

+}

+

+uint8_t WiFiDrv::getCurrentEncryptionType()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_CURR_ENCT_CMD, PARAM_NUMS_1);

+

+    uint8_t _dummy = DUMMY_DATA;

+    SpiDrv::sendParam(&_dummy, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t dataLen = 0;

+    uint8_t encType = 0;

+    SpiDrv::waitResponseCmd(GET_CURR_ENCT_CMD, PARAM_NUMS_1, (uint8_t*)&encType, &dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return encType;

+}

+

+int8_t WiFiDrv::startScanNetworks()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(START_SCAN_NETWORKS, PARAM_NUMS_0);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+

+    if (!SpiDrv::waitResponseCmd(START_SCAN_NETWORKS, PARAM_NUMS_1, &_data, &_dataLen))

+     {

+         WARN("error waitResponse");

+         _data = WL_FAILURE;

+     }

+

+    SpiDrv::spiSlaveDeselect();

+

+    return (_data == WL_FAILURE)? _data : WL_SUCCESS;

+}

+

+

+uint8_t WiFiDrv::getScanNetworks()

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(SCAN_NETWORKS, PARAM_NUMS_0);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t ssidListNum = 0;

+    SpiDrv::waitResponse(SCAN_NETWORKS, &ssidListNum, (uint8_t**)_networkSsid, WL_NETWORKS_LIST_MAXNUM);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return ssidListNum;

+}

+

+char* WiFiDrv::getSSIDNetoworks(uint8_t networkItem)

+{

+	if (networkItem >= WL_NETWORKS_LIST_MAXNUM)

+		return NULL;

+

+	return _networkSsid[networkItem];

+}

+

+uint8_t WiFiDrv::getEncTypeNetowrks(uint8_t networkItem)

+{

+	if (networkItem >= WL_NETWORKS_LIST_MAXNUM)

+		return NULL;

+

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_IDX_ENCT_CMD, PARAM_NUMS_1);

+

+    SpiDrv::sendParam(&networkItem, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t dataLen = 0;

+    uint8_t encType = 0;

+    SpiDrv::waitResponseCmd(GET_IDX_ENCT_CMD, PARAM_NUMS_1, (uint8_t*)&encType, &dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return encType;

+}

+

+int32_t WiFiDrv::getRSSINetoworks(uint8_t networkItem)

+{

+	if (networkItem >= WL_NETWORKS_LIST_MAXNUM)

+		return NULL;

+	int32_t	networkRssi = 0;

+

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(GET_IDX_RSSI_CMD, PARAM_NUMS_1);

+

+    SpiDrv::sendParam(&networkItem, 1, LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t dataLen = 0;

+    SpiDrv::waitResponseCmd(GET_IDX_RSSI_CMD, PARAM_NUMS_1, (uint8_t*)&networkRssi, &dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+	return networkRssi;

+}

+

+uint8_t WiFiDrv::reqHostByName(const char* aHostname)

+{

+	WAIT_FOR_SLAVE_SELECT();

+

+    // Send Command

+    SpiDrv::sendCmd(REQ_HOST_BY_NAME_CMD, PARAM_NUMS_1);

+    SpiDrv::sendParam((uint8_t*)aHostname, strlen(aHostname), LAST_PARAM);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _data = 0;

+    uint8_t _dataLen = 0;

+    uint8_t result = SpiDrv::waitResponseCmd(REQ_HOST_BY_NAME_CMD, PARAM_NUMS_1, &_data, &_dataLen);

+

+    SpiDrv::spiSlaveDeselect();

+

+    return result;

+}

+

+int WiFiDrv::getHostByName(IPAddress& aResult)

+{

+	uint8_t  _ipAddr[WL_IPV4_LENGTH];

+	IPAddress dummy(0xFF,0xFF,0xFF,0xFF);

+	int result = 0;

+

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(GET_HOST_BY_NAME_CMD, PARAM_NUMS_0);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _dataLen = 0;

+    if (!SpiDrv::waitResponseCmd(GET_HOST_BY_NAME_CMD, PARAM_NUMS_1, _ipAddr, &_dataLen))

+    {

+        WARN("error waitResponse");

+    }else{

+    	aResult = _ipAddr;

+    	result = (aResult != dummy);

+    }

+    SpiDrv::spiSlaveDeselect();

+    return result;

+}

+

+int WiFiDrv::getHostByName(const char* aHostname, IPAddress& aResult)

+{

+	uint8_t retry = 10;

+	if (reqHostByName(aHostname))

+	{

+		while(!getHostByName(aResult) && --retry > 0)

+		{

+			delay(1000);

+		}

+	}else{

+		return 0;

+	}

+	return (retry>0);

+}

+

+char*  WiFiDrv::getFwVersion()

+{

+	WAIT_FOR_SLAVE_SELECT();

+    // Send Command

+    SpiDrv::sendCmd(GET_FW_VERSION_CMD, PARAM_NUMS_0);

+

+    //Wait the reply elaboration

+    SpiDrv::waitForSlaveReady();

+

+    // Wait for reply

+    uint8_t _dataLen = 0;

+    if (!SpiDrv::waitResponseCmd(GET_FW_VERSION_CMD, PARAM_NUMS_1, (uint8_t*)fwVersion, &_dataLen))

+    {

+        WARN("error waitResponse");

+    }

+    SpiDrv::spiSlaveDeselect();

+    return fwVersion;

+}

+

+WiFiDrv wiFiDrv;

diff --git a/libraries/WiFi/utility/wifi_drv.h b/libraries/WiFi/utility/wifi_drv.h
new file mode 100644
index 0000000..c4f04db
--- /dev/null
+++ b/libraries/WiFi/utility/wifi_drv.h
@@ -0,0 +1,219 @@
+#ifndef WiFi_Drv_h

+#define WiFi_Drv_h

+

+#include <inttypes.h>

+#include "wifi_spi.h"

+#include "IPAddress.h"

+

+// Key index length

+#define KEY_IDX_LEN     1

+// 5 secs of delay to have the connection established

+#define WL_DELAY_START_CONNECTION 5000

+// 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];

+	static int32_t 	_networkRssi[WL_NETWORKS_LIST_MAXNUM];

+	static uint8_t 	_networkEncr[WL_NETWORKS_LIST_MAXNUM];

+

+	// 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);

+

+public:

+

+    /*

+     * Driver initialization

+     */

+    static void wifiDriverInit();

+

+    /*

+     * 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: Lenght of ssid string.

+     * return: WL_SUCCESS or WL_FAILURE

+	 */

+    static int8_t wifiSetNetwork(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: Lenght of ssid string.

+     * param passphrase: Passphrase. Valid characters in a passphrase

+     *        must be between ASCII 32-126 (decimal).

+     * param len: Lenght of passphrase string.

+     * return: WL_SUCCESS or WL_FAILURE

+     */

+    static int8_t wifiSetPassphrase(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: Lenght of ssid string.

+     * param key_idx: The key index to set. Valid values are 0-3.

+     * param key: Key input buffer.

+     * param len: Lenght of key string.

+     * return: WL_SUCCESS or WL_FAILURE

+     */

+    static int8_t wifiSetKey(char* ssid, uint8_t ssid_len, uint8_t key_idx, const void *key, const uint8_t len);

+

+    /*

+     * Disconnect from the network

+     *

+     * return: WL_SUCCESS or WL_FAILURE

+     */

+    static int8_t disconnect();

+

+    /*

+     * 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 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 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);

+

+    /*

+     * 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 char* getFwVersion();

+

+};

+

+extern WiFiDrv wiFiDrv;

+

+#endif

diff --git a/libraries/WiFi/utility/wifi_spi.h b/libraries/WiFi/utility/wifi_spi.h
new file mode 100644
index 0000000..bf479e2
--- /dev/null
+++ b/libraries/WiFi/utility/wifi_spi.h
@@ -0,0 +1,144 @@
+#ifndef WiFi_Spi_h

+#define WiFi_Spi_h

+

+#include "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

+  

+enum {

+	SET_NET_CMD 		= 0x10,

+	SET_PASSPHRASE_CMD	= 0x11,

+	SET_KEY_CMD	        = 0x12,

+	TEST_CMD	        = 0x13,

+

+	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,

+

+    // All command with DATA_FLAG 0x40 send a 16bit Len

+

+	SEND_DATA_TCP_CMD		= 0x44,

+    GET_DATABUF_TCP_CMD		= 0x45,

+};

+

+

+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,

+    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

diff --git a/libraries/WiFi/utility/wl_definitions.h b/libraries/WiFi/utility/wl_definitions.h
new file mode 100644
index 0000000..15de781
--- /dev/null
+++ b/libraries/WiFi/utility/wl_definitions.h
@@ -0,0 +1,50 @@
+/*
+ * 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	MAX_SOCK_NUM		4
+//Maximum number of attempts to establish wifi connection
+#define WL_MAX_ATTEMPT_CONNECTION	10
+
+typedef enum {
+		WL_NO_SHIELD = 255,
+        WL_IDLE_STATUS = 0,
+        WL_NO_SSID_AVAIL,
+        WL_SCAN_COMPLETED,
+        WL_CONNECTED,
+        WL_CONNECT_FAILED,
+        WL_CONNECTION_LOST,
+        WL_DISCONNECTED
+} 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
+};
+
+
+#endif /* WL_DEFINITIONS_H_ */
diff --git a/libraries/WiFi/utility/wl_types.h b/libraries/WiFi/utility/wl_types.h
new file mode 100644
index 0000000..82b309d
--- /dev/null
+++ b/libraries/WiFi/utility/wl_types.h
@@ -0,0 +1,31 @@
+/*

+ * 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

+};

+

+#endif //_WL_TYPES_H_