چهارشنبه , ۲۵ مهر ۱۳۹۷
خانه » نرم افزار » اندروید » Wemo Socket IoT سوئیچ برق اینترنتی
حمایت مالی از یزد کیت

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

سایت belkin در زمینه خانه هوشمند محصولات متنوعی  از جمله ، کنترل پریز برق ،دیمر الکترونیک ، دوربین دید در شب ، کلید برق وای فای ، دستیار صوتی و… رو جهت فروش داره در این پست میخواهیم نحوه اتصال با Wemo Switch Smart Plug سوییچ برق رو به شما اموزش بدیم .

به کمک این سوئیچ که در بین پریز برق و تغذیه دستگاه شما قرار میگیره ، شما قادر خواهید بود کنترل روشن و خاموش کردن رو به دست بگیرید به صورتی که ابتدا این دستگاه رو به وای فای منزل یا محل کارتون یا از طریق سیم کارت به اینترنت وصل میکنید و از این به بعد با کمک آپ میتونید کنترل این سوییچ رو داشته باشید اما در این پروژه ما میخوایم این سوییچ را با کمک سایت ic2cloud کنترل کنیم.

 در این پروژه شما با استفاده از برنامه اندورید مربوط به این پروژه و اتصال گوشی به اینترنت و با استفاده از برد Arduino Due و Arduino Ethernet Shield قادر به کنترل سوئیچ WEMO  خواهید بود البته هدف از این پروژه راه اندازی این سوئیچ با کمک برنامه و برد اردیونو هست وگرینه شما در صورتی که این سوئئیچ رو خریداری کنید به همراه اون اپ android , ios  اون موجود هست.

جهت راه اندازی و سورس اردوینو شما نیاز به Arduino development environment. خواهید داشت اما دقت کنید در حالت پیش فرض کتابخانه Ethernet library از مود UDP MULTICAST  پشتیبانی نمیکنه و برای این کار باید در برنامه تغییراتی بدیم برای این کار به مسیر C:\Program Files (x86)\Arduino\libraries\Ethernet\src برید فایل EthernetUdp.cpp رو باز کنید و کد های زیر رو به آخر فایل اضافه کنید و ذخیره کنید.

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;
}

حالا باید این تابع رو در فایل EthernetUdp.h اضافه کنیم برای اینکار فایل EthernetUdp.h رو باز کنید و دستور در دقیقا در قسمت ساختار( سازنده) constructor  وارد کنید.

   virtual uint8_t beginMulti(IPAddress, uint16_t);

 

نتیجه نهایی باید مشابه زیر بشه

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

 

در این مرحله فایل رو ذخیره کنید و میرسیم به سورس اردوینو که لازمه طبق اموزش در این پست ، مقادیر device_id و auth رو تغییر بدین.

#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);
}

خوب تقریبا برنامه ما آماده هست و یه قدم دیگه تا راه اندازی مونده و اونم یادداشت سریال نامبر نوشته شده پشت سوئیچ و اد کردن اون در برنامه اپ اندروید شما جهت ارتباط با سوئیچ هست

همونطور که در عکس پایین نمایش داده شده در اپ اندروید شما بخشی برای وارد کردن شماره سریال موجود داره که لازمه شماره سریال سوئیچ رو در اون قسمت وارد کنید و به این صورت خروجی سوئیچ رو کنترل کنید البته این سویپ برای ۱۱۰ ولت ساخته شده و مناسب برق ایران نیست ولی ایده خوبی برای ساخت مشابه این دستگاه خواهد بود.

 

در پایان در صورت نیاز به اطلاعات بیشتر میتونید به پست اصلی این مطلب از این لینک مراجعه کنید همچنین ک فایل و سروس اپ اندروید و اردینو جهت دانلود قرار داده شده است.

Download “Wemo-Socket.zip” Wemo-Socket.zip – 2 بار دانلود شده است – 369 KB

منبع : فروشگاه آترین

حمایت مالی از یزد کیت

همچنین ببینید

MPR121 سنسور لمسی خازنی مجاورتی ( کیبورد لمسی)

آی سی MPR121  سنسور لمسی خازنی مجاورتی هست که البته هیچ ربطی به صفحات تاچ اسکرین …

دیدگاهتان را بنویسید