Lab_interaccio/2013/SCK_boya/sck_boya/WiFlyHQ.h

/*-
 * Copyright (c) 2012 Darran Hunt (darran [at] hunt dot net dot nz)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* Release history
 *
 * Version  Date         Description
 * 0.1      25-Mar-2012  First release.
 * 0.2      09-Apr-2012  Added features to support http servers.
 *                       - added an httpserver.ino example.
 *                       - added sendChunk() and sendChunkln() to send chunked HTTP bodies.
 *                       - added terminal() method for simple terminal access via debug stream
 *                       - replaced getFreeMemory() with simpler version that works with 0 bytes
 *                       - turned peek buffer into a circular buffer to fix bug with detecting
 *                         *CLOS* and *OPEN* after a partial match.
 *                       - Added new TCP connection detection via *OPEN* match from available().
 *                         isConnected() can now be polled until a client connects.
 *                       - made the match() function public, handy for matching text in a stream.
 *                       - Added a getProtocol() function to get current set of protocols.
 * 0.3      21-Apr-2012  Added createAdhocNetwork() to create an Ad Hoc WiFi network.
 * 			 Optimised the setopt() and getopt() function so they handle
 * 			 integer conversions and refactored all of the set and get functions.
 * 			 Added a multMatch_P() function to match serial data against multiple
 * 			 progmem strings.
 * 			 Added failure detection to the join() function to quickly detect
 * 			 a failure rather than relying on a timeout.
 * 			 Added setJoin() and getJoin() function for access to the wlan join parameter.
 * 			 Refactored getres() to use the new multiMatch_P() function.
 * 0.4		20-Dec-2012 By Felix Bonowski. Added an easy setup function. Lots of minor changes.
 *
 */

#ifndef _WIFLYHQ_H_
#define _WIFLYHQ_H_

#include <Arduino.h>
#include <Stream.h>
#include <avr/pgmspace.h>
#include <IPAddress.h>

/* IP Protocol bits */
#define WIFLY_PROTOCOL_UDP		0x01
#define WIFLY_PROTOCOL_TCP		0x02
#define WIFLY_PROTOCOL_SECURE		0x04
#define WIFLY_PROTOCOL_TCP_CLIENT	0x08
#define WIFLY_PROTOCOL_HTTP		0x10	/* HTTP Client mode */
#define WIFLY_PROTOCOL_RAW		0x20
#define WIFLY_PROTOCOL_SMTP		0x40

/* IP Flag bits */
#define WIFLY_FLAG_TCP_KEEP		0x01	/* Keep TCP connection alive when wifi lost */
#define WIFLY_FLAG_TCP_NODELAY		0x02
#define WIFLY_FLAG_TCP_RETRY		0x04
#define WIFLY_FLAG_UDP_RETRY		0x08
#define WIFLY_FLAG_DNS_CACHING		0x10
#define WIFLY_FLAG_ARP_CACHING		0x20
#define WIFLY_FLAG_UDP_AUTO_PAIR	0x40
#define WIFLY_FLAG_ADD_TIMESTAMP	0x80

/* UART mode bits */
#define WIFLY_UART_MODE_NOECHO		0x01
#define WIFLY_UART_MODE_DATA_TRIGGER	0x02
#define WIFLY_UART_MODE_SLEEP_RX_BREAK	0x08
#define WIFLY_UART_MODE_RX_BUFFER	0x10

/* DHCP modes */
#define WIFLY_DHCP_MODE_OFF		0x00	/* No DHCP, static IP mode */
#define WIFLY_DHCP_MODE_ON		0x01	/* get IP, Gateway, and DNS from AP */
#define WIFLY_DHCP_MODE_AUTOIP		0x02	/* Used with Adhoc networks */
#define WIFLY_DHCP_MODE_CACHE		0x03	/* Use previous DHCP address based on lease */
#define WIFLY_DHCP_MODE_SERVER		0x04	/* Server DHCP IP addresses? */

/* WLAN Join modes */
#define WIFLY_WLAN_JOIN_MANUAL		0x00	/* Don't auto-join a network */
#define WIFLY_WLAN_JOIN_AUTO		0x01	/* Auto-join network set in SSID, passkey, and channel. */
#define WIFLY_WLAN_JOIN_ANY		0x02	/* Ignore SSID and join strongest network using passkey. */
#define WIFLY_WLAN_JOIN_ADHOC		0x04	/* Create an Adhoc network using SSID, Channel, IP and NetMask */

#define WIFLY_DEFAULT_TIMEOUT		500	/* 500 milliseconds */

#define WIFLY_MODE_WPA			0	
#define WIFLY_MODE_WEP			1

//Debug out

#ifndef TRACE
#define TRACE(x) do { if (DEBUG) Serial.print( x); } while (0)
#endif
#ifndef TRACELN
#define TRACELN(x) do { if (DEBUG) Serial.println( x); } while (0)
#endif


class WFDebug : 
public Stream {
public:
  WFDebug();
  void begin(Stream *debugPrint);

  virtual size_t write(uint8_t byte);
  virtual int read() { 
    return debug->read(); 
  }
  virtual int available() { 
    return debug->available(); 
  }
  virtual void flush() { 
    return debug->flush(); 
  }
  virtual int peek() { 
    return debug->peek(); 
  }

  using Print::write;
private:
  Stream *debug;
};

class WiFly : 
public Stream {
public:
  WiFly();
  /// a complete setup of all functionality for UDP. Templated with the type of the Serial you want to use.
  template <class serialType> void setupForUDP(
  serialType* wiFlySerial,
  const uint32_t newSerialSpeed,
  const bool tryOtherSpeeds,	///< should we try some other baudrates if the currently selected one fails?
  const char* SSID,
  const char* password,
  const char* deviceID,      ///< for identifacation in the network
  const char* localIP,       ///< a string with numbers, if 0, we will use dhcp to get an ip
  const uint16_t localPort,
  const char* remoteHost,
  const uint16_t remotePort,
  const bool printTrace	///< show debug information on Serial
  ){
    bool DEBUG=printTrace;
    TRACE((F("Free memory: ")));
    TRACELN((this->getFreeMemory()));

    boolean saveAndReboot=false;
    char buf[32];

    //try out some different serial speeds until we find one that is working...
    const uint32_t serialSpeeds[]={
      newSerialSpeed,9600, 19200, 38400, 57600, 115200            };

    int speedIndex=0;
    int maxSpeedIndex;
    if(tryOtherSpeeds){
      maxSpeedIndex=6;
    }
    else{ 
      maxSpeedIndex=1;
    }; 
    boolean baudrateFound=false;
    TRACELN(F("Trying to connect to this"));

    for (speedIndex=0;speedIndex<maxSpeedIndex;speedIndex++){
      TRACE(F("Connecting to this using Baudrate:"));
      TRACELN(serialSpeeds[speedIndex]);
      wiFlySerial->begin(serialSpeeds[speedIndex]);
      if(this->begin(wiFlySerial, &Serial)){
        baudrateFound=true;
        break;
      }
    }

    if(!baudrateFound){
      TRACELN(F("Could not find working Baud rate to connect to this"));
      return;
    }
    else{
      TRACE(F("Working Baud rate is "));
      TRACELN(serialSpeeds[speedIndex]);
    }

    this->startCommand();  //made this public to avoid the annoing waiting times
    if(serialSpeeds[speedIndex]!=newSerialSpeed){
      TRACE(F("Setting new baud rate to "));
      TRACELN(newSerialSpeed);
      //set the new this baud rate
      this->setBaud(newSerialSpeed);
      TRACE(F("Saving this config."));
      this->save();
      TRACE(F("Rebooting this->.."));
      this->reboot();
      wiFlySerial->begin(newSerialSpeed);
      saveAndReboot=false;
    }
    //set

    this->getDeviceID(buf, sizeof(buf));
    if(strcmp(buf, deviceID) != 0){
      TRACE(F("Changing device ID to "));
      TRACELN(deviceID);
      this->setDeviceID(deviceID);
      saveAndReboot=true;
    }

    //setup dhcp or an ip..
    if(localIP==0){
      TRACELN(F("No fixed IP provided"));
      if(this->getDHCPMode()!=WIFLY_DHCP_MODE_ON){
        TRACELN(F("Enabling DHCP"));

        this->enableDHCP();
        saveAndReboot=true;
      }
    }
    else{
      if(this->getDHCPMode()!=WIFLY_DHCP_MODE_OFF){
        TRACE(F("Disabling DHCP; setting IP to "));
        TRACELN(localIP);
        this->disableDHCP();
        this->setIP(localIP);
        saveAndReboot=true;
      }
      //set ip only if necessary...
      this->getIP(buf,sizeof(buf));  
      if(strcmp(buf, localIP) != 0){
        TRACE(F("Setting IP to "));
        TRACELN(localIP);
        this->setIP(localIP);
        saveAndReboot=true;
      }
    }

    //receive packets at this port...
    if(this->getPort()!=localPort){
      TRACE(F("Setting listen Port to "));
      TRACELN(localPort);
      this->setPort( localPort);	// Send UPD packets to this server and port
      saveAndReboot=true;
    }

    //2 millis seems to be the minimum for 9600 baud
    if (this->getFlushTimeout() != 2) {
      TRACE(F("Setting Flush timeout to 2ms "));
      this->setFlushTimeout(2);
      saveAndReboot=true;
    }

    //set SSID only if necessary...
    this->getSSID(buf,sizeof(buf));  
    if(strcmp(buf, SSID) != 0){
      TRACE(F("Setting SSID to "));
      TRACELN((SSID));
      this->setSSID(SSID);

      TRACE(F("Setting Wifi Passwd to "));
      TRACELN((password));
      //this->setPassphrase(password);
      // MODO WEP
      this->setopt(PSTR("set w a "), 8); 
      this->setKey(password); 
      saveAndReboot=true;
    }

    this->save();
    this->finishCommand();
    if(saveAndReboot==true){
      this->reboot();
      wiFlySerial->begin(newSerialSpeed);
    }


    /***********************************************/
    /***********************************************/
    /***********************************************/
    

    this->startCommand();
    //set SSID only if necessary...
    this->getSSID(buf,sizeof(buf));  
    if(strcmp(buf, SSID) != 0){
      this->setSSID(SSID);
      this->setPassphrase(password);
      // MODO WEP
    //this->setopt(PSTR("set w a "), 8);
    this->setKey(password); 
    }
    

    /* Join wifi network if not already associated */
    if (!this->isAssociated()) {
      //  if(true){
      /* Setup the this to connect to a wifi network */
      TRACELN(F("Joining network"));
      this->setSSID(SSID);

      if (this->join()) {
        // MODO WEP!!!
        //this->setopt("set w a ", 1); // WEP128
        this->setopt(PSTR("set w a "), 8);   // WEP64
        if (this->join(SSID, password, localIP==0, WIFLY_MODE_WEP))
          TRACELN(F("Joined wifi network"));
      } 
      else {
        TRACELN(F("Failed to join wifi network"));
      }
    } 
    else {
      TRACELN(F("Already joined network"));
    }

    
    /* Setup for UDP packets, sent automatically */
    this->setIpProtocol(WIFLY_PROTOCOL_UDP);
    this->setHost(remoteHost, remotePort);	// Send UPD packets to this server and port
    
    //enable auto join
    this->setJoin(WIFLY_WLAN_JOIN_AUTO);

    /***********************************************/
    /***********************************************/
    /***********************************************/
    
    //this->join();

//    TRACE("MAC: ");
//    TRACELN(this->getMAC(buf, sizeof(buf)));
//    TRACE("IP: ");
//    TRACELN(this->getIP(buf, sizeof(buf)));
//    TRACE("Netmask: ");
//    TRACELN(this->getNetmask(buf, sizeof(buf)));
//    TRACE("Gateway: ");
//    TRACELN(this->getGateway(buf, sizeof(buf)));
//    TRACE("Listen Port:");
//    TRACELN(this->getPort());
//    this->finishCommand();
//    TRACELN(F("this setup finished"));

  };

  void printStatusInfo(){
    this->startCommand();
    char buf[32];
    /* Ping the gateway */
    Serial.print("MAC: ");
    Serial.println(this->getMAC(buf, sizeof(buf)));
    Serial.print("IP: ");
    Serial.println(this->getIP(buf, sizeof(buf)));
    Serial.print("Netmask: ");
    Serial.println(this->getNetmask(buf, sizeof(buf)));
    Serial.print("Gateway: ");
    Serial.println(this->getGateway(buf, sizeof(buf)));
    Serial.print("Listen Port:");
    Serial.println(this->getPort());
    this->finishCommand();

  }


  boolean begin(Stream *serialdev, Stream *debugPrint = NULL);

  char *getSSID(char *buf, int size);
  uint8_t getJoin();
  char *getDeviceID(char *buf, int size);    
  char *getIP(char *buf, int size);
  uint16_t getPort();
  char *getNetmask(char *buf, int size);
  char *getGateway(char *buf, int size);
  char *getDNS(char *buf, int size);
  char *getMAC(char *buf, int size);
  int8_t getDHCPMode();
  uint32_t getRate();
  uint8_t getTxPower();

  uint16_t getConnection();
  int8_t getRSSI();

  bool setJoin(uint8_t join);
  boolean setDeviceID(const char *buf);
  boolean setBaud(uint32_t baud);
  uint32_t getBaud();
  uint8_t getUartMode();
  uint8_t getIpFlags();
  uint8_t getProtocol();

  uint8_t getFlushChar();
  uint16_t getFlushSize();
  uint16_t getFlushTimeout();

  char *getHostIP(char *buf, int size);
  uint16_t getHostPort();

  boolean setSSID(const char *buf);
  boolean setIP(const char *buf);
  boolean setIP(const __FlashStringHelper *buf);
  boolean setPort(const uint16_t port);
  boolean setNetmask(const char *buf);
  boolean setNetmask(const __FlashStringHelper *buf);
  boolean setGateway(const char *buf);
  boolean setDNS(const char *buf);
  boolean setChannel(uint8_t channel);
  boolean setKey(const char *buf);
  boolean setPassphrase(const char *buf);
  boolean setSpaceReplace(const char *buf);
  boolean setDHCP(const uint8_t mode);
  boolean setRate(uint32_t rate);
  boolean setTxPower(uint8_t dBm);

  boolean setHostIP(const char *buf);
  boolean setHostIP(const __FlashStringHelper *buf);
  boolean setHostPort(const uint16_t port);
  boolean setHost(const char *buf, uint16_t port);

  boolean setProtocol(const uint8_t protocol);
  boolean setIpProtocol(const uint8_t protocol); 	/* obsolete */
  boolean setIpFlags(const uint8_t flags);
  boolean setUartMode(const uint8_t mode);

  boolean setBroadcastInterval(const uint8_t seconds);

  boolean setTimeAddress(const char *buf);
  boolean setTimePort(const uint16_t port);
  boolean setTimezone(const uint8_t zone);
  boolean setTimeEnable(const uint16_t enable);

  boolean sleep();

  boolean setAdhocBeacon(const uint16_t msecs);
  boolean setAdhocProbe(const uint16_t secs);
  uint16_t getAdhocBeacon();
  uint16_t getAdhocProbe();
  uint16_t getAdhocReboot();

  boolean setFlushTimeout(const uint16_t timeout);
  boolean setFlushChar(const char flushChar);
  boolean setFlushSize(uint16_t size);
  boolean enableDataTrigger(const uint16_t flushtime=10, const char flushChar=0, const uint16_t flushSize=64);
  boolean disableDataTrigger();
  boolean enableUdpAutoPair();
  boolean disableUdpAutoPair();

  boolean setIOFunc(const uint8_t func);

  char *getTime(char *buf, int size);
  uint32_t getUptime();
  uint8_t getTimezone();
  uint32_t getRTC();

  bool getHostByName(const char *hostname, char *buf, int size);
  boolean ping(const char *host);

  boolean enableDHCP();
  boolean disableDHCP();

  boolean createAdhocNetwork(const char *ssid, uint8_t channel);
  boolean join(const char *ssid, uint16_t timeout=20000);
  boolean join(uint16_t timeout=20000);
  //boolean join(const char *ssid, const char *password, bool dhcp=true, uint8_t mode=WIFLY_MODE_WEP, uint16_t timeout=20000);
  boolean join(const char *ssid, const char *password, bool dhcp=true, uint8_t mode=WIFLY_MODE_WPA, uint16_t timeout=20000);
  boolean leave();
  boolean isAssociated();

  boolean save();
  boolean reboot();
  boolean factoryRestore();

  boolean sendto(const uint8_t *data, uint16_t size, const char *host, uint16_t port);
  boolean sendto(const uint8_t *data, uint16_t size, IPAddress host, uint16_t port);
  boolean sendto(const char *data, const char *host, uint16_t port);
  boolean sendto(const char *data, IPAddress host, uint16_t port);
  boolean sendto(const __FlashStringHelper *data, const char *host, uint16_t port);
  boolean sendto(const __FlashStringHelper *data, IPAddress host, uint16_t port);

  void enableHostRestore();
  void disableHostRestore();

  boolean open(const char *addr, int port=80, boolean block=true);
  boolean open(IPAddress addr, int port=80, boolean block=true);
  boolean close();
  boolean openComplete();
  boolean isConnected();
  boolean isInCommandMode();

  virtual size_t write(uint8_t byte);
  virtual int read();
  virtual int readBufTimeout(char* buf, int size, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);	///< read data into the buffer until it is full or the next character takes more than timeout millis to arrive
  virtual int available();
  virtual void flush();
  virtual int peek();

  char *iptoa(IPAddress addr, char *buf, int size);
  IPAddress atoip(char *buf);
  boolean isDotQuad(const char *addr);

  void sendChunk(const char *str);
  void sendChunk(const __FlashStringHelper *str);
  void sendChunkln(const char *str);
  void sendChunkln(const __FlashStringHelper *str);
  void sendChunkln(void);

  int getFreeMemory();
  void terminal();

  using Print::write;

  void dbgBegin(int size=256);
  void dbgDump();
  void dbgEnd();
  boolean debugOn;

  boolean match(const char *str, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);
  boolean match(const __FlashStringHelper *str, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);
  int multiMatch_P(uint16_t timeout, uint8_t count, ...);
  int gets(char *buf, int size, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);
  int getsTerm(char *buf, int size, char term, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);
  void flushRx(int timeout=WIFLY_DEFAULT_TIMEOUT);

  boolean setFtpDefaults(void);
  boolean setFtpAddress(const char *addr);
  boolean setFtpPort(uint16_t port);
  boolean setFtpDirectory(const char *dir);
  boolean setFtpUser(const char *user);
  boolean setFtpPassword(const char *password);
  boolean setFtpFilename(const char *filename);
  boolean setFtpTimer(uint16_t msecs);
  boolean setFtpMode(uint8_t mode);

  boolean ftpGet(
  const char *addr,
  const char *dir,
  const char *user,
  const char *password,
  const char *filename);
  boolean startCommand();
  boolean finishCommand();
  boolean setopt(const prog_char *cmd, const char *buf=NULL, const __FlashStringHelper *buf_P=NULL);
  boolean setopt(const prog_char *opt, const uint32_t value, uint8_t base=DEC);
private:
  void init(void);

  void dump(const char *str);

  boolean sendto(
  const uint8_t *data,
  uint16_t size,
  const __FlashStringHelper *flashData,
  const char *host,
  uint16_t port);

  boolean match_P(const prog_char *str, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);
  int8_t multiMatch_P(const prog_char *str[], uint8_t count, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);

  void send_P(const prog_char *str);
  void send(const char *str);
  void send(const char ch);
  boolean enterCommandMode();
  boolean exitCommandMode();
  boolean setPrompt();
  boolean getPrompt(uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);
  boolean checkPrompt(const char *str);
  int getResponse(char *buf, int size, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);
  boolean readTimeout(char *ch, uint16_t timeout=WIFLY_DEFAULT_TIMEOUT);

  char *getopt(int opt, char *buf, int size);
  uint32_t getopt(int opt, uint8_t base=DEC);

  boolean getres(char *buf, int size);

  boolean checkStream(const prog_char *str, boolean peeked);
  boolean checkClose(boolean peeked);
  boolean checkOpen(boolean peeked);

  boolean hide();

  boolean inCommandMode;
  int  exitCommand;
  boolean dhcp;
  bool restoreHost;
  bool restoreHostStored;
  char lastHost[32];
  uint16_t lastPort;

  boolean tcpMode;
  boolean udpAutoPair;

  boolean connected;
  boolean connecting;
  struct {
    uint8_t tcp;
    uint8_t assoc;
    uint8_t authen;
    uint8_t dnsServer;
    uint8_t dnsFound;
    uint8_t channel;
  } 
  status;

  Stream *serial; 	/* Serial interface to WiFly */

  WFDebug debug; 	/* Internal debug channel. */

  /*  for dbgDump() */
  char *dbgBuf;
  int dbgInd;
  int dbgMax;
};

#endif