socket_switcher 0.1.0

data/arduino/lib/RCSwitch/RCSwitch.h

@@ -0,0 +1,144 @@
+/*
+  RCSwitch - Arduino libary for remote control outlet switches
+  Copyright (c) 2011 Suat �zg�r.  All right reserved.
+
+  Contributors:
+  - Andre Koehler / info(at)tomate-online(dot)de
+  - Gordeev Andrey Vladimirovich / gordeev(at)openpyro(dot)com
+  - Skineffect / http://forum.ardumote.com/viewtopic.php?f=2&t=46
+  - Dominik Fischer / dom_fischer(at)web(dot)de
+  - Frank Oltmanns / <first name>.<last name>(at)gmail(dot)com
+  
+  Project home: http://code.google.com/p/rc-switch/
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef _RCSwitch_h
+#define _RCSwitch_h
+
+#if defined(ARDUINO) && ARDUINO >= 100
+    #include "Arduino.h"
+#elif defined(ENERGIA) // LaunchPad, FraunchPad and StellarPad specific
+    #include "Energia.h"	
+#else
+    #include "WProgram.h"
+#endif
+
+
+// At least for the ATTiny X4/X5, receiving has to be disabled due to
+// missing libm depencies (udivmodhi4)
+#if defined( __AVR_ATtinyX5__ ) or defined ( __AVR_ATtinyX4__ )
+#define RCSwitchDisableReceiving
+#endif
+
+// Number of maximum High/Low changes per packet.
+// We can handle up to (unsigned long) => 32 bit * 2 H/L changes per bit + 2 for sync
+#define RCSWITCH_MAX_CHANGES 67
+
+#define PROTOCOL3_SYNC_FACTOR   71
+#define PROTOCOL3_0_HIGH_CYCLES  4
+#define PROTOCOL3_0_LOW_CYCLES  11
+#define PROTOCOL3_1_HIGH_CYCLES  9
+#define PROTOCOL3_1_LOW_CYCLES   6
+
+class RCSwitch {
+
+  public:
+    RCSwitch();
+    
+    void switchOn(int nGroupNumber, int nSwitchNumber);
+    void switchOff(int nGroupNumber, int nSwitchNumber);
+    void switchOn(char* sGroup, int nSwitchNumber);
+    void switchOff(char* sGroup, int nSwitchNumber);
+    void switchOn(char sFamily, int nGroup, int nDevice);
+    void switchOff(char sFamily, int nGroup, int nDevice);
+    void switchOn(char* sGroup, char* sDevice);
+    void switchOff(char* sGroup, char* sDevice);
+    void switchOn(char sGroup, int nDevice);
+    void switchOff(char sGroup, int nDevice);
+
+    void sendTriState(char* Code);
+    void send(unsigned long Code, unsigned int length);
+    void send(char* Code);
+    
+    #if not defined( RCSwitchDisableReceiving )
+    void enableReceive(int interrupt);
+    void enableReceive();
+    void disableReceive();
+    bool available();
+    void resetAvailable();
+	
+    unsigned long getReceivedValue();
+    unsigned int getReceivedBitlength();
+    unsigned int getReceivedDelay();
+    unsigned int getReceivedProtocol();
+    unsigned int* getReceivedRawdata();
+    #endif
+  
+    void enableTransmit(int nTransmitterPin);
+    void disableTransmit();
+    void setPulseLength(int nPulseLength);
+    void setRepeatTransmit(int nRepeatTransmit);
+    #if not defined( RCSwitchDisableReceiving )
+    void setReceiveTolerance(int nPercent);
+    #endif
+    void setProtocol(int nProtocol);
+    void setProtocol(int nProtocol, int nPulseLength);
+  
+  private:
+    char* getCodeWordB(int nGroupNumber, int nSwitchNumber, boolean bStatus);
+    char* getCodeWordA(char* sGroup, int nSwitchNumber, boolean bStatus);
+    char* getCodeWordA(char* sGroup, char* sDevice, boolean bStatus);
+    char* getCodeWordC(char sFamily, int nGroup, int nDevice, boolean bStatus);
+    char* getCodeWordD(char group, int nDevice, boolean bStatus);
+    void sendT0();
+    void sendT1();
+    void sendTF();
+    void send0();
+    void send1();
+    void sendSync();
+    void transmit(int nHighPulses, int nLowPulses);
+
+    static char* dec2binWzerofill(unsigned long dec, unsigned int length);
+    static char* dec2binWcharfill(unsigned long dec, unsigned int length, char fill);
+    
+    #if not defined( RCSwitchDisableReceiving )
+    static void handleInterrupt();
+    static bool receiveProtocol1(unsigned int changeCount);
+    static bool receiveProtocol2(unsigned int changeCount);
+    static bool receiveProtocol3(unsigned int changeCount);
+    int nReceiverInterrupt;
+    #endif
+    int nTransmitterPin;
+    int nPulseLength;
+    int nRepeatTransmit;
+    char nProtocol;
+
+    #if not defined( RCSwitchDisableReceiving )
+    static int nReceiveTolerance;
+    static unsigned long nReceivedValue;
+    static unsigned int nReceivedBitlength;
+    static unsigned int nReceivedDelay;
+    static unsigned int nReceivedProtocol;
+    #endif
+    /* 
+     * timings[0] contains sync timing, followed by a number of bits
+     */
+    static unsigned int timings[RCSWITCH_MAX_CHANGES];
+
+    
+};
+
+#endif

data/arduino/lib/RCSwitch/examples/ReceiveDemo_Advanced/ReceiveDemo_Advanced.pde

@@ -0,0 +1,24 @@
+/*
+  Example for receiving
+  
+  http://code.google.com/p/rc-switch/
+  
+  If you want to visualize a telegram copy the raw data and 
+  paste it into http://test.sui.li/oszi/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+  Serial.begin(9600);
+  mySwitch.enableReceive(0);  // Receiver on inerrupt 0 => that is pin #2
+}
+
+void loop() {
+  if (mySwitch.available()) {
+    output(mySwitch.getReceivedValue(), mySwitch.getReceivedBitlength(), mySwitch.getReceivedDelay(), mySwitch.getReceivedRawdata(),mySwitch.getReceivedProtocol());
+    mySwitch.resetAvailable();
+  }
+}

data/arduino/lib/RCSwitch/examples/ReceiveDemo_Advanced/helperfunctions.ino

@@ -0,0 +1,20 @@
+static char * dec2binWzerofill(unsigned long Dec, unsigned int bitLength){
+  static char bin[64]; 
+  unsigned int i=0;
+
+  while (Dec > 0) {
+    bin[32+i++] = (Dec & 1 > 0) ? '1' : '0';
+    Dec = Dec >> 1;
+  }
+
+  for (unsigned int j = 0; j< bitLength; j++) {
+    if (j >= bitLength - i) {
+      bin[j] = bin[ 31 + i - (j - (bitLength - i)) ];
+    }else {
+      bin[j] = '0';
+    }
+  }
+  bin[bitLength] = '\0';
+  
+  return bin;
+}

data/arduino/lib/RCSwitch/examples/ReceiveDemo_Advanced/output.ino

@@ -0,0 +1,52 @@
+void output(unsigned long decimal, unsigned int length, unsigned int delay, unsigned int* raw, unsigned int protocol) {
+
+  if (decimal == 0) {
+    Serial.print("Unknown encoding.");
+  } else {
+    char* b = dec2binWzerofill(decimal, length);
+    Serial.print("Decimal: ");
+    Serial.print(decimal);
+    Serial.print(" (");
+    Serial.print( length );
+    Serial.print("Bit) Binary: ");
+    Serial.print( b );
+    Serial.print(" Tri-State: ");
+    Serial.print( bin2tristate( b) );
+    Serial.print(" PulseLength: ");
+    Serial.print(delay);
+    Serial.print(" microseconds");
+    Serial.print(" Protocol: ");
+    Serial.println(protocol);
+  }
+  
+  Serial.print("Raw data: ");
+  for (int i=0; i<= length*2; i++) {
+    Serial.print(raw[i]);
+    Serial.print(",");
+  }
+  Serial.println();
+  Serial.println();
+}
+
+
+static char* bin2tristate(char* bin) {
+  char returnValue[50];
+  int pos = 0;
+  int pos2 = 0;
+  while (bin[pos]!='\0' && bin[pos+1]!='\0') {
+    if (bin[pos]=='0' && bin[pos+1]=='0') {
+      returnValue[pos2] = '0';
+    } else if (bin[pos]=='1' && bin[pos+1]=='1') {
+      returnValue[pos2] = '1';
+    } else if (bin[pos]=='0' && bin[pos+1]=='1') {
+      returnValue[pos2] = 'F';
+    } else {
+      return "not applicable";
+    }
+    pos = pos+2;
+    pos2++;
+  }
+  returnValue[pos2] = '\0';
+  return returnValue;
+}
+

data/arduino/lib/RCSwitch/examples/ReceiveDemo_Simple/ReceiveDemo_Simple.pde

@@ -0,0 +1,35 @@
+/*
+  Simple example for receiving
+  
+  http://code.google.com/p/rc-switch/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+  Serial.begin(9600);
+  mySwitch.enableReceive(0);  // Receiver on inerrupt 0 => that is pin #2
+}
+
+void loop() {
+  if (mySwitch.available()) {
+    
+    int value = mySwitch.getReceivedValue();
+    
+    if (value == 0) {
+      Serial.print("Unknown encoding");
+    } else {
+      Serial.print("Received ");
+      Serial.print( mySwitch.getReceivedValue() );
+      Serial.print(" / ");
+      Serial.print( mySwitch.getReceivedBitlength() );
+      Serial.print("bit ");
+      Serial.print("Protocol: ");
+      Serial.println( mySwitch.getReceivedProtocol() );
+    }
+
+    mySwitch.resetAvailable();
+  }
+}

data/arduino/lib/RCSwitch/examples/SendDemo/SendDemo.pde

@@ -0,0 +1,57 @@
+/*
+  Example for different sending methods
+  
+  http://code.google.com/p/rc-switch/
+  
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  Serial.begin(9600);
+  
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+
+  // Optional set pulse length.
+  // mySwitch.setPulseLength(320);
+  
+  // Optional set protocol (default is 1, will work for most outlets)
+  // mySwitch.setProtocol(2);
+  
+  // Optional set number of transmission repetitions.
+  // mySwitch.setRepeatTransmit(15);
+  
+}
+
+void loop() {
+
+  /* See Example: TypeA_WithDIPSwitches */
+  mySwitch.switchOn("11111", "00010");
+  delay(1000);
+  mySwitch.switchOn("11111", "00010");
+  delay(1000);
+
+  /* Same switch as above, but using decimal code */
+  mySwitch.send(5393, 24);
+  delay(1000);  
+  mySwitch.send(5396, 24);
+  delay(1000);  
+
+  /* Same switch as above, but using binary code */
+  mySwitch.send("000000000001010100010001");
+  delay(1000);  
+  mySwitch.send("000000000001010100010100");
+  delay(1000);
+
+  /* Same switch as above, but tri-state code */ 
+  mySwitch.sendTriState("00000FFF0F0F");
+  delay(1000);  
+  mySwitch.sendTriState("00000FFF0FF0");
+  delay(1000);
+
+  delay(20000);
+}

data/arduino/lib/RCSwitch/examples/TypeA_WithDIPSwitches/TypeA_WithDIPSwitches.pde

@@ -0,0 +1,40 @@
+/*
+  Example for outlets which are configured with a 10 pole DIP switch.
+  
+  http://code.google.com/p/rc-switch/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+
+  // Optional set pulse length.
+  // mySwitch.setPulseLength(320);
+  
+}
+
+void loop() {
+
+  // Switch on:
+  // The first parameter represents the setting of the first 5 DIP switches. 
+  // In this example it's ON-ON-OFF-OFF-ON.
+  // 
+  // The second parameter represents the setting of the last 5 DIP switches. 
+  // In this example the last 5 DIP switches are OFF-ON-OFF-ON-OFF.  
+  mySwitch.switchOn("11001", "01010");
+
+  // Wait a second
+  delay(1000);
+  
+  // Switch off
+  mySwitch.switchOff("11001", "01010");
+  
+  // Wait another second
+  delay(1000);
+  
+}

data/arduino/lib/RCSwitch/examples/TypeA_WithDIPSwitches_Lightweight/TypeA_WithDIPSwitches_Lightweight.ino

@@ -0,0 +1,43 @@
+/*
+  This is a minimal sketch without using the library at all but only works for
+  the 10 pole dip switch sockets. It saves a lot of memory and thus might be 
+  very useful to use with ATTinys :)
+  
+  http://code.google.com/p/rc-switch/
+*/
+
+int RCLpin = 7;
+
+void setup() {
+    pinMode(RCLpin, OUTPUT);
+}
+
+void loop() {
+    RCLswitch(0b010001000001);  // DIPs an Steckdose: 0100010000 An:01
+    delay(2000);
+
+    RCLswitch(0b010001000010);  // DIPs an Steckdose: 0100010000 Aus:10
+    delay(2000);    
+}
+
+void RCLswitch(uint16_t code) {
+    for (int nRepeat=0; nRepeat<6; nRepeat++) {
+        for (int i=4; i<16; i++) {
+            RCLtransmit(1,3);
+            if (((code << (i-4)) & 2048) > 0) {
+                RCLtransmit(1,3);
+            } else {
+                RCLtransmit(3,1);
+            }
+        }
+        RCLtransmit(1,31);    
+    }
+}
+
+void RCLtransmit(int nHighPulses, int nLowPulses) {
+    digitalWrite(RCLpin, HIGH);
+    delayMicroseconds( 350 * nHighPulses);
+    digitalWrite(RCLpin, LOW);
+    delayMicroseconds( 350 * nLowPulses);
+}
+

data/arduino/lib/RCSwitch/examples/TypeB_WithRotaryOrSlidingSwitches/TypeB_WithRotaryOrSlidingSwitches.pde

@@ -0,0 +1,40 @@
+/*
+  Example for outlets which are configured with two rotary/sliding switches.
+  
+  http://code.google.com/p/rc-switch/
+*/
+
+#include <RCSwitch.h>
+
+RCSwitch mySwitch = RCSwitch();
+
+void setup() {
+
+  // Transmitter is connected to Arduino Pin #10  
+  mySwitch.enableTransmit(10);
+  
+  // Optional set pulse length.
+  // mySwitch.setPulseLength(320);
+  
+}
+
+void loop() {
+
+  // Switch on:
+  // The first parameter represents the setting of the first rotary switch. 
+  // In this example it's switched to "1" or "A" or "I". 
+  // 
+  // The second parameter represents the setting of the second rotary switch. 
+  // In this example it's switched to "4" or "D" or "IV". 
+  mySwitch.switchOn(1, 4);
+
+  // Wait a second
+  delay(1000);
+  
+  // Switch off
+  mySwitch.switchOff(1, 4);
+  
+  // Wait another second
+  delay(1000);
+  
+}