diff options
Diffstat (limited to 'libraries')
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(¶m[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_
|