Basic sirens coupled with Normal Open and Normal Closed sensors were the obvious first step because they are cheap and fairly easy to understand and implement. And they give you rudimentary detection and feedback capabilities. But I want more, and to get more I have been exploring all the IP based options available for controlling lights, outlets, and other household devices.
Unfortunately, in part to the current smart house craze, any device that supports traditional smart house technology like z-wave, wifi, and zigbee are extremely expensive. But then I thought about traditional remote controls.
The vast majority of remotely controlled devices use standard Radio Frequencies (RF), usually in the 315 or 433MHz range. Most people do not consider this to be smart house related because they only work up to a range of a few hundred feet, are usually unidirectional in communication, have no interface to be controlled through the Internet, and absolutely zero security around the protocol.
There isn't much I can do about the lack of security, that's just a fact of life about cheap remote controls. However, I did not see any reason why I could not make a computer connected radio that sent out the same wave patterns as my remotes. With these cloned signals I would then be able to remotely and centrally control anything with an RF receiver in it.
After days of reading about the subject and other peoples attempts to do the same thing, I bought an arduino and a 315MHz receiver/transmitter set. Three days later after a lot of signal analysis, trial and error, I finally got my first signal cloned. I now have the ability to repeat the process for any RF remote that operates on the 315MHz frequency with a fixed code and control its item remotely as a fully integral part of my smart house.
The process involved:
- writing a program for arduino that sampled one of the analog pins on a tight loop tracking the strength and duration of the signal fluxuations.
- I then moved this data into excel where I normalized it to determine the binary code it was sending.
- Converted that binary code into an integer mapping table for condensed storage.
- Wrote a program to use a digital out pin to send that signal to the transmitter which turned it back into an analog wave form in the air.
To be fair, both of the base programs I started with someone else who knew the arduino far better wrote, I just modified them to be more efficient for my use case.
Here is the code for the RF Receiver to capture signals:
#define analogPin A0 // RF data pin = Analog pin 0
byte dataBuffer[512];
int dataCounter = 0;
int maxSignalLength = 255;
const unsigned int upperThreshold = 100;
const unsigned int lowerThreshold = 80;
void setup() {
Serial.begin(115200);
// wait until a LOW signal is received
while(analogRead(analogPin) < 1) { }
// got HIGH; read the rest of the data into dataBuffer
for (int i = 0; i < sizeof(dataBuffer); i = i+2) {
// LOW signals
dataCounter = 0;
while (analogRead(analogPin) > upperThreshold && dataCounter < maxSignalLength)
dataCounter++;
dataBuffer[i] = dataCounter;
// HIGH signal
dataCounter = 0;
while(analogRead(analogPin) < lowerThreshold && dataCounter < maxSignalLength)
dataCounter++;
dataBuffer[i+1] = dataCounter;
}
Serial.println("LOW,HIGH");
delay(20);
for (int i = 0; i < sizeof(dataBuffer); i = i+2) {
Serial.print(dataBuffer[i]);
Serial.print(",");
Serial.println(dataBuffer[i+1]);
delay(20);
}
}
void loop() { }
Receiving the signals is pretty straight forward. You have to wire your receiver into the arduino. If you are holding it with the top of the board facing you, then the pins are from left to right: Power, Data, Data, Ground. Hook the Power (or Vcc) into a 5V pin, 3.3V should work as well. This code is supposed to be used with the second Data pin, but it doesn't really matter, the HIGH/LOW values will just be reversed if you use the other pin.
Upload the code to the arduino, it will automatically run since it is all in the setup function. Press Ctrl+Shift+M to bring up the serial monitor, and make sure you set it to receive at 115200.
Immediately press the button on your remote. Once the data appearing on the screen it is too late, the capture has already taken place. I had to do this process several times, playing with the data each time until I finally got a capture that was clean enough I was able to find a good pattern in it.
Next you need to paste the data into excel, or some other text editor and start manipulating it. You need to split it into two columns, a HIGH and LOW column, then count the number of occurrences of every value one column at a time. I wrote a macro to do this for me (the guy who's tutorial I followed wrote a php script for himself).
Next sort the value low to high based on the value that was being counted.
This is the really tricky part now. You need to identify the signal groupings. Most basic remotes are only going to have two. A common short burst and a common long burst; or smaller number and larger number. So pick the low value and the high value that occur most frequently and group the other more random values in on those two. I picked the values manually, but had Excel re-write the originally values into two new "normalized" columns for me.
Then you re-combine the two new "normalized" columns back into a single column, perform a Unique function on them, and number each unique value. The purpose for this is we need an easy way to identify the values, copying and pasting all those values pairs into code over and over would just get too difficult very fast.
Finally you make another column which pairs the two "normalized" columns up with their newly assigned unique value. Combine all those values into a comma delimited string. And start searching for patterns. I often find that the unique value column is a better place for me to go pattern hunting in. Values of 0 and 255 are timeouts and can usually be ignored; if they happen in a very specific pattern inside of the pattern you end up identifying then it could indicate a missing value that you need or could try guessing at.
Here is what my excel sheet looked like through one of these processes:
Upload the code to the arduino, it will automatically run since it is all in the setup function. Press Ctrl+Shift+M to bring up the serial monitor, and make sure you set it to receive at 115200.
Immediately press the button on your remote. Once the data appearing on the screen it is too late, the capture has already taken place. I had to do this process several times, playing with the data each time until I finally got a capture that was clean enough I was able to find a good pattern in it.
Next you need to paste the data into excel, or some other text editor and start manipulating it. You need to split it into two columns, a HIGH and LOW column, then count the number of occurrences of every value one column at a time. I wrote a macro to do this for me (the guy who's tutorial I followed wrote a php script for himself).
Next sort the value low to high based on the value that was being counted.
This is the really tricky part now. You need to identify the signal groupings. Most basic remotes are only going to have two. A common short burst and a common long burst; or smaller number and larger number. So pick the low value and the high value that occur most frequently and group the other more random values in on those two. I picked the values manually, but had Excel re-write the originally values into two new "normalized" columns for me.
Then you re-combine the two new "normalized" columns back into a single column, perform a Unique function on them, and number each unique value. The purpose for this is we need an easy way to identify the values, copying and pasting all those values pairs into code over and over would just get too difficult very fast.
Finally you make another column which pairs the two "normalized" columns up with their newly assigned unique value. Combine all those values into a comma delimited string. And start searching for patterns. I often find that the unique value column is a better place for me to go pattern hunting in. Values of 0 and 255 are timeouts and can usually be ignored; if they happen in a very specific pattern inside of the pattern you end up identifying then it could indicate a missing value that you need or could try guessing at.
Here is what my excel sheet looked like through one of these processes:
And here is the Code to re-transmit the signal, however it will have to be modified for your values:
#define transmitPin 7 // RF transmit pin = Digital pin 7
int ding[] = {1,2,3,2,3,2,3,2,2,2,2,2,3,2,3,2,3,2,2,3,3,2,2,2,2};
// Play with this value
int timeDelay = 155;
int signalPin = 13;
int numberOfTransmissions = 19;
int numberOfSignalInTransmission = (sizeof(ding)/sizeof(int)) - 1;
void setup() {
Serial.begin(9600);
pinMode(transmitPin, OUTPUT);
pinMode(signalPin, OUTPUT);
delay(2000);
// wait 3 seconds, then transmit the payload
int highLength = 0;
int lowLength = 0;
for(int y = 105; y < 415; y=y+10) {
for(int x = 0; x < numberOfTransmissions; x++) {
if(x % 2 == 0)
digitalWrite(signalPin, HIGH);
else
digitalWrite(signalPin, LOW);
for(int i = 0; i < numberOfSignalInTransmission; i++) {
switch(ding[i]) {
case 1:
lowLength = 3;
highLength = 119;
break;
case 3:
lowLength = 3;
highLength = 11;
break;
case 2:
lowLength = 11;
highLength = 3;
break;
case 4:
lowLength = 5;
highLength = 5;
break;
case 5:
lowLength = 42;
highLength = 2;
break;
}
// transmit HIGH signal
digitalWrite(transmitPin, HIGH);
delayMicroseconds(highLength*y);
// transmit LOW signal
digitalWrite(transmitPin,LOW);
delayMicroseconds(lowLength*y);
}
}
}
}
void loop() { }
The transmitter comes with 3 or 4 pins depending on if it has an onboard antenna or not. The antenna is absolutely critical; I had a receiver that came without one and it would rarely pick up any signals unless I held a bit of mettle over the solder point where the antenna was supposed to be.
The pins from left to right if you are holding it facing you are: Digital receiver (hook to digital pin 7 for the code above), Power (Vcc 3.3V or 5V, they can usually go up to 12V for increased range), Ground.
The code above is designed with three nested for loops.
The inner most simply takes the ding[] array, converts it back into the values from the normalized columns in your excel document using a case statement, and transmits them. I did not need the last two case statements in this instance.
The next one out specifies how many times you want to send the pattern; most remotes transmit a repeating pattern several times so there is no point is storing multiple copies of the same pattern if we can just loop through it several times.
The outermost loop is very important. It adjusts the length of the signals you are sending out, how long each high/low signal should be held for before moving on to the next. The remotes I have seen use a value in the high 200s or low 300s for this. Finding the precise number can be quite difficult though, so looping through a range that increments by 10 microseconds is a much faster way to at least figure out if you are on the right track before trying to narrow the signal down.
------------------------
Unfortunately it looks like the website I used to figure this all out has gone offline, which is a bummer because it had very detailed step-by-step instructions and was the only set of instructions I could find that I was able to understand clearly enough to figure this all out.
I believe this is the original site I got my tutorial from that is no longer active.
However, here is another site that looks almost as good.
