Wemo Socket IoT سوئیچ برق اینترنتی

uint8_t EthernetUDP::beginMulti(IPAddress ip, uint16_t port) {
  if (_sock != MAX_SOCK_NUM)
    return 0;

  for (int i = 0; i < MAX_SOCK_NUM; i++) {
    uint8_t s = W5100.readSnSR(i);
    if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT) {
      _sock = i;
      break;
    }
  }

  if (_sock == MAX_SOCK_NUM)
    return 0;
 
 
  // Calculate MAC address from Multicast IP Address
  byte mac[] = {  0x01, 0x00, 0x5E, 0x00, 0x00, 0x00 };
 
  mac[3] = ip[1] & 0x7F;
  mac[4] = ip[2];
  mac[5] = ip[3];

  W5100.writeSnDIPR(_sock, rawIPAddress(ip));   //۲۳۹.۲۵۵.۰.۱
  W5100.writeSnDPORT(_sock, port);
  W5100.writeSnDHAR(_sock,mac);
 
  _remaining = ۰;

  socket(_sock, SnMR::UDP, port, SnMR::MULTI);

  return 1;
}

   virtual uint8_t beginMulti(IPAddress, uint16_t);

public:
  EthernetUDP();  // Constructor
  virtual uint8_t beginMulti(IPAddress, uint16_t);

#include <SPI.h>
#include <Ethernet.h>
#include <Udp.h>

#define MAX_BUFF ۱۰۲۴                                             // maximum buffer size to read UDP packets
#define MX_SEARCH ۱۰۰۰۰                                           // Maximum time to wait for a response to an UPnP search request. 

byte mac[]     = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

char server[]  = "www.ic2pro.com";                          // Wiring Cloud host name
int port       = 80;
String devId   = "111-222-333";                             // Device ID. CREATE YOUR OWN GUID; Use this http://www.guidgenerator.com/
String auth    = "dXNlcjpwYXNzd29yZA==";                    // Authentication credentials Create a string from <email_address>:<API_Password> and encode it base64
                                                            // The sample here "dXNlcjpwYXNzd29yZA==" is the encoding for "user:password"

String swuuid  = "";                                              // Wemo switch ID (printed on the device). Set in the cloud

IPAddress ip(192, 168, 1, 50);                                    // fallback IP address in case DHCP fails
IPAddress upnp_ip(239, 255, 255, 250);                            // UPnP IP address to send the multicast search UPnP

String       switchIP;                                            // the IP for the Wemo switch
unsigned int switchPort;                                          // the port for the Wemo switch

String switchCurrentState;                                        // current state of the switch
String switchState;                                               // new state retrieved from server

EthernetClient eth;                                               // For HTTP requests 
EthernetUDP Udp;                                                  // For UDP connection

char buff[MAX_BUFF];                                              // buffer for the UDP packets

//  Read the response data from an HTTP request
String readData()
{
  while (eth.connected() && !eth.available()) delay(1);          // wait for data

  String buff = "";                                              // read data in the variable buff
  while (eth.connected() || eth.available()) {
    char c = eth.read();
    buff += c;
    Serial.print(c);
  }
  eth.stop();
  Serial.println();
  return buff;
}

//  Request the control signals from server
void getControl()
{
  Serial.println("====> Control");
  if (eth.connect(server, port)) {
    eth.println("GET http://" + String(server) + ":" + String(port) + "/Wire/connector/get?id=" + devId + "&SW&WEMOID HTTP/1.1");   // just get the switch status
    eth.println("Authorization: Basic " + auth);
    eth.println("Connection: close");
    eth.println();
  }
  else {
    Serial.println("CON ERR");
  }
}


//  Update state for switch (Wemo Switch)
void updateSwitch()
{
  Serial.println("SW-" + switchState);

  char txt[20];
  switchIP.toCharArray(txt, 20);
  if (eth.connect(txt, switchPort)) {
    eth.println("POST /upnp/control/basicevent1 HTTP/1.1");
    eth.println("Host: " + switchIP);
    eth.println("SOAPACTION: \"urn:Belkin:service:basicevent:1#SetBinaryState\"");
    eth.println("Content-type: text/xml; charset=\"utf-8\"");
    eth.println("Connection: close");
    eth.print("Content-Length: ");
    eth.println(262);
    eth.println();
    eth.print("<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><s:Body><u:SetBinaryState xmlns:u=\"urn:Belkin:service:basicevent:1\"><BinaryState>");
    eth.print(switchState);
    eth.println("</BinaryState></u:SetBinaryState></s:Body></s:Envelope>");
  }
  else {
    Serial.println("CC ERR");
  }
}

// Extract values from an HTTP response message 
void extractValues(String msg)
{
  String paramName;
  String paramValue;
  int pos1, pos2;

  if (msg != "")
  {
    // extract fields from received message
    pos2 = ۰;
    pos1 = msg.indexOf("SW,");
    if(pos1 > 0) {
      pos2 = msg.indexOf("\n", pos1);
      paramValue = msg.substring(pos1, pos2);                           // extract value for parameter
      Serial.println(">"+paramValue +"<");
      if(paramValue.indexOf("ON") > 0)
        switchState = "۱";
      else
        switchState = "۰";
    }

    pos1 = msg.indexOf("WEMOID,");
    if(pos1 > 0) {
      pos2 = msg.indexOf("\n", pos1);
      paramValue = msg.substring(pos1+7, pos2);                           // extract value for parameter
      Serial.println(">"+paramValue +"<");
      swuuid = paramValue;
    }
  }
}

// Send a UPnP request to find the Wemo switch
void searchUPnP()
{
  Udp.beginMulti(upnp_ip, ۱۹۰۰);         // Open multicast UDP connection

  String msg = "M-SEARCH * HTTP/1.1\nHOST: 239.255.255.250:1900\nMAN: \"ssdp:discover\"\nMX: 10\nST: ssdp:all\n\n";
  msg.getBytes((byte*)buff, MAX_BUFF);
  buff[msg.length()] = 0;

  Udp.beginPacket(upnp_ip, 1900);        // send request
  Udp.write(buff, msg.length());
  Udp.endPacket();

  Udp.stop();                            // close Multicast UDP. To get response we have to switch to unicast
}

// Read responses from the UPnP search request
void readUPnP()
{
  int packetSize;;
  long start = millis();
  String msg;
  String wemoIP = "";
  String wemoPort = "";

  Udp.begin(1900);                                                           // Start a UDP unicast connection 
  while ((millis() < start + MX_SEARCH) && ((wemoIP == "")  || (wemoPort == "")))
  {
    packetSize = Udp.parsePacket();
    while (( packetSize > 0 ) && ((wemoIP == "")  || (wemoPort == "")))
    {
      Udp.read(buff, MAX_BUFF);                                              // We've received a packet, read the data from it
      buff[packetSize] = ۰;
      msg = String(buff);
      if (msg.indexOf(swuuid) > 0 && msg.indexOf("Belkin") > 0)              // check if the packet is received from a Belkin device with the UUID
      {
        // extract IP & port
        int ipIdx = msg.indexOf("LOCATION: ");                               // find "LOCATION:" line in the packet
        if (ipIdx > 0)
        {
          ipIdx = ipIdx + ۱۷;                                                // move index beyond Length("LOCATION: http://") = 17
          int ipIdxEnd = msg.indexOf(":", ipIdx);
          if (ipIdxEnd > 0)
          {
            wemoIP = msg.substring(ipIdx, ipIdxEnd);                         // extract Wemo IP
            int portIdxEnd = msg.indexOf("/", ipIdxEnd + 1);
            if (portIdxEnd > 0)
              wemoPort = msg.substring(ipIdxEnd + 1, portIdxEnd);            // extract port
          }
        }
      }
      packetSize = Udp.parsePacket();
    }
  }
  Udp.stop();                                                                // stop UDP connection
  switchIP = wemoIP;                                                         
  switchPort = wemoPort.toInt();
  Serial.println("[" + wemoIP + "]");
  Serial.println("[" + wemoPort + "]");
}

// Find the Wemo Switch
void findWemo()
{
  searchUPnP();      // send search request
  readUPnP();        // read response and extract IP & Port
}

void setup() {
  Serial.begin(115200);                               // Initialize debuging

  Serial.println("GO");
  if (Ethernet.begin(mac) == 0) {                   // Initialize Ethernet shield
    Serial.println("ETH ERR");
    Ethernet.begin(mac, ip);                        // If DHCP fails try fix IP
  }
  delay(1000);
  Serial.println(Ethernet.localIP());

  switchCurrentState = "";                          // Set last known state for switch
}

void loop()
{
  String data;
  getControl();                                     // Check on/off "buttons"
  data = readData();
  Serial.println("[" + data + "]");
  if(data != "") {
    extractValues(data);
    if (switchCurrentState != switchState)  {      // check if switch status was changed
      findWemo();                                  // find the wemo switch Ip & Port
      updateSwitch();                              // update switch
      readData();
      switchCurrentState = switchState;
    }
  }
  delay(1000);
}