विचार

• प्रतिक्रिया के लिए अतिरिक्त KM रिले संपर्कों का उपयोग करने का अवसर मिलता है;
• हम विद्युत सुरक्षा में वृद्धि करेंगे, जो विशेष रूप से गीले कमरों में महत्वपूर्ण है;
• हम KMTronic रिले के लिए डिज़ाइन किए गए की तुलना में अधिक शक्तिशाली भार को स्विच करने में सक्षम होंगे।

कार्यान्वयन

रास्पबेरी पाई पर केमोटिक क्रॉनिक यूडीपी रिले कनेक्शन डोमोटिकोज के लिए

• यूडीपी के साथ काम करने के लिए समाज सेट करें:
  
  

  sudo apt-get install socat
  

  
  
• ~ / Domoticz / स्क्रिप्ट निर्देशिका में, UDP के माध्यम से KMTronic को नियंत्रित करने के लिए एक स्क्रिप्ट बनाएं। स्क्रिप्ट को कॉल करें, उदाहरण के लिए, rudp.sh:
  
  

  #!/bin/bash
  RelayIP="$1"
  RelayNumber="$2"
  Status=$(echo FF0000 | socat - udp-datagram:192.168.100.${RelayIP}:12345)
  StatusBit=${Status:RelayNumber-1:1}
  CommandON=FF0${RelayNumber}01
  CommandOFF=FF0${RelayNumber}00
  if [ "$StatusBit" = "1" ]; then
  echo ${CommandOFF} | socat - udp-datagram:192.168.100.${RelayIP}:12345
  else
  echo ${CommandON} | socat - udp-datagram:192.168.100.${RelayIP}:12345
  fi
  

  
  
• हम rudp.sh फ़ाइल को निष्पादन योग्य बनाते हैं:
  
  

  chmod +x rudp.sh
  

  
  
• कमांड लाइन से जांचें:
  
  

  rudp.sh 199 1
  

  
  
  इस कमांड को डिफ़ॉल्ट पोर्ट 12345 का उपयोग करके पता 192.168.100.199 के साथ KMTronic डिवाइस के रिले # 1 को स्विच करना चाहिए।
  
  
• डोमोटिकोज़ में, एक्शन और ऑफ एक्शन फ़ील्ड में डमी स्विच बनाएं, निर्दिष्ट करें:
  
  

  script:///home/pi/domoticz/scripts/rudp.sh 199 1
  

  
  
  अब, जब आप स्विच पर क्लिक करते हैं, तो यूडीपी रिले संपर्क स्विच करता है।
  समानांतर में, हम मैनुअल स्विच का उपयोग करके लोड को स्विच कर सकते हैं।
  
  

Arduino प्रोटोकॉल MQTT का उपयोग करके भार की स्थिति के बारे में जानकारी का संग्रह

• हम Arduino में MQTT के साथ काम करने के लिए स्केच में भरते हैं (ध्यान दें, स्केच में आपको domoticz_Idx [सरणी] में भरकर Arduino निविष्टियाँ और हमारे डमी स्विच के Idx सूचकांक को जोड़ने की आवश्यकता है।
  
  स्केच

  #include <SPI.h>
  #include <Ethernet.h>
  #include <Bounce2.h>
  #include <PubSubClient.h>
  
  byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
  byte server[] = { 192, 168, 100, 250};
  byte ip[]     = { 192, 168, 100, 199};
  
  // I/O ports on board, 20 for UNO and Leonardo (14 DI + 6 AI) 
  static const int ioPorts = 20; 
  
  // all pins                           0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
  static const uint8_t arduinoPins[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,A0,A1,A2,A3,A4,A5};
  static const int availablePin[]    = {1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1}; //  pins available for general I/O. 1 - available, 0 - not available
  static const int domoticz_Idx[]    = {5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //
  
  // Buffers for sending data
  char  statusBuffer[ioPorts+1] = "0";           
  char  prevStatusBuffer[ioPorts+1] = "0"; 
  
  // Instantiate a Bounce object
  Bounce debouncer[ioPorts] = Bounce();
  
  // Function headers
  void callback(char* topic, byte* payload, unsigned int length);
  char pinToChar(int value);
  int compareCharArrays(char  array1[ioPorts+1], char array2[ioPorts+1]);
  void readAllPins();
  void publishPins(boolean all);
  void setup();
  void loop();
  
  EthernetClient ethClient;
  PubSubClient clientMQTT(server, 1883, callback, ethClient);
  
  void callback(char* topic, byte* payload, unsigned int length) {
    byte* p = (byte*)malloc(length);
    memcpy(p,payload,length);
    publishPins(true); 
    free(p);
  }
  
  char pinToChar(int value) {
    char result = 'X';
    if (value==HIGH) {
      result = '0';  // if pin opened, send 0
    }  
    if (value==LOW) {
       result = '1';  // if pin closed to GND, send 1
    }   
    return result; 
  }
  
  int compareCharArrays(char  array1[ioPorts+1], char array2[ioPorts+1]) {
    int result = 0;
    for (int i =0; i <= (ioPorts); i++) {
      if (array1[i]!=array2[i]) {
        result = 1;
        break;
      }  
    }  
    return result;    
  }
  
  void readAllPins() {
    for (int i =0; i < (ioPorts); i++)
    {
      if (availablePin[i]) 
      {
        debouncer[i].update();
        statusBuffer[i] =  pinToChar(debouncer[i].read());
      }  
    }  
  }
  
  void publishPins(boolean all) {
    char topic[]="domoticz/in";
    String data;
    char jsonStr[200];
    for (int i =0; i < (ioPorts); i++)
    {
      if ((all) || (prevStatusBuffer[i]!=statusBuffer[i]))
      {
        if ((availablePin[i]) && (domoticz_Idx[i])) 
        {
          data="{\"idx\":";
          data+=(int)domoticz_Idx[i];
          data+=",\"nvalue\":";
          data+=(char)statusBuffer[i];
          data+="}";
          data.toCharArray(jsonStr,200);
          clientMQTT.publish(topic,jsonStr); 
          Serial.print(topic);
          Serial.print(" ");
          Serial.println(jsonStr);
        }
      }  
    }  
  }
  
  void setup() {  
    // initialize serial port over USB  
    Serial.begin(9600);
    
    Ethernet.begin(mac, ip);
    
    // initialize the digital pins as an input.
    for (int i =0; i < ioPorts; i++)
    {
      if (availablePin[i]) { 
        pinMode(i, INPUT_PULLUP);
        debouncer[i].attach(arduinoPins[i]);       // setup the Bounce instance
        debouncer[i].interval(100);   // interval in ms
      }  
      statusBuffer[i]='0';  
      prevStatusBuffer[i]='0'; 
    }
    statusBuffer[ioPorts]='\0';      // EOL
    prevStatusBuffer[ioPorts]='\0';  // EOL
  
    readAllPins();
    
    if (clientMQTT.connect("myhome-ino-id1")) {
      clientMQTT.subscribe("myhome/ino/id1/in/#");
      publishPins(true);
    }
  }
  
  void loop(){
    clientMQTT.loop();
    readAllPins();
    if (compareCharArrays(statusBuffer,prevStatusBuffer)==1)
    // time for send information to the server
    {
        if (!clientMQTT.connected()){
          if (clientMQTT.connect("myhome-ino-id1")) {
            clientMQTT.subscribe("myhome/ino/id1/in/#");
          }  
        } 
        
        if (clientMQTT.connected()) { 
          publishPins(false);
        }  
      
      for (int i =0; i < (ioPorts); i++) {
        prevStatusBuffer[i]=statusBuffer[i]; 
      }
    }    
  }
  

  
  
  
  
• हम Arduino के Gnd और DIxx के संपर्क में अपने मध्यवर्ती रिले का एक मुफ्त संपर्क कनेक्ट करते हैं।
  
  
• डॉमोटिकज़ में एमक्यूटीटी के माध्यम से जानकारी प्राप्त करने के लिए, एमक्यूटीटीवॉकर स्थापित करें।
  
  
• मैन्युअल रूप से लोड को चालू और बंद करें और डोमोटिकिज़ इंटरफ़ेस में लोड स्थिति में परिवर्तन का निरीक्षण करें।