Hacking eines 433/434 MHz Funk-Schalt

Hacking
eines
433/434 MHz
Funk-SchaltZwischensteckers
[email protected]
Benötigte Hardware
- Arduino UNO R3 (oder kompatibles Board)
- 433/434 MHz Empfänger
- 433/434 MHz Sender zB RF-Link-Sender (Watterot)
oder
- Funk-Schalt-Zwischenstecker (hier Conrad)
- passender Sender zum Funk-Schalt-Zwischenstecker
- 3x Jumper Wire female – male
- USB Kabel für Arduino
Auslesen der Codes des Funk-Schalt-Zwischensteckers
Pin 1 : GND
Pin 2 : Data
Pin 4 : +5V
Pin 8 : Antenne (optinal)
die Jumper Wire an Pin 1 (GND, grün), Pin 2 (Data, blau) und Pin 4 (violett,
+5V) anschließen. Achtung Pin 3 bleibt leer. Die Antenne Pin 8 kann hier
wegfallen, da wir den Sender direkt davor halten und keine grosse Reichweite
überbrücken müssen.
Dann wird das Empfänger Modul an den Arduino angeschlossen. Grün an GND, violett
an +5V und blau an digital IO Pin 2.
Für die Software brauchen wir noch die RCSwitch Bibliothek, die in der Arduino
Entwicklungsumgebung installiert werden muss (https://github.com/sui77/rcswitch). Danach die unten stehende SW auf das Arduino Board spielen. Diese
befindet sich auch in den Beispielen der mitgelieferten Bibliothek.
/*
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();
}
Jetzt startet man den Seriellen Monitor in der Arduino Umgebung und drückt auf
dem Funk-Schalt-Zwischenstecker Sender die Tasten durch. Auf dem Monitor
erscheinen neben Received der Code den der Sender aussendet. Dieser kann ein
wenig variieren. Hier reicht es den am häufigsten angezeigten Code für die eine
Taste zu merken. Wichtig ist es sich die Ein-/Ausschaltcodes der Tasten zu
merken, bei der auch die Dose schaltet. Wichtig ist noch die Bitlänge zu merken
und die Protokollnummer. Die sich aber für das System nicht weiter ändert.
Bei meiner Conrad Dose war der Sender auf I gestellt und die Dose auf I und der
Tastencode auf 1. Somit schaltet die Dose auf den Tasten 1. Die Codes waren für
On : 1381717 und für Off : 1381716. Mit diesen Informationen kann nun der Sender
betrieben werden.
Senden der Codes an den Funk-Schalt-Zwischenstecker
Pin 1 : Data (blau)
Pin 2 : +5V (violett)
Pin 3 : GND (grün)
Die Jumper Wire an Pin 1 (Data,blau), Pin 2 (+5V, violett) und Pin 3 (GND,
grün).
Dann werden die Jumper Wire wieder mit dem Arduino verbunden mit der gleichen
Belegung, wie der Empfänger (Hab mir so ein Bild gespart). Grün an GND, violett
an +5V und blau an digital IO Pin 2.
Die Software zum Schalten der Funk-Schalt-Zwischensteckdose ist eine angepasste
Version des Sende Beispieles aus der RCSwitch-Bibliothek. Die digital IO Pin
Nummer der Datenleitung (blau) ist hier 2 und wird in im setup() in der Methode
mySwitch.enableTransmit(2); eingestellt. Die Sendecodes werden in der loop()
Funktion in der Methode mySwitch.send(1381717, 24); für an und
mySwitch.send(1381716, 24); für aus gesendet. In dieser Methode wird auch die
Bitlänge eingestellt.
/*
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(2);
// Optional set pulse length.
// mySwitch.setPulseLength(320);
// Optional set protocol (default is 1, will work for most outlets)
mySwitch.setProtocol(1);
// Optional set number of transmission repetitions.
// mySwitch.setRepeatTransmit(15);
}
void loop() {
/* Same switch as above, but using decimal code */
mySwitch.send(1381717, 24);
delay(1000);
mySwitch.send(1381716, 24);
delay(1000);
delay(5000);
}
Sollte alles richtig gemacht worden sein, so schaltet sich die Dose ein und nach
einer Sekunde wieder aus, um dann nach 5 Sekunden wieder eingeschaltet zu werden
Anhang: RCSwitch Bibliothek
RCSwitch.h
/*
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
*/
#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"
USA
#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
#define
#define
#define
#define
PROTOCOL3_SYNC_FACTOR
71
PROTOCOL3_0_HIGH_CYCLES 4
PROTOCOL3_0_LOW_CYCLES 11
PROTOCOL3_1_HIGH_CYCLES 9
PROTOCOL3_1_LOW_CYCLES
6
class RCSwitch {
public:
RCSwitch();
void
void
void
void
void
void
void
void
void
void
switchOn(int nGroupNumber, int nSwitchNumber);
switchOff(int nGroupNumber, int nSwitchNumber);
switchOn(char* sGroup, int nSwitchNumber);
switchOff(char* sGroup, int nSwitchNumber);
switchOn(char sFamily, int nGroup, int nDevice);
switchOff(char sFamily, int nGroup, int nDevice);
switchOn(char* sGroup, char* sDevice);
switchOff(char* sGroup, char* sDevice);
switchOn(char sGroup, int nDevice);
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
unsigned
unsigned
unsigned
unsigned
#endif
long getReceivedValue();
int getReceivedBitlength();
int getReceivedDelay();
int getReceivedProtocol();
int* getReceivedRawdata();
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
static bool receiveProtocol2(unsigned int
static bool receiveProtocol3(unsigned int
int nReceiverInterrupt;
#endif
int nTransmitterPin;
int nPulseLength;
int nRepeatTransmit;
char nProtocol;
)
changeCount);
changeCount);
changeCount);
#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
RCSwitch.cpp
/*
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
- Andreas Steinel / A.<lastname>(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
*/
#include "RCSwitch.h"
#if not defined( RCSwitchDisableReceiving )
unsigned long RCSwitch::nReceivedValue = NULL;
unsigned int RCSwitch::nReceivedBitlength = 0;
unsigned int RCSwitch::nReceivedDelay = 0;
unsigned int RCSwitch::nReceivedProtocol = 0;
int RCSwitch::nReceiveTolerance = 60;
#endif
unsigned int RCSwitch::timings[RCSWITCH_MAX_CHANGES];
RCSwitch::RCSwitch() {
this->nTransmitterPin = -1;
this->setPulseLength(350);
this->setRepeatTransmit(10);
this->setProtocol(1);
#if not defined( RCSwitchDisableReceiving )
this->nReceiverInterrupt = -1;
this->setReceiveTolerance(60);
RCSwitch::nReceivedValue = NULL;
#endif
}
/**
* Sets the protocol to send.
*/
void RCSwitch::setProtocol(int nProtocol) {
this->nProtocol = nProtocol;
if (nProtocol == 1){
this->setPulseLength(350);
}
else if (nProtocol == 2) {
this->setPulseLength(650);
}
else if (nProtocol == 3) {
this->setPulseLength(100);
}
}
/**
* Sets the protocol to send with pulse length in microseconds.
*/
void RCSwitch::setProtocol(int nProtocol, int nPulseLength) {
this->nProtocol = nProtocol;
this->setPulseLength(nPulseLength);
}
/**
USA
* Sets pulse length in microseconds
*/
void RCSwitch::setPulseLength(int nPulseLength) {
this->nPulseLength = nPulseLength;
}
/**
* Sets Repeat Transmits
*/
void RCSwitch::setRepeatTransmit(int nRepeatTransmit) {
this->nRepeatTransmit = nRepeatTransmit;
}
/**
* Set Receiving Tolerance
*/
#if not defined( RCSwitchDisableReceiving )
void RCSwitch::setReceiveTolerance(int nPercent) {
RCSwitch::nReceiveTolerance = nPercent;
}
#endif
/**
* Enable transmissions
*
* @param nTransmitterPin
Arduino Pin to which the sender is connected to
*/
void RCSwitch::enableTransmit(int nTransmitterPin) {
this->nTransmitterPin = nTransmitterPin;
pinMode(this->nTransmitterPin, OUTPUT);
}
/**
* Disable transmissions
*/
void RCSwitch::disableTransmit() {
this->nTransmitterPin = -1;
}
/**
* Switch a remote switch on (Type D REV)
*
* @param sGroup
Code of the switch group (A,B,C,D)
* @param nDevice
Number of the switch itself (1..3)
*/
void RCSwitch::switchOn(char sGroup, int nDevice) {
this->sendTriState( this->getCodeWordD(sGroup, nDevice, true) );
}
/**
* Switch a remote switch off (Type D REV)
*
* @param sGroup
Code of the switch group (A,B,C,D)
* @param nDevice
Number of the switch itself (1..3)
*/
void RCSwitch::switchOff(char sGroup, int nDevice) {
this->sendTriState( this->getCodeWordD(sGroup, nDevice, false) );
}
/**
* Switch a remote switch on (Type C Intertechno)
*
* @param sFamily Familycode (a..f)
* @param nGroup
Number of group (1..4)
* @param nDevice Number of device (1..4)
*/
void RCSwitch::switchOn(char sFamily, int nGroup, int nDevice) {
this->sendTriState( this->getCodeWordC(sFamily, nGroup, nDevice, true) );
}
/**
* Switch a remote switch off (Type C Intertechno)
*
* @param sFamily Familycode (a..f)
* @param nGroup
Number of group (1..4)
* @param nDevice Number of device (1..4)
*/
void RCSwitch::switchOff(char sFamily, int nGroup, int nDevice) {
this->sendTriState( this->getCodeWordC(sFamily, nGroup, nDevice, false) );
}
/**
* Switch a remote switch on (Type B with two rotary/sliding switches)
*
* @param nAddressCode Number of the switch group (1..4)
* @param nChannelCode Number of the switch itself (1..4)
*/
void RCSwitch::switchOn(int nAddressCode, int nChannelCode) {
this->sendTriState( this->getCodeWordB(nAddressCode, nChannelCode, true) );
}
/**
* Switch a remote switch off (Type B with two rotary/sliding switches)
*
* @param nAddressCode Number of the switch group (1..4)
* @param nChannelCode Number of the switch itself (1..4)
*/
void RCSwitch::switchOff(int nAddressCode, int nChannelCode) {
this->sendTriState( this->getCodeWordB(nAddressCode, nChannelCode, false) );
}
/**
* Deprecated, use switchOn(char* sGroup, char* sDevice) instead!
* Switch a remote switch on (Type A with 10 pole DIP switches)
*
* @param sGroup
Code of the switch group (refers to DIP switches 1..5
where "1" = on and "0" = off, if all DIP switches are on it's "11111")
* @param nChannelCode Number of the switch itself (1..5)
*/
void RCSwitch::switchOn(char* sGroup, int nChannel) {
char* code[6] = { "00000", "10000", "01000", "00100", "00010", "00001" };
this->switchOn(sGroup, code[nChannel]);
}
/**
* Deprecated, use switchOff(char* sGroup, char* sDevice) instead!
* Switch a remote switch off (Type A with 10 pole DIP switches)
*
* @param sGroup
Code of the switch group (refers to DIP switches 1..5
where "1" = on and "0" = off, if all DIP switches are on it's "11111")
* @param nChannelCode Number of the switch itself (1..5)
*/
void RCSwitch::switchOff(char* sGroup, int nChannel) {
char* code[6] = { "00000", "10000", "01000", "00100", "00010", "00001" };
this->switchOff(sGroup, code[nChannel]);
}
/**
* Switch a remote switch on (Type A with 10 pole DIP switches)
*
* @param sGroup
Code of the switch group (refers to DIP switches 1..5
where "1" = on and "0" = off, if all DIP switches are on it's "11111")
* @param sDevice
Code of the switch device (refers to DIP switches 6..10
(A..E) where "1" = on and "0" = off, if all DIP switches are on it's "11111")
*/
void RCSwitch::switchOn(char* sGroup, char* sDevice) {
this->sendTriState( this->getCodeWordA(sGroup, sDevice, true) );
}
/**
* Switch a remote switch off (Type A with 10 pole DIP switches)
*
* @param sGroup
Code of the switch group (refers to DIP switches 1..5
where "1" = on and "0" = off, if all DIP switches are on it's "11111")
* @param sDevice
Code of the switch device (refers to DIP switches 6..10
(A..E) where "1" = on and "0" = off, if all DIP switches are on it's "11111")
*/
void RCSwitch::switchOff(char* sGroup, char* sDevice) {
this->sendTriState( this->getCodeWordA(sGroup, sDevice, false) );
}
/**
* Returns a char[13], representing the Code Word to be send.
* A Code Word consists of 9 address bits, 3 data bits and one sync bit but in
our case only the first 8 address bits and the last 2 data bits were used.
* A Code Bit can have 4 different states: "F" (floating), "0" (low), "1"
(high), "S" (synchronous bit)
*
* +-------------------------------+-------------------------------+----------------------------------------+-----------------------------------------+----------------------+------------+
* | 4 bits address (switch group) | 4 bits address (switch number) | 1 bit
address (not used, so never mind) | 1 bit address (not used, so never mind) | 2
data bits (on|off) | 1 sync bit |
* | 1=0FFF 2=F0FF 3=FF0F 4=FFF0
| 1=0FFF 2=F0FF 3=FF0F 4=FFF0
| F
| F
| on=FF off=F0
| S
|
* +-------------------------------+-------------------------------+----------------------------------------+-----------------------------------------+----------------------+------------+
*
* @param nAddressCode Number of the switch group (1..4)
* @param nChannelCode Number of the switch itself (1..4)
* @param bStatus
Wether to switch on (true) or off (false)
*
* @return char[13]
*/
char* RCSwitch::getCodeWordB(int nAddressCode, int nChannelCode, boolean
bStatus) {
int nReturnPos = 0;
static char sReturn[13];
char* code[5] = { "FFFF", "0FFF", "F0FF", "FF0F", "FFF0" };
if (nAddressCode < 1 || nAddressCode > 4 || nChannelCode < 1 || nChannelCode
> 4) {
return '\0';
}
for (int i = 0; i<4; i++) {
sReturn[nReturnPos++] = code[nAddressCode][i];
}
for (int i = 0; i<4; i++) {
sReturn[nReturnPos++] = code[nChannelCode][i];
}
sReturn[nReturnPos++] = 'F';
sReturn[nReturnPos++] = 'F';
sReturn[nReturnPos++] = 'F';
if (bStatus) {
sReturn[nReturnPos++] = 'F';
} else {
sReturn[nReturnPos++] = '0';
}
sReturn[nReturnPos] = '\0';
return sReturn;
}
/**
* Returns a char[13], representing the Code Word to be send.
*
* getCodeWordA(char*, char*)
*
*/
char* RCSwitch::getCodeWordA(char* sGroup, char* sDevice, boolean bOn) {
static char sDipSwitches[13];
int i = 0;
int j = 0;
for (i=0; i < 5; i++) {
if (sGroup[i] == '0') {
sDipSwitches[j++] = 'F';
} else {
sDipSwitches[j++] = '0';
}
}
for (i=0; i < 5; i++) {
if (sDevice[i] == '0') {
sDipSwitches[j++] = 'F';
} else {
sDipSwitches[j++] = '0';
}
}
if ( bOn ) {
sDipSwitches[j++]
sDipSwitches[j++]
} else {
sDipSwitches[j++]
sDipSwitches[j++]
}
= '0';
= 'F';
= 'F';
= '0';
sDipSwitches[j] = '\0';
return sDipSwitches;
}
/**
* Like getCodeWord (Type C = Intertechno)
*/
char* RCSwitch::getCodeWordC(char sFamily, int nGroup, int nDevice, boolean
bStatus) {
static char sReturn[13];
int nReturnPos = 0;
if ( (byte)sFamily < 97 || (byte)sFamily > 112 || nGroup < 1 || nGroup > 4 ||
nDevice < 1 || nDevice > 4) {
return '\0';
}
char* sDeviceGroupCode = dec2binWzerofill( (nDevice-1) + (nGroup-1)*4, 4
char familycode[16][5] = { "0000", "F000", "0F00", "FF00", "00F0", "F0F0",
"0FF0", "FFF0", "000F", "F00F", "0F0F", "FF0F", "00FF", "F0FF", "0FFF",
"FFFF" };
for (int i = 0; i<4; i++) {
sReturn[nReturnPos++] = familycode[ (int)sFamily - 97 ][i];
}
for (int i = 0; i<4; i++) {
sReturn[nReturnPos++] = (sDeviceGroupCode[3-i] == '1' ? 'F' : '0');
}
sReturn[nReturnPos++] = '0';
sReturn[nReturnPos++] = 'F';
sReturn[nReturnPos++] = 'F';
if (bStatus) {
sReturn[nReturnPos++] = 'F';
} else {
sReturn[nReturnPos++] = '0';
}
sReturn[nReturnPos] = '\0';
return sReturn;
}
);
/**
* Decoding for the REV Switch Type
*
* Returns a char[13], representing the Tristate to be send.
* A Code Word consists of 7 address bits and 5 command data bits.
* A Code Bit can have 3 different states: "F" (floating), "0" (low), "1" (high)
*
* +-------------------------------+-------------------------------+-----------------------+
* | 4 bits address (switch group) | 3 bits address (device number) | 5 bits
(command data) |
* | A=1FFF B=F1FF C=FF1F D=FFF1
| 1=0FFF 2=F0FF 3=FF0F 4=FFF0
| on=00010
off=00001
|
* +-------------------------------+-------------------------------+-----------------------+
*
* Source: http://www.the-intruder.net/funksteckdosen-von-rev-uber-arduinoansteuern/
*
* @param sGroup
Name of the switch group (A..D, resp. a..d)
* @param nDevice
Number of the switch itself (1..3)
* @param bStatus
Wether to switch on (true) or off (false)
*
* @return char[13]
*/
char* RCSwitch::getCodeWordD(char sGroup, int nDevice, boolean bStatus){
static char sReturn[13];
int nReturnPos = 0;
// Building 4 bits address
// (Potential problem if dec2binWcharfill not returning correct string)
char *sGroupCode;
switch(sGroup){
case 'a':
}
case 'A':
sGroupCode =
case 'b':
case 'B':
sGroupCode =
case 'c':
case 'C':
sGroupCode =
case 'd':
case 'D':
sGroupCode =
default:
return '\0';
dec2binWcharfill(8, 4, 'F'); break;
dec2binWcharfill(4, 4, 'F'); break;
dec2binWcharfill(2, 4, 'F'); break;
dec2binWcharfill(1, 4, 'F'); break;
for (int i = 0; i<4; i++)
{
sReturn[nReturnPos++] = sGroupCode[i];
}
// Building 3 bits address
// (Potential problem if dec2binWcharfill not returning correct string)
char *sDevice;
switch(nDevice) {
case 1:
sDevice = dec2binWcharfill(4, 3, 'F'); break;
case 2:
sDevice = dec2binWcharfill(2, 3, 'F'); break;
case 3:
sDevice = dec2binWcharfill(1, 3, 'F'); break;
default:
return '\0';
}
for (int i = 0; i<3; i++)
sReturn[nReturnPos++] = sDevice[i];
// fill up rest with zeros
for (int i = 0; i<5; i++)
sReturn[nReturnPos++] = '0';
// encode on or off
if (bStatus)
sReturn[10] = '1';
else
sReturn[11] = '1';
// last position terminate string
sReturn[12] = '\0';
return sReturn;
}
/**
* @param sCodeWord
/^[10FS]*$/ -> see getCodeWord
*/
void RCSwitch::sendTriState(char* sCodeWord) {
for (int nRepeat=0; nRepeat<nRepeatTransmit; nRepeat++) {
int i = 0;
while (sCodeWord[i] != '\0') {
switch(sCodeWord[i]) {
case '0':
this->sendT0();
break;
case 'F':
this->sendTF();
break;
case '1':
this->sendT1();
break;
}
i++;
}
}
this->sendSync();
}
void RCSwitch::send(unsigned long Code, unsigned int length) {
this->send( this->dec2binWzerofill(Code, length) );
}
void RCSwitch::send(char* sCodeWord) {
for (int nRepeat=0; nRepeat<nRepeatTransmit; nRepeat++) {
int i = 0;
while (sCodeWord[i] != '\0') {
switch(sCodeWord[i]) {
case '0':
this->send0();
break;
case '1':
this->send1();
break;
}
i++;
}
this->sendSync();
}
}
void RCSwitch::transmit(int nHighPulses, int nLowPulses) {
#if not defined ( RCSwitchDisableReceiving )
boolean disabled_Receive = false;
int nReceiverInterrupt_backup = nReceiverInterrupt;
#endif
if (this->nTransmitterPin != -1) {
#if not defined( RCSwitchDisableReceiving )
if (this->nReceiverInterrupt != -1) {
this->disableReceive();
disabled_Receive = true;
}
#endif
digitalWrite(this->nTransmitterPin, HIGH);
delayMicroseconds( this->nPulseLength * nHighPulses);
digitalWrite(this->nTransmitterPin, LOW);
delayMicroseconds( this->nPulseLength * nLowPulses);
#if not defined( RCSwitchDisableReceiving )
if(disabled_Receive){
this->enableReceive(nReceiverInterrupt_backup);
}
#endif
}
}
/**
* Sends a "0" Bit
*
_
* Waveform Protocol 1: | |___
*
_
* Waveform Protocol 2: | |__
*/
void RCSwitch::send0() {
if (this->nProtocol == 1){
this->transmit(1,3);
}
else if (this->nProtocol == 2) {
this->transmit(1,2);
}
else if (this->nProtocol == 3) {
this->transmit(4,11);
}
}
/**
* Sends a "1" Bit
*
___
* Waveform Protocol 1: |
|_
*
__
* Waveform Protocol 2: | |_
*/
void RCSwitch::send1() {
if (this->nProtocol == 1){
this->transmit(3,1);
}
else if (this->nProtocol == 2) {
this->transmit(2,1);
}
else if (this->nProtocol == 3) {
this->transmit(9,6);
}
}
/**
* Sends a Tri-State "0" Bit
*
_
_
* Waveform: | |___| |___
*/
void RCSwitch::sendT0() {
this->transmit(1,3);
this->transmit(1,3);
}
/**
* Sends a Tri-State "1" Bit
*
___
___
* Waveform: |
|_|
|_
*/
void RCSwitch::sendT1() {
this->transmit(3,1);
this->transmit(3,1);
}
/**
* Sends a Tri-State "F" Bit
*
_
___
* Waveform: | |___|
|_
*/
void RCSwitch::sendTF() {
this->transmit(1,3);
this->transmit(3,1);
}
/**
* Sends a "Sync" Bit
*
_
* Waveform Protocol 1: | |_______________________________
*
_
* Waveform Protocol 2: | |__________
*/
void RCSwitch::sendSync() {
}
if (this->nProtocol == 1){
this->transmit(1,31);
}
else if (this->nProtocol == 2) {
this->transmit(1,10);
}
else if (this->nProtocol == 3) {
this->transmit(1,71);
}
#if not defined( RCSwitchDisableReceiving )
/**
* Enable receiving data
*/
void RCSwitch::enableReceive(int interrupt) {
this->nReceiverInterrupt = interrupt;
this->enableReceive();
}
void RCSwitch::enableReceive() {
if (this->nReceiverInterrupt != -1) {
RCSwitch::nReceivedValue = NULL;
RCSwitch::nReceivedBitlength = NULL;
attachInterrupt(this->nReceiverInterrupt, handleInterrupt, CHANGE);
}
}
/**
* Disable receiving data
*/
void RCSwitch::disableReceive() {
detachInterrupt(this->nReceiverInterrupt);
this->nReceiverInterrupt = -1;
}
bool RCSwitch::available() {
return RCSwitch::nReceivedValue != NULL;
}
void RCSwitch::resetAvailable() {
RCSwitch::nReceivedValue = NULL;
}
unsigned long RCSwitch::getReceivedValue() {
return RCSwitch::nReceivedValue;
}
unsigned int RCSwitch::getReceivedBitlength() {
return RCSwitch::nReceivedBitlength;
}
unsigned int RCSwitch::getReceivedDelay() {
return RCSwitch::nReceivedDelay;
}
unsigned int RCSwitch::getReceivedProtocol() {
return RCSwitch::nReceivedProtocol;
}
unsigned int* RCSwitch::getReceivedRawdata() {
return RCSwitch::timings;
}
/**
*
*/
bool RCSwitch::receiveProtocol1(unsigned int changeCount){
unsigned long code = 0;
unsigned long delay = RCSwitch::timings[0] / 31;
unsigned long delayTolerance = delay * RCSwitch::nReceiveTolerance * 0.01;
for (int i = 1; i<changeCount ; i=i+2) {
if (RCSwitch::timings[i] > delay-delayTolerance &&
RCSwitch::timings[i] < delay+delayTolerance && RCSwitch::timings[i+1] > delay*3delayTolerance && RCSwitch::timings[i+1] < delay*3+delayTolerance) {
code = code << 1;
} else if (RCSwitch::timings[i] > delay*3-delayTolerance &&
RCSwitch::timings[i] < delay*3+delayTolerance && RCSwitch::timings[i+1] > delaydelayTolerance && RCSwitch::timings[i+1] < delay+delayTolerance) {
code+=1;
code = code << 1;
} else {
// Failed
i = changeCount;
code = 0;
}
}
code = code >> 1;
if (changeCount > 6) {
// ignore < 4bit values as there are no devices
sending 4bit values => noise
RCSwitch::nReceivedValue = code;
RCSwitch::nReceivedBitlength = changeCount / 2;
RCSwitch::nReceivedDelay = delay;
RCSwitch::nReceivedProtocol = 1;
}
if (code == 0){
return false;
}else if (code != 0){
return true;
}
}
bool RCSwitch::receiveProtocol2(unsigned int changeCount){
unsigned long code = 0;
unsigned long delay = RCSwitch::timings[0] / 10;
unsigned long delayTolerance = delay * RCSwitch::nReceiveTolerance * 0.01;
for (int i = 1; i<changeCount ; i=i+2) {
if (RCSwitch::timings[i] > delay-delayTolerance &&
RCSwitch::timings[i] < delay+delayTolerance && RCSwitch::timings[i+1] > delay*2delayTolerance && RCSwitch::timings[i+1] < delay*2+delayTolerance) {
code = code << 1;
} else if (RCSwitch::timings[i] > delay*2-delayTolerance &&
RCSwitch::timings[i] < delay*2+delayTolerance && RCSwitch::timings[i+1] > delaydelayTolerance && RCSwitch::timings[i+1] < delay+delayTolerance) {
code+=1;
code = code << 1;
} else {
// Failed
i = changeCount;
code = 0;
}
}
code = code >> 1;
if (changeCount > 6) {
// ignore < 4bit values as there are no devices
sending 4bit values => noise
RCSwitch::nReceivedValue = code;
RCSwitch::nReceivedBitlength = changeCount / 2;
RCSwitch::nReceivedDelay = delay;
RCSwitch::nReceivedProtocol = 2;
}
if (code == 0){
return false;
}else if (code != 0){
return true;
}
}
/** Protocol 3 is used by BL35P02.
*
*/
bool RCSwitch::receiveProtocol3(unsigned int changeCount){
unsigned long code = 0;
unsigned long delay = RCSwitch::timings[0] / PROTOCOL3_SYNC_FACTOR;
unsigned long delayTolerance = delay * RCSwitch::nReceiveTolerance * 0.01;
for (int i = 1; i<changeCount ; i=i+2) {
if (RCSwitch::timings[i]
> delay*PROTOCOL3_0_HIGH_CYCLES delayTolerance
&& RCSwitch::timings[i]
< delay*PROTOCOL3_0_HIGH_CYCLES +
delayTolerance
&& RCSwitch::timings[i+1] > delay*PROTOCOL3_0_LOW_CYCLES delayTolerance
&& RCSwitch::timings[i+1] < delay*PROTOCOL3_0_LOW_CYCLES +
delayTolerance) {
code = code << 1;
} else if (RCSwitch::timings[i]
> delay*PROTOCOL3_1_HIGH_CYCLES
delayTolerance
&& RCSwitch::timings[i]
< delay*PROTOCOL3_1_HIGH_CYCLES
delayTolerance
&& RCSwitch::timings[i+1] > delay*PROTOCOL3_1_LOW_CYCLES
delayTolerance
&& RCSwitch::timings[i+1] < delay*PROTOCOL3_1_LOW_CYCLES
delayTolerance) {
code+=1;
code = code << 1;
} else {
+
+
// Failed
i = changeCount;
code = 0;
}
}
code = code >> 1;
if (changeCount > 6) {
// ignore < 4bit values as there are no devices
sending 4bit values => noise
RCSwitch::nReceivedValue = code;
RCSwitch::nReceivedBitlength = changeCount / 2;
RCSwitch::nReceivedDelay = delay;
RCSwitch::nReceivedProtocol = 3;
}
if (code
return
}else if
return
}
}
== 0){
false;
(code != 0){
true;
void RCSwitch::handleInterrupt() {
static
static
static
static
unsigned
unsigned
unsigned
unsigned
int duration;
int changeCount;
long lastTime;
int repeatCount;
long time = micros();
duration = time - lastTime;
if (duration > 5000 && duration > RCSwitch::timings[0] - 200 && duration <
RCSwitch::timings[0] + 200) {
repeatCount++;
changeCount--;
if (repeatCount == 2) {
if (receiveProtocol1(changeCount) == false){
if (receiveProtocol2(changeCount) == false){
if (receiveProtocol3(changeCount) == false){
//failed
}
}
}
repeatCount = 0;
}
changeCount = 0;
} else if (duration > 5000) {
changeCount = 0;
}
if (changeCount >= RCSWITCH_MAX_CHANGES) {
changeCount = 0;
repeatCount = 0;
}
RCSwitch::timings[changeCount++] = duration;
lastTime = time;
}
#endif
/**
* Turns a decimal value to its binary representation
*/
char* RCSwitch::dec2binWzerofill(unsigned long Dec, unsigned int bitLength){
}
return dec2binWcharfill(Dec, bitLength, '0');
char* RCSwitch::dec2binWcharfill(unsigned long Dec, unsigned int bitLength, char
fill){
static char bin[64];
unsigned int i=0;
while (Dec > 0) {
bin[32+i++] = ((Dec & 1) > 0) ? '1' : fill;
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] = fill;
}
}
bin[bitLength] = '\0';
}
return bin;

Download Report