I knocked up a small PHP script that grabs the backend status, finds what is being recorded or watched, compares with the previous run, and sends a message to twitter using wget.

To use it, grab the script, change the username/password variables, chmod +x it, and then add it to your “Startup Applications” or equivalent if you’re not using Ubuntu.

I’ve made a little markup system so that the whole postit can be a link, and the time and location can be overridden (child protection malarky – can’t just put a time and location for some things!)

It’s all written in PHP, using the GD graphics features to put the text on a background image. If you’re interested in the code, comment, and I’ll give it to you (if you link to me!)

First, go to about:config (just type it in the address bar and hit enter)

Then filter for “origin”.

Change “security.fileuri.strict_origin_policy” to false.

You should now be able to use local javascript files.

By applying a “Newsletters” label on GMail to all automated messages by filtering messages, I can now see how many unread emails I have, then subtract the number of unread newsletters I have, and flash the ambient light that number of times.

Grab getGoogleMail.sh, change the usernames and passwords, and change “Newsletters” to whatever your google label is. Then use the $count variable to do whatever you want.

What I really want is a text message telling me which junctions on the M27 and M3 are delayed and roughly what their speed are. While I don’t actually use the motorways to get to work, if they’re gridlocked, the surrounding country-roads tend to also be gridlocked, so this should work. My house already texts me thanks to twitter, so that part of the system is easy, and has the bonus of other people can use it.

After discovering a site that gives average speeds between junctions, cogs started to whir. Unfortunately the site doesn’t provide a nice feed, but that wasn’t going to stop me.

A few hours of Java hacking later, @hants_motorway was born.

Every 20 minutes, between 7am-10am and 4pm-7pm, the speeds of each junction between J2-J12 on M27 and J4-J14 on M3 are recorded in a database, and compared against the speed of that junction at that time in the previous month. If it is less than 45%, it assumes there’s a delay and puts a message on Twitter. When the list of junctions delayed change, or the delays end, another message is put on Twitter.

I’ve setup my personal account (@ejellard) to follow @hants_motorway and to text me each update.

I’m hoping that this means that those driving from the Southampton area to some location near Winchester won’t have to sit in stupid amounts of traffic. I obviously can’t guarantee it’s accuracy, and no doubt my house will have a power-cut or network outage the one day it would be useful, but it shouldn’t give false-positives (or negatives, depending which way you look at it). Let me know what you think, and if there are any better ways of doing this.

And purely because I can, here’s an “interesting” graph of road speeds of different junctions along the M3:

And the M27:

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!

Now to actually create an album.  Yes, pretty easy. Upload a file, not so easy, but doable.  Get that file to be shown – next to impossible.  This is the worlds most convoluted software I have ever seen!  To get a photo to be shown, you first have to syncronise, then go and create thumbnails – but wait, by default the synchronise does a dummy run, so go back and tick a tick-box.  Grr, really not usable.  So, I tried looking at the documentation (which goes against my beliefs of websites should never, ever, need any help – they should be usable) and even that is appauling!  It’s a wiki with a very poor navigation structure (if there is any structure), so impossible to find anything useful.  Turn to the forums to find others having the same problem, and being told to read the instructions…

Right, rant over, software uninstalled.

Plogger was the next on the list, the demo looked clean and simple – just what I needed (PHP/MySQL based).  Installed it in a couple of minutes, saw a test album had been created for me so uploaded a photo and job done – it was there!  Then spent the next hour cropping and adjusting the photos, uploaded them, and bob’s your uncle, I have a nice and simple photo gallery for the scouts!  The styling is very minimal, it’s designed to be part of a larger site, although there is one style that’s a little less minimal which I’ve gone for as there’s no “larger site” for this.

So steer clear of piwigo, and let me know if you have any recommendations…

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…

The cap off an addidas deoderant can makes a nice enough base for the orb from a B&Q disco lamp (no link as can’t find it online).  I soldered the ends of some CAT5 to the BlinkM, and left the other ends loose to be shoved into the arduino.

As I’ve got an arduino and ethernet shield, I went for the second largest ABS box and even then, I had to break off the screw connectors on one side so that the plugs could stick through the outside.  I soldered the AM receiver and transmitter onto a small piece of stripboard (also from bitsbox), added a couple of wires for aerials (with a knot in each to prevent someone pulling it out the circuit).  So that’s pretty much the finished product, what a shame!  I will add a thermometer to it so it can become a thermostat in another room – eventually this’ll go in the sitting room, so will have the current cost meter producing one temperature reading from the kitchen, this one in the sitting room, and have just ordered another arduino for my bedroom’s ambient light/thermometer/development board.

The java code has been working nicely, turning the heating on and off via the hacked home-easy plug!  I sent a text from my phone to turn the heating on, very proud of actually finding a use for it as I was stuck in traffic but had friends coming round so the heating would have cut out at 5.30 (it heats up til 5.30, then waits for movement) – only to find there was a street power cut that has lasted 3 days (intermittently)!  So, if the power holds up a little longer, I should get a tweet tomorrow telling me how long the central heating was on for, fingers crossed!

So, time to write the web interface, pretty dull

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!!