The Hardware

Recently I’ve acquired a Home Easy HE217 remote light switch which consists of a unit placed between the light bulb and ceiling rose and a wireless switch to switch the light on and off from anywhere within about 10m. I purchased this with some form of hackery in mind but this is the first real attempt to do anything useful outside of the functionality of the supplied package. The system uses RF at 433MHz and a simple authentication protocol, which is conveniently documented at the Home Easy Hacking Wiki.

433MHz is a common frequency used by radio controlled devices such as remote switches, garage doors and car remote controls and transmitters and receivers are readily available for very little money (around $5). These can be used for many uses especially in combination with an arduino, following on from the work documented on the Home Easy Hacking Wiki an arduino library has been produced (available here). This allows the arduino to control the light switch in the same way as the provided Home Easy light switch.

The RF transmitter was then simply connected to the arduino to allow the light switch to be controlled using the arduino.

The software

The software aspect of this project consists of my previous processing sketch which receives button presses from the chronos watch, to this I added functionality so that every time a button press is received a serial character is sent to the arduino in this case H for on and L for off.

On the arduino a sketch is used that reads the serial input and when H or L is received it send an on or off message using the home easy arduino library thus switching the light. The observant among you will have noticed that this is based on the arduino physical pixel example!

The system works even if the watch is taken out of transmit mode and then restarted.

The code can be viewed below.

In action

The code

The processing sketch chronoslight.pde

The arduino sketch: chronosHE.pde

The process of acquiring the data, the same request string is sent however in PPT mode the return is different, the third byte determining which button has been pressed in the case of my watch the buttons return the values below:

Top left: 18

Top right: 50

Bottom left: 34

However these are different to the values Sean found, his being one less in each case (i.e. 17,49 and 33) so some experimentation may be required.

Update: A kind commenter has pointed out that in PPT mode the values are as I listed, and in ACC mode they are the lower values.

Code

Original python code: chronosbuttono.py (originally posted here http://pastebin.com/m5d1b7ced however doesn’t seem to work with my watch)

My working python code: chronosbutton.py

My processing sketch: chronosbutton.pde

Following on from the sample code posted by Sean (pastebin or my mirror) I have made the code into a more conventional processing style and added simple graphing functionality in processing to allow the simultaneous graphing of xyz data and my updated code can be found below.

Using processing seems to perform slightly less well than python as it is slower and less data arrives marked as valid (any thoughts on why this is would be appreciated as always) but still provides a workable system. It does seem to be linked to problems I was having implementing this, where the data appeared jumbled, at that time I wasn’t aware of the validation byte.

Code

chronosgraph.pde – sketch to take data and graph it

chronos.pde - original  sketch which just gets data (Sean Brewer)

Recently my Texas Instruments ez430 Chronos watch arrived, I preordered it the day I read about it on engadget back in November 2009, so it was nice to receive it after all this time. As a dedicated Linux user I found it disappointing that there was little in the way of Linux support provided by TI, however this was not unexpected and a linux application is currently being developed, although progress seems to be somewhat slow. However in the last week breakthroughs have been made, uguryildiz in a post on the TI forum revealed the protocol used to request data from the acceleration sensors and also for setting of the time allowing custom applications to be built using this data on Linux or any other operating system able to use usb serial.

Example code in python was also posted here, basically the protocol for getting the accelerometer data is very simple:

• After connecting the RF USB dongle supplied with the watch and putthe watch into ACC transmit mode and connect to the serial port /dev/ACM0 (on linux) with baud of 115200
• Send the hex string: 0xFF 0×07 0×03 to open a connection with the watch, it should reply 0xFF 0×06 0×03 to confirm a connection has been made
• Accelerometer data can then be requested by sending 0xFF, 0×08, 0×07, 0×00, 0×00, 0×00, 0×00
• The watch will then return seven bytes back in the form ff 06 07 tt xx yy zz where the last three bytes are the accelerometer values.

As a simple experiment I used the afore mentioned python code to get data from the watch and then combined this with a graphing gui example kindly posted by Eli Bendersky to make an application which uses matplotlib produce a live graph of the data (currently only one axis at a time).

My code can be downloaded here: chronos_graph.py

It should be noted that this code is very much hacked together, I am not a python coder and have never written anything in python before in my life, but it should work.

I am currently working on trying to get this working with processing and arduino, however serial communication from processing with the watch is proving troublesome so I reverted to python for this example.


import controlP5.*;

ControlP5 controlP5;
int myColorBackground = color(0,0,0);

void setup() {
size(400,200);
controlP5 = new ControlP5(this);
controlP5.addSlider("Pitch",0,100,50,50,50,10,100);
controlP5.addSlider("LFO",0,100,50,150,50,10,100);
controlP5.addSlider("Duty Cycle",0,100,50,250,50,10,100);
controlP5.addKnob("Volume",0,11,5,330,70,40);
}

void draw() {
background(myColorBackground);
}