The core idea is:

• Run “Boblightd”, which monitors the screen (excuse the pun) and calculates the average colour, passing it to a program that sends the message via serial to…
• An arduino listening for colours, and changes the colour of the BlinkM/RGB LED strip accordingly

This is the result of mine on my computer monitor, looks much better in real life (skip to 30-40s for best demo). Will be even better when the RGB LED strip arrives – that’ll be going behind my 42″ TV downstairs.

Installing Boblightd on Ubuntu Karmic

Installing Boblightd wasn’t quite so straightforward as I’d hoped as it requires a whole bunch of dependencies, and on my two machines, it needed a different bunch (despite both being the most up to date Ubuntu Karmic).  For some reason, the boblightd webserver is blocking my IP address (not a static IP address) but fortunately, downloads still work – I’m using version 1.3

First, the dependencies:

sudo apt-get install libx11-dev libxpm-dev x11proto-xext-dev libxext-dev libx11-dev libxrender-dev libavcodec-dev libavformat-dev libswscale-dev libavdevice-dev libportaudio-dev mesa-common-dev

Then, run ./configure, make and sudo make install

Grab my config file and change the script location to wherever you will be putting the following script.

The Perl Script

Boblightd runs a specified program, and prints three floats to stdin, space separated, and then a new line, and repeats.  This perl script is one loop that gets the standard in, splits it on the space, converts the floats to ints, and then to hex, and then writes it to the serial port (after checking it is different from the last one, just to save arduino processing time).  Change ttyUSB1 to wherever your arduino is.

#!/usr/bin/perl -w
use Device::SerialPort qw(  ARAM :STAT 0.07 );
use Time::localtime;
my $PORT = "/dev/ttyUSB1";

my $ob = Device::SerialPort->new($PORT);
$ob->baudrate(115200);
$ob->write_settings;
open(SERIAL, "+<$PORT");
$lastOutput = "";
while (1) {
        $in = <STDIN>;
        @rgb = split(/ /, $in);
        $r = int($rgb[0] * 255);
        $g = int($rgb[1] * 255);
        $b = int($rgb[2] * 255);

        $rHex = sprintf("%02X", $r);
        $gHex = sprintf("%02X", $g);
        $bHex = sprintf("%02X", $b);

        $output = "$rHex$gHex$bHex\n";
        if ($lastOutput ne $output) {
                print SERIAL $output;
                print $output;
                $lastOutput = $output;
        }
}

If you haven’t already got Device::SerialPort, run these (as root):

perl -MCPAN -e shell

install Device::SerialPort

The Arduino Code

The Arduino code is very simple, hacked from the BlinkM Tester example.  Remember to Sketch > Add File and include the BlinkM_funcs.h file before trying to run this.  Change blinkm_addr to the address of your BlinkM (probably 0×09).

#include "Wire.h"
#include "BlinkM_funcs.h"
#define BLINKM_ARDUINO_POWERED 0
byte blinkm_addr = 0x01;
#include
char serInStr[30];

void setup()
{
  BlinkM_begin();
  delay(100);
  Serial.begin(115200);
  BlinkM_stopScript( blinkm_addr );
  BlinkM_setRGB( blinkm_addr, 0,0,0);
}

void loop()
{
  if( readSerialString() ) {
     byte r = toHex( serInStr[0],serInStr[1] );
     byte g = toHex( serInStr[2],serInStr[3] );
     byte b = toHex( serInStr[4],serInStr[5] );
     BlinkM_setRGB( blinkm_addr, r,g,b);
  }
}
#include
uint8_t toHex(char hi, char lo)
{
  uint8_t b;
  hi = toupper(hi);
  if( isxdigit(hi) ) {
    if( hi > '9' ) hi -= 7;
    hi -= 0x30;
    b = hi<<4;
    lo = toupper(lo);
    if( isxdigit(lo) ) {
      if( lo > '9' ) lo -= 7;
      lo -= 0x30;
      b = b + lo;
      return b;
    }
  }
  return 0;
}
uint8_t readSerialString()
{
  if(!Serial.available()) {
    return 0;
  }
  delay(5);
  int i = 0;
  while (Serial.available()) {
    serInStr[i] = Serial.read();
    i++;
  }
  serInStr[i] = 0;
  return i;
}

Putting it all together

Upload the arduino code.

Run boblightd -c popen.conf

Run boblight-X11

And now watch a movie, simple!

So, in between power cuts (6 days on the trot of less than 8hrs of power per day), with only a few hours of awake time before the event, I dismantled my home automation system (no loss, given there’s barely any power for the heating) and connected up the breadboard, ambient lights and a couple of wires that will act as trip wires.  As there are no pull-down resistors, and I have absolutely no components, the trip-wire is connected to ground and then digital pin 3.  Running digitalWrite(3, HIGH); enables the pull-up resistor, so whenever the circuit is complete (i.e. car hasn’t driven through the wire) it reads 0.

The way I made the trip-wire was to stick one wire over the track, and rest it in a small uninsulated loop of wire.  A quick trip to the scout hut proved this worked, although was in serious need of some debouncing as the vibrations on the track caused the wire to jump around a little.

The main loop of the code is very simple, it reads the two trip wire readings, and if one changes it increments a winning counter.  If that counter is more than 7000 (fairly random number that seems to work), it turns that lane’s ambient light green.  After that happens, when the next trip wire is broken, the appropriate light goes red.

I stole the one component I did have, a switch, from the B&Q ambient light, and wired that up in a similar way to the trip wires.  At the start of the loop, it checks this value to see if it has changed (the button is a normal switch, not a temporary push-button), and if it has changed (after some debouncing), it resets some variables, checks the trip-wires have been reconnected (and if not, flash the appropriate light), then runs the red-amber-green starting sequence.

The kids seemed to like it, and other than the odd dodgy connection, and a particularly streamlined car going under the wire, it worked perfectly!!

Next year will be a little more high-tech as I’ll change the trip-wires to some kind of optical sensor, and possibly have one at the start of the race so we can display track times, speeds etc.  May even make an automatic releaser, we shall see…

An interrupt procedure gets the home easy (HE) signal, and sends it to a callback function.  This converts the sender/recipient/state into strings, and then publishes the data to MQTT.  Problem with this is it takes time, and may be interrupted by the next HE signal.  This problem is exaggerated by the HE motion detectors, which send about 15 on/off messages one after the other.   When this happens, MQTT is interrupted and it leaves the arduino in a very strange state – loop() is paused, and nothing happens until it receives another HE signal, which kicks the arduino back into action – but by that time, any signals like “turn off the central heating” will be lost, so my energy efficient house becomes boiling hot!

So, after lots of hitting my head against a wall, my solution is to add the data to a global “string”, and then in the loop() method, to read this string, split it up into the MQ topic and the data to send to it, and then send it.  I have found the WString library crashes the arduino, so it’s all done by manipulating individual characters in the array.  Really missing the simplicity of Java!

And there are more problems…

If the arduino receives a message via MQTT at the “same” time as it receives a message via HE, the MQTT message gets lost.  Doh.  I can’t think of a guaranteed way around this problem as there’s no way of knowing when either will happen.  Fortunately the fix should be done server-side, so it’s easier to do more complex things (Java).

What I’ve settled for is to also queue up messages to send to the arduino into a ConcurrentLinkedQueue.  I also store the timestamp of the last message received via MQTT notifying me of a HE signal.  A thread then sits waiting for a message to be put on the queue.  If there is one, and the last received HE signal timestamp is more than 10 seconds ago, it sends the message.  It then waits a few seconds and checks that there hasn’t been a more receent HE signal received – if there was, it waits and resends, and loops until there aren’t any HE signals 10s either side of sending.

So, by queueing everything at each end, I think I’ve found a reasonable solution to messages getting lost.  I guess I could add some handshaking in, but that’s for another time.  Very glad I use Java for my day-job, this C stuff is horrible!!

However, with that over… I’m on a quest to automate my home with arduinos, and central heating is something that “needs” automating. Yes, I could buy a Home Easy central heating controller for £75, but I already have three plugs and in all honesty, nothing to do with them (yet). After reading an article at instructables, I decided to do something similar but hopefully a lot easier. The final result I aimed for was to have my usual central heating/hot water programmer running as usual, but have the home easy plug sitting between it and the pump/boiler so I could make it act like a thermostat. Then, by leaving the central heating on 24×7 on the programmer, I can take full control over it via arduinos and an AM transmitter. Naturally you could use any home easy remote to control the heating as well, but that’s not very exciting! As I’m prone to playing, I also want to be able to bypass the home easy device and let the programmer work as usual – just in case the code/hardware fails!

So, step one was get the stuff out of the home easy plug (HE302S, for those that care). I could have done what instructables said and ruin a screwdriver to unscrew the tamper-proof screws, or I could use brute force – the latter one. Just pry it open from the end opposite the screws and yank. Then stick a screwdriver by the two clips at the end opposite the plug and lever the circuit board out – much easier!

After probing the wires above (while the programmer was on – had to extend the wires out the bottom), I saw that the right-most pin only went live when the central heating was turned on. Hot water (second from right) went on when hot water or central heating were on. So, all I’d need to do is interrupt the right-most pin, letting it go live when I want C/H, and dead when I don’t.

Left to right, Neutral, Live, Hot Water Off (is live most of the time), Blank, Hot Water on (live when either hot water or c/h is on) and Central Heating on.

The wires in the pic above with red are the new wires that I added, a permanent neutral, a timer controlled live feed (right-most pin) and the output wire from my device.

The home easy device needs a neutral, which I took from the C/H programmer’s neutral, a live, which came from the C/H programmer’s right-most pin – that way the home easy device only gets power when the programmer is telling the heating to go on, which will be 24×7 once I’m happy. And then the output of the home easy device should go back to the wire that was in the right-most pin on the C/H programmer. But, I want an override switch, so put a two-way light switch in the middle of this. Pictures speak a thousand words, so you should be able to see what’s going on in the picture.

I didn’t have to isolate the relay as mentioned in the instructables article – this solution seemed much easier…

Net result was in less than 30mins, I can use a remote or my arduino software to turn on/off the heating – and if all goes wrong, I can take the home easy device out of the loop

I struggled last night for several hours trying to get reliable two way communications.  The idea is that every time the arduino receives a home easy command from a remote or motion detector, it sends a message to the MPC-L.  Then, with some funky programming, the server will decide what events to fire off.

Unfortunately while I can reliably receive messages, and reliably send messages, I can’t do both – it just hangs.  I’m thinking it’s the nuelectronics ethernet shield, the software certainly isn’t very nice, so as I’ve only been playing with this for a few days, I’m splashing out on an official shield.  As a by-product of this, it is supported by Nicholas O’Leary’s MQTT code.  So, moving away from last night’s PHP start, I’ll write a small java program to receive these, process them, and fire off any events if need be.

The logic for the event firing will end up being more complicated, but initially, I want a bunch of events/desired actions, and each event has a sequence of signals required, each of which have to happen within a changable amount of time.  Only if a path through the sequence is achieved in the right time will the action be fired.

For example, a motion detector in the hall, and a door open/shut detector on my front door.  An event (i.e. turn off all lights) with a sequence of 1. Motion detector fired, 2. Door opened will detect when someone has just left the house, but obviously you only want it to happen if the time between 1 and 2 isn’t too much, otherwise the person could have walked upstairs and someone else came in through the front door!

I got this working in PHP, so will Java-it-up tonight.  Then will code the more complicated (and more useful) central heating logic (i.e. I want the house at 18 degrees at 7PM, it’s now 16 degrees, and takes 45mins to warm up to 18degrees, so turn on centreal heating at 6.15PM).

So, with the help of the arduino playground and homeeasyhacking, my arduino could receive and transmit home easy messages.

The photo shows my prototype of all parts of the project (ambient light – bit of paper coiled up, will be improved soon – and home easy controller).

Wire the data line of the receiver (any of the two work on my receiver) to pin 8, and the data line of the transmitter to pin 6, and connect power/ground/aerials accordingly (I haven’t used an aerial for the receiver yet). A 23cm piece of wire works well as an aerial. All my cables are strands from CAT5 – I’m a cheap-skate!

To use the following code, first download the HomeEasy package from homeeasyhacking, add the .h and .cpp file (Sketch > Add File), then copy and paste the following code. Upload it, then start the serial monitor.

Press a button on a home easy remote and you should see the sender code – copy this, and replace “2427994″ in the code below with yours. Then restart the program, and whatever you programmed the first button on the first slider of the remote should turn off and on. Make sure, unlike me, you haven’t plugged your computer into that device – I eventually got the code working only to kill my computer’s power, oops!

To control another device, change the setHEDevice(0) line.

#include "HomeEasy.h"
HomeEasy homeEasy;
int onOff = 0;
bool bit2[26]={};
bool bit3[4]={};
int txPin = 6;

void setup(){
homeEasy = HomeEasy();
homeEasy.registerAdvancedProtocolHandler(processReceivedRemote);
homeEasy.init();
pinMode(txPin, OUTPUT);
Serial.begin(9600);
setHEDevice(0); //Set destination home easy device (first device, 0)
itob(2427994,26); //Sender code from remote control - change this to match yours
transmit(1);
delay(10);
transmit(1);
delay(1000);
transmit(0);
delay(10);
transmit(0);
}

void loop(){
//do nothing regularly
}

void processReceivedRemote(unsigned long sender, unsigned int recipient, bool on, bool group) {
Serial.print("Sender: ");
Serial.print(sender);
Serial.print("\nRecipient: ");
Serial.print(recipient);
Serial.print("\nOn: ");
Serial.print(on);
Serial.print("\nGroup: ");
Serial.print(group);
Serial.print("\n\n");
}

void transmit(int blnOn) {
int i;
// Do the latch sequence..
digitalWrite(txPin, HIGH);
delayMicroseconds(275); // bit of radio shouting before we start.
digitalWrite(txPin, LOW);
delayMicroseconds(9900); // low for 9900 for latch 1
digitalWrite(txPin, HIGH); // high again
delayMicroseconds(275); // wait a moment 275
digitalWrite(txPin, LOW); // low again for 2675 - latch 2.
delayMicroseconds(2675);
// End on a high
digitalWrite(txPin, HIGH);
// Send HE Device Address
for (i=0; i<26;i++) {
sendPair(bit2[i]);
}
// Send 26th bit - group 1/0
sendPair(false);
// Send 27th bit - on/off 1/0
sendPair(blnOn);
sendPair(bit3[0]); //MSB
sendPair(bit3[1]);
sendPair(bit3[2]);
sendPair(bit3[3]); //LSB
digitalWrite(txPin, HIGH); // high again (shut up)
delayMicroseconds(275); // wait a moment
digitalWrite(txPin, LOW); // low again for 2675 - latch 2.
}
void sendPair(boolean b) {
// Send the Manchester Encoded data 01 or 10, never 11 or 00
if(b) {
sendBit(true);
sendBit(false);
} else {
sendBit(false);
sendBit(true);
}
}
void sendBit(boolean b) {
if (b) {
digitalWrite(txPin, HIGH);
delayMicroseconds(310); //275 orinally, but tweaked.
digitalWrite(txPin, LOW);
delayMicroseconds(1340); //1225 orinally, but tweaked.
} else {
digitalWrite(txPin, HIGH);
delayMicroseconds(310); //275 orinally, but tweaked.
digitalWrite(txPin, LOW);
delayMicroseconds(310); //275 orinally, but tweaked.
}
}
void itob(unsigned long integer, int length)
{ //needs bit2[length]
// Convert long device code into binary (stores in global bit2 array.)
for (int i=0; i<length; i++){
if ((integer / power2(length-1-i))==1){
integer-=power2(length-1-i);
bit2[i]=1;
}
else bit2[i]=0;
}
}
void setHEDevice(int integer) {
int length = 4;
// Convert long device code into binary (stores in global sendDevice array.)
for (int i=0; i<length; i++){
if ((integer / power2(length-1-i))==1){
integer-=power2(length-1-i);
hedevice[i]=1;
}
else hedevice[i]=0;
}
}
unsigned long power2(int power){ //gives 2 to the (power)
unsigned long integer=1;
for (int i=0; i<power; i++){
integer*=2;
}
return integer;
}


Downloaded the examples and got it working within a few mins.  Slight gotcha was that after I told it to change colour, it changed, then did something else.  Turned out that  a sequence was still running, so I now stop the sequences in the setup() method with BlinkM_stopScript( blinkm_addr );

Initial plan is to monitor gas usage as I’m currently using currentcost to monitor electricity, so would be nice to get the full picture.

Ordered a BlinkM to start work on an ambient light that will be used to show power consumption, number of emails, traffic, weather – anything really!