A couple of weeks ago I was in our local Boots chemist. They were clearing out all the Christmas gifts at 75% off.  I saw this Space Invaders alarm clock reduced to around £3 ($5) and had to have it, even though I had no use for another alarm clock.  (Btw, even though Boots are now sold out, the same clock is available from Play, IWOOT, Menkind and others.)

The challenge was… what to do with it?

In the end I decided to turn it into an ambient device, connected to the internet and capable of alerting me when things happen. Right now I’ve got it firing up with a new message arrives in my Gmail inbox, but really it could do anything – flag up Twitter replies, indicate the chance of rain or even, paired with one of my previous projects, act as an additional ringer for the doorbell.  I’ve added a row of LEDs (three red, three yellow) to give it some more feedback options.

Every time I get a new email the clock moves from side to side and does the classic Space Invaders sound, then lights one of the LEDs to give me an idea of how many unread messages there are.  There’s loads more that could be done with it, but I was happy just turning it into something more useful without destroying it in the process.

If you want to make one yourself, here’s what I did…

I used an Arduino to give the clock some more logic. I didn’t want to alter the external appearance of the clock and space was incredibly tight inside, so I used an Arduino Nano clone that I had lying around.

First step was to get the components working on a breadboard. I ran 6 LEDs off the Arduino’s digital pins and added an opto-isolator to another digital pin to act as a switch. I knew the Arduino wouldn’t be able to drive the clock’s motor straight off an IO pin, so my plan was to simply trigger the clock’s handy ‘demo’ button from the pin and deliver the main clock/motor power from the direct 5V pin on Arduino.

Here’s the wiring layout that I ended up with…

The original power source for the clock was 3 AA batteries producing around 4.5v. I was planning to power the clock directly over USB – I figured 5V was close enough – so the battery compartment provided the perfect space to house the additional components. Unfortunately the battery box wasn’t quite deep enough for the Nano, so my first job was to cut out the battery recess with a craft knife. I left a small lip on the bottom edge to support the additional components and to retain the original motor mounting point.

With a bit of breadboard trimming (with a hacksaw… quick and nasty!) I was able to fit it into the clock…

Next step, the Arduino sketch. The code is currently dead simple: listen to the serial input and if it’s a number, light that many LEDs; if the new number is higher than the old number (i.e. you’ve got new emails, not just cleared out old ones) then also close the ‘demo’ switch to activate the sound and movement. Here’s the finished code.

int ser = 0; // for incoming serial data
int prevCount = 0;
int timer = 100;

void setup() {
 for (int thisPin = 2; thisPin <= 13; thisPin++) {
 pinMode(thisPin, OUTPUT);
 }
 Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}

void loop() {

 if (Serial.available() > 0) {
 // read the incoming byte:
 ser = Serial.read();

if (ser >= 48 && ser <= 58) {
 int newCount = ser - 48;
 if (newCount > 0 && newCount > prevCount) {
 digitalWrite(12, HIGH);
 delay(100);
 digitalWrite(12, LOW);
 delay(1500);
 digitalWrite(12, HIGH);
 delay(500);
 digitalWrite(12, LOW);
 }
 prevCount = newCount;
 } else {
 digitalWrite(13, HIGH);
 delay(100);
 digitalWrite(13,LOW);
 }
 }

for (int thisPin = 3; thisPin <= 11; thisPin++) {
 digitalWrite(thisPin, LOW);
 }

int topPin = prevCount + 2;

for (int thisPin = 3; thisPin <= topPin; thisPin++) {
 if(thisPin <= 5) {
 digitalWrite(thisPin, HIGH);
 } else {
 digitalWrite(thisPin+3, HIGH); // Because I left a gap in the digital pins
 }
 }
}

The last step was to write a quick script to poll Gmail and get the number of unread messages.  I’ve tried lots of different languages for Arduino serial control in the past – Perl, PHP and DOS shell scripts – but every time it’s been a little bit flakey, at least under Windows. Flash Actionscript is pretty reliable using Serproxy, but that was overkill for this project. So in the end I decided to give Python a go. It was a good choice – reliable and really quick to implement.  Here’s the code…

import serial
import time
import imaplib

ser = serial.Serial('COM6', 9600)
time.sleep(2)

while True:
 obj = imaplib.IMAP4_SSL('imap.gmail.com','993')
 obj.login('GMAIL_USER_HERE','PASSWORD_HERE')
 obj.select()
 obj.search(None,'UnSeen')
 count = len(obj.search(None, 'UnSeen')[1][0].split())

if(count > 9):
 ser.write(':')
 else:
 ser.write(count)

time.sleep(120)

ser.close()

The only bit that had me scratching my head was Arduino’s trick of resetting every time the serial line is opened.  The Nano takes around 1.5 seconds to restart, meaning it would always miss the first mail notification. A wee sleep command fixed that.

And that’s about it. Three hours and around £12 of components (including the Nano clone) to turn an alarm clock into a Gmail notifier.

Future scope

There are still lots of free pins on the Nano, so plenty of scope for expansion. A light sensor could be a useful addition so it doesn’t trigger when the room lights are off, and maybe a knock sensor so it could be set to ‘snooze’ with a quick tap. Apart from that, most other mods would be software-based. I might make the three red LEDs linked to Gmail and the yellow ones linked to Twitter.

If you decide to make one of your own please let me know.  And if you make any improvements to the software, please share!

In previous years I’ve just pulled together a picture, some clip art and a Christmas-y tune in Flash to make something like this: http://www.heraldandtimeslabs.com/christmas2010/

…which is OK, but not very exciting.  So this year, I decided to try something different.

Over the space of a week I took around 3,500 still photos around our Glasgow office and Cambuslang print plant.   I then stitched these photos together using a free Mac app called Time Lapse Assembler to produce a pretty smooth 30 frames/sec timelapse video.  In turn, this was edited to match an appropriate Christmas tune in iMovie.  Here’s the result…

Two cameras were used on the shoot.  Most of the pics came from my Nikon D3100 using both an 18-55mm zoom and an 8mm fish eye for the really wide angle shots.  Interval timing was handled by a great little remote shutter release I got off eBay for about £15.  It does everything the official Nikon one does for about a tenth of the price.

My backup camera was a Ricoh CX1 which I used to capture a second angle while the D3100 was in use (like when the drivers were loading their trucks and while everyone gathered for the final “Merry Christmas” shot).

In total I reckon I spent approx four hours shooting the pics (elapsed time was more like 18 hours, but most of the time I could leave the camera and get on with other work) and then about another three hours assembling the footage and editing in iMovie.  So, for less than a day’s work — or about the same as I’d have spent creating another cheesy Santa animation — I reckon we got a much better result.

Producing this video has really given me the timelapse bug, so for Christmas I’m getting a custom-built robotic tripod head which will allow me to combine real tilts and pans with my timelapse photography.  Exciting stuff!

The awards ceremony, hosted by Catriona Shearer, was held on Thursday night at Oran Mor in Glasgow. Congratulations to all the winners and finalists listed here - especially the 999 Design team who scooped three awards and Screenmedia who took the top award for the second year running.

There’s also a wee write-up of the event here.

From Algarve 2011 – the pics Tara didn’t upload, posted by Grant Gibson on 9/18/2011 (28 items)

Generated by Facebook Photo Fetcher

From Algarve Holiday Sept 2011, posted by Tara Gibson on 9/18/2011 (41 items)

Generated by Facebook Photo Fetcher

As in previous years, we ended up with thousands of photographs.  And, as in previous years, we made hundreds of those photos available to buy via our photo sales site.  But the problem we’re always left with is one of discovery: without having the names and email addresses of those pictured, how could we let people know their photo is available to buy?

So, this year we’re trying a new experiment.  As well as putting the pics up on our photo sales site we’re also uploading them all to Facebook.  Users are able to ‘tag’ themselves and their friends in our photos with prizes available to act as an incentive.  All the pics going up on Facebook have a unique reference number which allows them to be found quickly and easily on our photo sales site.

Adding this reference number was actually the trickiest part of the whole process – standard Photoshop actions, even combined with the new Photoshop Variables feature, don’t offer the flexibility needed for this.   Instead, the solution was to script a Photoshop extension in Javascript that would extract the reference number, overlay it on the image and resize the output to a Facebook-friendly res.  What… you can script Photoshop in Javascript?  Who knew?  Not me, until last week.

Anyway, it’s early days but it seems to be working quite well so far.  The technology part was a breeze and should be reusable in future with mimimal effort.

Unfortuantely the Evening Times Facebook page was only five days old at the time of the Great Scottish Run, so we were a bit short of friends to give this a big kickstart.  Hopefully we’ll be able to use this technique again in future to aid discoverability of our photo sales service.

If you took part in the run, go here to see  if you can find yourself or your friends!

What they don’t tell you anywhere on the packaging or instructions (and by implication deny) is that the Wi-Drive works with ANY web and Wi-Fi enabled gadget.

Want to use the Wi-Drive with an Android phone or tablet, Windows or Mac laptop?

Here’s how… Simply connect to the Wi-Drive’s Wi-Fi AP then point your browser to http://kingston.  As if by magic, the main window of the iOS app appears within your browser.  You can browse folders and open files just like in the app…. or perhaps more accurately, just like the internet.

I’ve tested it on a few different devices – phone, tablet and laptop – and it works nicely on all of them.  It’ll even stream movies quite happily from the web interface.

Personally, I think this transforms the Wi-Drive from a super-niche proposition (iPhone users who are stuck for space and aren’t due an upgrade) to something far more mainstream and interesting.

Hosting a personal site from home is a great idea, and something I’d strongly recommend to anyone.  As well as learning the basics of server configuration and maintenance you also get several unique benfits, like:

• You can hook up other devices like weather stations, door bells or ambient Twitter clients
• Storage is virtually unlimited
• It’s pretty cheap to run (I reckon around £20 a year in electricity)

The one problem with hosting from home is bandwidth.  A basic DSL or Cable line is fine for handling modest everyday traffic (this site gets between 300 and 1,000 visits per day), but isn’t suited to handling large spikes.  Hopefully, Google’s Page Speed Service (PSS) will be able to smooth out those spikes and give me the best of both worlds.  So far it’s looking good.

Set up

Setting up PSS is pretty straightforward. Once you’ve signed up and have been accepted, you just need to confirm ownership of your domain (by adding a TXT DNS record) then provide Google with a ‘reference domain’ on which they’ll be able to access your site. The reference domain needs to be something new, because you’ll be redirecting www to Google’s servers.  The final step is to update your CNAME record to redirect your www to Google’s page speed domain, then it’s just a case of waiting for DNS propogation.

The process was pretty painless, taking less than half an hour even though I was being super-cautious throughout.

Results

Initial results are pretty impressive.  Independent speed tests suggest an improvement of approx 50% in page delivery times and that’s while my server is otherwise quiet.   I suspect the difference will be much more noticeable when my Cable line is busy downloading the latest multi-gigabyte OSX/PS3/Windows 7/Wii/iOS update.

Issues

I had a few teething problems with specific pages on my site.  My weather station graphs showed garbage data and the lightbox effect stopped working on my photo gallery.  I’m sure it would be possible to view source and debug where it’s all going wrong, but for simplicity I added the weather page to Google’s handy page speed blacklist which stopped them trying to process that page.

For now I’m going to put up with the missing lightbox on my photo gallery.  Those galleries are only there for pre-2010 content anyway – more recently I’ve been using Facebook and a handy WordPress plug-in to import pics back onto my site.  Plus, I’m more interested in Google taking the strain of image delivery than I care about the lightbox effect.

Final thoughts

I’m really impressed so far.  Every test I’ve run on the site suggests the pages are far better optimised and download faster.  For a completely transparent, coding-free solution that’s a great result.

My only slight concern is over Google’s as-yet-undisclosed pricing for PSS.  I like that my site is faster, but it’s not something I’d be willing to pay a lot for.  Hopefully pricing will be based on usage with a free entry level for personal sites like mine.

Generated by Facebook Photo Fetcher

What is it?!

I was in B&Q a few weeks ago and this LED panel caught my eye.  It’s not the type of thing I’d normally buy but I fancied its hacking potential as an ambient device of some sort.

Taking the back off revealed a set of nine mini circuit boards, each with a red, green and blue LED plus a simple circuit to cycle through those colours.  The wiring couldn’t have been simpler – the 5V DC power supply ran to a switch with each of the LED boards wired in parallel from that.

The plan

At this point I didn’t know what I was going to use it for but I had a plan for taking control.

The standard behaviour for the lamps was to start at red, then sequence through to green then blue at a random rate. Taking control of each red, green and blue LED individually was more work than I was prepared to put in — on top of needing to wire and control 27 LEDs individually (via PWM outputs if I wanted smooth transitions) I’d also need to add resistors to limit the power going to each bulb.  Far too much work for a couple of nights tinkering.

However, by simply controlling the 5V input to each circuit board I could have three-state control over each bulb: off, cycling colours, and constant red.  The constant red can be achieved by removing the power for as little as 1 millisecond every couple of seconds.  Every time the power trips the bulb resets to red (and the delay is imperceptible).

So, step one: I kept the ground (black) wire running between all of the lamps, but cut away the standard positive (red) wiring.  I then soldered each positive connection to a jumper wire and from there directly to an output on an Arduino Uno board.  The ground line went to ground on the Arduino.  Since the power switch was no longer required I wired that as an input switch in case it would be useful later.

At this point I still had no idea what I’d use it for, but was able to write some simple sketches to control the individual lamps.  All was well.

So what to do with a 3×3 ambient light?

I ran through various ideas including indicating weather forecasts, a count of unread emails, and any ‘ending soon’ eBay auctions.  But in each case there would be a lot of bespoke coding required and, actually, the output would be pretty cryptic: “what does one red ball, two cycling balls, a flashing ball and four off balls mean again?”

So then I had an idea… could I display a text font on a 3×3 display?  I had a hunt around for any fonts that would work on a 3×3 matrix.  To my surprise I found a few and in the end I created my own font using some of the others as inspiration.

Some Arduino sketching later and I had the whole printable ASCII range mapped out in an Arduino array. Input via the serial line was printed directly to the display – result.

OK, so now it displays text, what next?  Well, then I thought, “Is there a good existing API for handling small amounts of text?”.  Twitter seemed like the obvious answer.

The Twitter angle

The benefits of using Twitter seemed pretty clear: the API is rock solid; there are clients for just about every platform I might want to send from (web, iPhone, SMS, etc); and it would be easy to hook it into other applications – like that weather forecast idea I’d had previously.

Putting it all together

Using the PHP OAuth library by Matt Harris it was pretty straightforward to get Twitter messages via the API.  It can show anything that is available via the API, and right now I’ve settled for @ mentions for 9bulb.  So if you send a message @9bulb it’ll pop up on my panel – sweet!

The one shortcoming at this point was that the messages ran across the panel in real time, even if I wasn’t there to see them.  To fix that, I added a second ‘mode’ to the Arduino code.

In this mode the Arduino powers all lamps constantly, making it work just like it did when I bought it.  But when a message comes in it’s held on the serial buffer and the lamps change to display a red cross to indicate an incoming message.

I then coded the old power switch to control modes: off for buffering, on for playback.

That’s about it. If you fancy trying it yourself here’s the PHP code…

<?php
require_once('tmhoauth/tmhOAuth.php');
require_once('maxid.php');

$count = 10;
$newmaxid = "";
$result = get_mentions($count, $maxid);

if($result) {
	exec("echo \"" . $result . "\" > com3");
	echo("Done.  Sent: " . $result);
} else {
	echo("Nothing to process");
}

function get_mentions($c, $m) {
  $outputString = "";

  $connection = new tmhOAuth(array(
    'consumer_key' => 'XXXXX - Get your own key from dev.twitter.com',
    'consumer_secret' => 'XXXXX',
    'user_token' => 'XXXXXX',
    'user_secret' => 'XXXXXX',
  )); 

  $connection->request('GET',
    $connection->url('1/statuses/mentions'),
    array('count' => $c, 'since_id' => "$m" ));

  $incoming = $connection->response['response'];
  if($incoming) {
    $incoming = preg_replace('/"id":([0-9]*)/', '"id":"\1"', $incoming);

    $response = json_decode($incoming);
    foreach ($response as $r) {
      if($r->{'id'} > $newmaxid) {
        $newmaxid = $r->{'id'};
      }
      $t = $r->{'text'};
      $t = str_replace("|"," ",$t);
      $outputString .= "|" . $t;
    }
    if($newmaxid != "") {
      update_max_id($newmaxid);
    }
  }
  return $outputString;
}

function update_max_id($id) {
  $myFile = "maxid.php";
  $fh = fopen($myFile, 'w') or die("can't open file");
  $stringData = "<?php \$maxid = \"" . $id . "\"; ?>";
  fwrite($fh, $stringData);
  fclose($fh);
}

?>

The file maxid.php just makes sure you don’t get the same tweet twice.  It just needs something like this to start with…

<?php $maxid = “104306727796744192″; ?>

And here’s the Arduino sketch…

int k = 10;

// logically map the physical pins to left-to-right reading order
int pinMap[] = {9, 10, 11, 8, 5, 12, 7, 6, 13};

int letter_matrix[70][9] = {
0,0,0,0,0,0,0,0,0, // space
0,1,0,0,1,0,0,1,0, // !
0,0,0,0,0,0,0,0,0, // " - set to space
1,0,1,1,0,1,1,0,1, // #
0,1,1,0,1,0,1,1,0, // $
0,0,0,0,1,0,0,0,0, // % - not implemented (middle dot)
0,0,0,0,1,0,0,0,0, // & - not implemented
0,1,0,0,1,0,0,0,0, // '
0,1,0,1,0,0,0,1,0, // (
0,1,0,0,0,1,0,1,0, // )
0,1,0,1,0,1,0,1,0, // *
0,1,0,1,1,1,0,1,0, // +
0,0,0,0,1,0,1,0,0, // ,
0,0,0,1,1,1,0,0,0, // -
0,0,0,0,0,0,0,1,0, // .
0,0,1,0,1,0,1,0,0, // /
1,1,1,1,0,1,1,1,1, // 0
1,1,0,0,1,0,1,1,1, // 1
1,1,0,0,1,0,0,1,1, // 2
1,1,1,0,1,1,1,1,1, // 3
1,0,1,1,1,1,0,0,1, // 4
0,1,1,0,1,0,1,1,0, // 5
1,0,0,1,1,1,1,1,1, // 6
1,1,1,0,0,1,0,0,1, // 7
0,1,1,1,1,1,1,1,1, // 8
1,1,1,1,1,1,0,0,1, // 9
0,1,0,0,0,0,0,1,0, // :
0,1,0,0,1,0,1,0,0, // ;
0,0,1,0,1,0,0,0,1, // < 
1,1,1,0,0,0,1,1,1, // =
1,0,0,0,1,0,1,0,0, // >
1,1,1,0,1,1,0,1,0, // ?

0,1,1,1,0,1,0,1,1, // @
0,1,0,1,1,1,1,0,1, // a
1,1,0,1,1,1,1,1,1, // b
1,1,1,1,0,0,1,1,1, // c
1,1,0,1,0,1,1,1,0, // d
1,1,1,1,1,0,1,1,1, // e
1,1,1,1,1,0,1,0,0, // f
1,1,0,1,0,1,1,1,1, // g
1,0,1,1,1,1,1,0,1, // h
1,1,1,0,1,0,1,1,1, // i
0,0,1,1,0,1,1,1,1, // j
1,0,1,1,1,0,1,0,1, // k
1,0,0,1,0,0,1,1,1, // l
1,1,1,1,1,1,1,0,1, // m
1,1,1,1,0,1,1,0,1, // n
1,1,1,1,0,1,1,1,1, // o
1,1,1,1,1,1,1,0,0, // p
1,1,1,1,1,1,0,0,1, // q
1,1,1,1,1,0,1,0,1, // r
0,1,1,0,1,0,1,1,0, // s
1,1,1,0,1,0,0,1,0, // t
1,0,1,1,0,1,1,1,1, // u
1,0,1,1,0,1,0,1,0, // v
1,0,1,1,1,1,1,1,1, // w
1,0,1,0,1,0,1,0,1, // x
1,0,1,0,1,0,0,1,0, // y
1,1,0,0,1,0,0,1,1, // z
1,1,0,1,0,0,1,1,0, // [
1,0,0,0,1,0,0,0,1, // \
0,1,1,0,0,1,0,1,1, // ]
0,1,0,1,0,1,0,0,0, // ^
0,0,0,0,0,0,1,1,1, // _
1,0,0,0,1,0,0,0,0, // `
0,0,1,1,1,0,0,0,1, // {
0,1,0,0,1,0,0,1,0, // |
1,0,0,0,1,1,1,0,0, // }
1,0,1,0,1,0,0,0,0, // ~
};

void setup() {
Serial.begin(9600);
pinMode(2, INPUT);
digitalWrite(2, HIGH);

pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
}

void loop() {
int buttonValue = digitalRead(2);
if(buttonValue == 1) {
modeOne();
} else {
modeTwo();
}
}

void modeOne() {
// Colour cycles all except 'x' if there is data on the line
for(int i=0; i 0) {
digitalWrite(pinMap[0], LOW);
digitalWrite(pinMap[2], LOW);
digitalWrite(pinMap[4], LOW);
digitalWrite(pinMap[6], LOW);
digitalWrite(pinMap[8], LOW);
}
}

void modeTwo() {
int i;
// Blank the display first
for(i=0;i 0) {
int ki = Serial.read();
Serial.println(ki);
if(ki == 124) {
// Pipe separator
doFlourish();
k = 0;
} else if ((ki>=97) && (ki=32) && (ki // Other displayable ascii char, so take away 32
k = ki - 32;
} else {
// Non-displayable character, so set to space
k = 0;
}
} else {
k = 0;
}
for(i=0;i if(letter_matrix[k][i] == 0) {
digitalWrite(pinMap[i], LOW);
} else {
digitalWrite(pinMap[i], HIGH);
}
}
delay(750);
}

void doFlourish() {
digitalWrite(pinMap[0], HIGH);
digitalWrite(pinMap[3], HIGH);
digitalWrite(pinMap[6], HIGH);
delay(100);
digitalWrite(pinMap[1], HIGH);
digitalWrite(pinMap[4], HIGH);
digitalWrite(pinMap[7], HIGH);
delay(100);
digitalWrite(pinMap[2], HIGH);
digitalWrite(pinMap[5], HIGH);
digitalWrite(pinMap[8], HIGH);
delay(100);
digitalWrite(pinMap[0], LOW);
digitalWrite(pinMap[3], LOW);
digitalWrite(pinMap[6], LOW);
delay(100);
digitalWrite(pinMap[1], LOW);
digitalWrite(pinMap[4], LOW);
digitalWrite(pinMap[7], LOW);
delay(100);
digitalWrite(pinMap[2], LOW);
digitalWrite(pinMap[5], LOW);
digitalWrite(pinMap[8], LOW);
}

Thoughts for the future

Right now it’s a read-only Twitter client.  A nice future enhancement would be to allow for the creation of messages directly on 9bulb.  I don’t want to modify the case of the unit, but the power input socket is now free.  It’s a 3.5mm headphone-style socket, so my current thinking is to have an external Morse code key which could be plugged into that 3.5mm socket.  Messages could be tapped out in Morse and potentially previewed on the lamp display before sending.

If anyone wants to have a go at writing the sketch (and/or the PHP) for that I’d love to see it. There are several Arduino Morse input projects on the go, but I haven’t yet thought about how to handle both incoming messages and incoming dot-dash sequences in a single code loop. Thoughts on a postcard please.