The first computer in the house was my father’s. It was a TRS-80 Model 1. He had bought it to learn computing and because he realised computers were the future. I used it a lot learning to program in the BASIC language and then in Z80 assembly language (the language of the
microprocessor that ran the computer).

I was also interested in electronics (thanks to my Uncle who taught it in schools) and around the same time I saw an advertisement for the
Acorn Atom in an electronics magazine and I wanted one. I started saving but the BBC Microcomputer (“The Beeb”) came out before I could afford one. My Parents offered to help buy a Beeb by way of multiple combined Birthday and Christmas presents and the deal I would not use it until after my ‘O’ levels which I mainly complied with. I remember the excitement of going in to the store to purchase my Beeb.

I learnt to program that machine from top to bottom. I had the reference manuals and the data sheets for all the chips. I loved how you got the full circuit diagram with the Advanced User Guide (it was a print of the one hand drawn by Acorn). I learnt BBC BASIC and 6502 assembly language. I learnt how to add to the operating system and how to do clever things by directly programming the chips in the machine. It taught me a lot about programming, such as interrupts, concurrency, race conditions, dead and live locks, and so on. Programming did become my first love and superseded electronics but I wouldn’t be the programmer I am today with out it!

I didn’t just program. I did play games with my favourites being Chuckie Egg and Elite! Elite was a complete time sink. No game following sucked me in as much as Elite did until World of Warcraft!

I didn’t completely give up on electronics and would develope small projects to connect to my Beeb. In the mid 80s I was studying for a Physics degree and naturally I used my Beeb. My final year project was based around the automation of an experiment. I designed hardware to drive the equipment, sensors and hardware to read data, and wrote software to drive it all from a Beeb.

In 1989 I got an Acorn A3000. It was the successor to the Beeb and also used in schools. It had the Acorn designed ARM processor (now used in nearly everything from a mobile phone to the iPad, set top boxes and televisions), what seemed like copious amounts of memory, loads of colours and a built in disk drive. It had BBC BASIC so I was at home and also taught me to program ARM assembly language (which I still use today). So the Beeb was basically retired.

I moved on to other machines, developing for Linux, higher degrees and becoming a research assistant but I never lost my love of my Beeb though and I still own mine almost 30 years after I bought it. I also still make projects for it. The most recent being an ethernet interface so that I can connect it to the internet.

I am now an embedded software consultant and I work for a company that was formed by employees of the company that bought Acorn Computers when it finally ended in 1999. My most recent project was optimising Linux on a device with an ARM processor. And my entire career is down to me and my Parents buying that Beeb 30 years ago!

At the core is the traditional key matrix. It is a grid of rows and columns with momentary push switches that connect a row to a column when pressed. All of the rows are tied high by resistors to the 5v supply rail. The rows are inputs to an octal NAND gate (IC4), which, in this case is better thought of as an OR gate with inverting inputs. I.e. but default the output of the NAND gate is low but if one of the rows is pulled low the NAND output goes high. The rows are also inputs in to the line data selector (IC2).

The synchronous 4 bit binary counter (IC1) is driven by the BBC Micro’s 1MHz clock and when the KB EN is high is in free running mode. The 4 bit outputs (outputs QA-QD) are decoded by the BCD to decimal decoder (IC3) such that the decoder’s outputs go low in turn. The outputs of the decoder form the columns of the grid. I.e. column 0 is low on the first clock pulse, column 1 on the second and so on. If a key is pressed the row the key is on will go low when the column goes low. This in turn makes the output of the NAND gate go high indicating a key is pressed. The output of the NAND gate is used to generate an interrupt in the BBC Micro’s CPU.

So normally the keyboard is being scanned by the hardware without any software influence. This is a good thing as it takes a lot of loading off of the BBC Micro’s CPU. When the key press interrupt is triggered the key scanning software takes over. As I said normally the 4 bit binary counter (IC1) is free running however if the LOAD pin (pin 9) is taken low the 4 bit input value (inputs A-D) are latched through to the outputs (QA-QD) and hence control the columns provided by the decoder (IC3). IC1′s load pin is connected to KB EN.

The S line of the data line selector (IC2) is the select line and is also connected to KB EN. The output of IC2 is 3 state meaning it either reflects the appropriate data input line when select is low or is high impedance. The data input lines are the row lines of the keyboard matrix. The input line is chosen using the three bit ‘address’ value on A-C. The row state is output via pin W.

So the keyboard is normally hardware scanning. If the user presses a key, the interrupt is triggered. The CPU enables the keyboard by setting KB EN low and then manually scans the key board by setting the columns in turn via IC1 and checking the state of the rows in turn via IC2. Once the scan is complete KB EN is set high and the hardware scanning continues.

There are three keys on the keyboard which are exceptions. The two SHIFT and CTRL keys are on a row that does not trigger an interrupt. This means that shift is only scanned manually or when another key is pressed. The BREAK key (labled RST) is completely separate from the matrix and triggers the CPU’s reset line. On boot the CPU scans the keyboard manually to see if any of the modifiers are held down to do a cold reset or mount the disk for example.

The BBC Micro keyboard can be easily interfaced with say an ATMEL ATMega328 (like in an Arduino). The micro-controller can drive a pin directly from one of the timers generating a square wave output to scan the keyboard. The interrupt can be connected to one of interrupt inputs and the rest connected to general purpose IO pins set as outputs or inputs as appropriate. Dick Streefland’s USBtiny code provides the functionality to support the USB protocol in software utilising three IO pins on the micro-controller and a few discrete components. All that is required by me is to write the keyboard scanning code and provide the missing bits of the HID device profile.

Overview

In order to install kind of new operating system I needed to have root access on the device. This meant I had to root it. Since Android 1.6 (Release R10) on the G1 doesn’t have any useful exploits I had to downgrade the OS to Release R7 first. Once it is downgraded it you can use the rooting exploit in R7 to get root access and install a recovery image that will allow the installation of an updated radio software and the new operating system.

Preliminaries

Firstly read all of this blog post and all of the pages linked to from this blog post. There is at least one point in this process where you can “brick your phone”. I.e. you can put it in a state where by a regular user cannot make it usable.

Secondly you will be wiping your phone and replacing the software on it. Back anything up you want to keep. This includes purchased applications, data, contacts, whatever.

Make sure the phone is fully charged. You don’t want it running out of power mid-flash!

Finally I provide no warranty express or implied. You are doing this to your phone. If it goes wrong its your fault! You have been warned!

Downgrading and rooting

Downgrading, rooting the phone, and installing a recovery image is described in the link below. However since there are specific requirements for upgrading to Android 2.X I’ll explain each stage here.

http://forum.xda-developers.com/showthread.php?t=442480

Downgrading

Before you do anything take note of the radio version string in the boot-loader. Its the fourth line down. You get the boot-loader screen up by holding down the camera button when powering on the phone. With the original loader you should have multi-coloured bars with yellow text in the top left hand corner. On my phone the radio version string read “RADIO-2.22.19.26I”. Write down the string and store it somewhere safe. You’ll need it later.

Now download the appropriate older image for your phone. The links to the image downloads are on the page above however here’s the link for RC7 for those with UK phones. Download the image, unzip it, and save the DREAMIMG.nbh file in the root of your SD card. While you’re at it also download recovery-RA-dream-v1.5.2.img which is a recovery image and will be used later. Save this in the root of your SD card also.

Turn off your phone, insert the SD card, and turn it back on again holding down the camera key as before. It should now re-flash your phone. There should be a progress bar. When its all complete you can restart your phone normally (without the camera key held down). This will result in some old school Android graphics and you wondering how anyone ever coped with that software. Once the phone has booted find the phone details in settings and check the software build version number. It should appear as something like TC5-RC7 112931.

Rooting the phone

Now you have exploitable image installed it is time to root the phone. This can be done using a back door. Go to the home screen then type…

<return>
<return>
telnetd
<return>

…on the slide out keyboard. This will look like a search in contacts for the name of telnetd. In fact telnetd is the telnet daemon which allows you to connect to shell on the phone via telnet. So now you need a telnet client. Use the Android Market to download a telnet client. Once installed you should be able to telnet to localhost and get a telnet prompt.

If all is well you have shell access as root (a ‘#’ prompt). Yay!

Installing a recovery image

Now we are going to install the recovery image we downloaded earlier. This will also give us permanent root access. In the shell type…

mount -o rw,remount -t yaffs2 /dev/block/mtdblock3 /system
cd sdcard
flash_image recovery recovery-RA-dream-v1.5.2.img
cat recovery-RA-dream-v1.5.2.img > /system/recovery.img

For those who are interested the lines do the following:

1. Remounts the flash memory in read/write mode. This allows you to save to the flash in the phone.
2. Navigate to the sdcard (which is mounted at /sdcard)
3. Flashes the recovery-RA-dream-v1.5.2.img image file in to the special recovery partition in the flash.
4. Copies the recovery-RA-dream-v1.5.2.img as /system/recovery.img (The Android busybox doesn’t have the copy command but cat with a pipe works just as well!).

Once you’ve done this and have a prompt again you can reboot the phone. This time if you hold down the home and power buttons when you power on the phone it will boot in to the recovery image. You can use the short cuts or the track ball to select a menu item.

Now we are ready to install the new software.

New radio software and DangerSPL

Now we have to repartition the flash to give enough room for the new platform. This is the scary bit. As I said before…

Finally I provide no warranty express or implied. You are doing this to your phone. If it goes wrong its your fault! You have been warned!

Read this page thoroughly http://wiki.cyanogenmod.com/index.php?title=Dream:DangerSPL. If you’ve gotten this far you fulfil the prerequisites to install Danger/SPL. You now need to download the appropriate radio image, place it in the root of your SD card and flash it. Remember that number we noted down from the boot-loader screen at the start (“RADIO-2.22.19.26I” or similar). You will need it now.

Boot in to recovery by holding down the home and power buttons. Select “Flash zip from sdcard”. Select update.zip (if that’s the name of the file) from the file menu. The image should be flashed and will then reboot the phone. Reboot the phone again.

Take out the SD card and boot back in to the boot loader. It should now appear as below.

Upgrading to FROYO and installing Google Apps

All the hard work is now done. You have a rooted phone with a nice recovery menu which allows you to flash anything that will fit.

To install the latest Android read this link: http://wiki.cyanogenmod.com/index.php?title=Dream:Installing_CyanogenMod_5%2B.

Clear out your SD card and download Froyo for the G1/Dream and the Google Tiny Apps (The G1 is a bit short on flash space so wont fit the all singing all dancing versions of the Google apps). Boot in to recovery as before (home and power buttons) and again select “Flash zip from sdcard”. Flash first Froyo and then the apps.

Finally reboot your phone. You should now have Android 2.2 installed!

Issues

The only issue I had was an exception from the keyboard software the first time I used Froyo. This can be solved using the “Wipe” menu in the recovery image. I wiped data, cache and delvik cache (The latter generated an error I ignored) and then re-installed Froyo.

I have created a new site http://projects.cyberspice.org.uk/ which contains all the details of these projects. Over the next few days I will be updating it with the details of Beebthernet, my programmable earrings and so on. Each of the projects will be described in detail and links to software and schematic downloads provided.

The first documented project is my ethernet for a BBC Microcomputer project known as Beebthernet.

Flickr provides the following APIs to access notes:

• flickr.photos.notes.add
• flickr.photos.notes.edit
• flickr.photos.notes.delete

The first API takes the photo id, coordinates (appropriate for a 500 pixel wide image) and text of the note to add. The second takes the note id, new coordinates and text to update the note with. The third takes the note id of the note to delete. As you can see there’s no way, using the API, of getting the ids of notes already associated with an image. The API only allows you to edit and delete notes that you have created using the API.

However all is not completely lost. Flickr outputs very nice HTML with HTML elements having sensible class names and so on. The layout of a Flickr image page is basically as follows:

All of the elements are <div;> elements except for “notes” which is an un-ordered list. Each of the notes themselves is a list item. Below is a typical note list item. As you can see it looks some what complicated. This is because it includes the code needed to render the border of the note’s active area together with re-size corners. However we can ignore most of it.

<li class="box note note-byowner note-highlight" data-note-user_id="38990160" data-note-id="72157624923250854" style="left: 253px; top: 56px; width: 94px; height: 120px; z-index: 2; " id="yui_3_1_0_1_1285322792456209">
<span class="box-stroke box-stroke-outer" id="yui_3_1_0_1_1285322792456803"></span>
<span class="box-stroke box-stroke-inner"></span>
<span class="box-stroke box-stroke-main" id="yui_3_1_0_1_1285322792456784"></span>
<span class="note-content" id="yui_3_1_0_1_1285322792456788">
<span class="note-text" id="yui_3_1_0_1_1285322792456792">
<span class="note-wrap" id="yui_3_1_0_1_1285322792456832">WIZ810MJ ethernet module.</span>
</span>
</span>
<span class="resize resize-nw"><span></span>
</span>
<span class="resize resize-ne">
<span>
</span>
</span>
<span class="resize resize-se"><span>
</span>
</span>
<span class="resize resize-sw">
<span></span>
</span>
</li>

The only elements of interest is the list item itself and the plain text it contains. The list item includes meta data which is useful to us. The data-note-id value is the note id value to use in the Flickr API, the style provides the coordinates and size of the note’s active area, and the plain text is the actual note description. This makes it reasonably easy to extract using “screen scraping”.

The Simple HTML DOM parser is a couple of PHP objects that parses HTML and allows you to access the DOM in a way similar to JQuery. It uses the MIT licence and is freely available from SourceForge. Using this parser we can extract the notes information from the Flickr web page for the image.

The URL for an image page on flickr is:

http://www.flickr.com/photos/<user id>/<photo id>/

The following example code displays the note information for notes related to an image in my Flickr stream.

<?php
 
// Using the SimpleHTMLDOM parser.
include_once('simple_html_dom.php');
 
// Create a new parser
$html = new simple_html_dom();
 
// Parse the web page for the image we want the notes for
$html->load_file('http://www.flickr.com/photos/39013214@N03/4976074521/');
 
// Flickr keeps all the notes in a <ul> with a class id of 'notes'
$notes = $html->find('#notes', 0);
 
// Each note is a list item
$note_items = $notes->find('li');
 
// Iterate through the notes
foreach ($note_items as $item) {
	// Get the id
	$id = $item->getAttribute('data-note-id');
 
	// Get the coordinates
	foreach (explode(";", $item->getAttribute('style')) as $style_item) {
		list($key,$value) = explode(":", trim($style_item));
		switch (trim($key)) {
			case 'left'  : $left   = $value; break;
			case 'top'   : $top    = $value; break;
			case 'width' : $width  = $value; break;
			case 'height': $height = $value; break;
		}
	}
 
	// Get the text
	$text = $item->text();
 
	// Output info
	echo "Id: " . $id . "\n";
	echo "Coords:\n";
	echo "  Left  : " . $left . "\n";
	echo "  Top   : " . $top . "\n";
	echo "  Width : " . $width . "\n";
	echo "  Height: " . $height . "\n";
	echo "Text: " . $text . "\n";
	echo "\n";
}

As you can see Simple HTML DOM parser makes things simple. The page for the image is loaded and parsed. Then the first element with the id of “notes” is found (there should be only one). Then an array of the list item elements to the “notes” element is obtained and iterated over. The data-note-id item is the note id; the style is parsed to extract the coordinates and size of the active area; and the plain text, i.e. the note text, is copied.

The output from the example code is as follows:

kring:simplehtmldom melanie$ php test.php
Id: 72157624923250854
Coords:
  Left  : 253px
  Top   : 56px
  Width : 94px
  Height: 120px
Text: WIZ810MJ ethernet module.

Id: 72157624798614851
Coords:
  Left  : 254px
  Top   : 177px
  Width : 95px
  Height: 77px
Text: Adapter to allow it to be plugged in to breadboard (the WIZ810MJ has 2mm pitch connectors)

Id: 72157624923256462
Coords:
  Left  : 205px
  Top   : 204px
  Width : 49px
  Height: 67px
Text: 3.3V regulation.

Id: 72157624798617733
Coords:
  Left  : 354px
  Top   : 233px
  Width : 91px
  Height: 72px
Text: From BBC micro 8 bit "User" parallel port.

Id: 72157624923259400
Coords:
  Left  : 103px
  Top   : 299px
  Width : 242px
  Height: 64px
Text: Boarduino to provide 5V power.

Using this information you can update the note using the Flickr API or display the image complete with notes on your own page.

When DPC 2010 announced the call for papers I submitted both a proposal for a tutorial on PHP extensions and one for a talk on web services. Both were excepted. I had proposed both half day and full day versions of the tutorial the organisers chose the full day version. This turned out to be a lot of work. Basically I would be talking for 6 hours in four 90 minute slots.

The web services talk was to be trailed at the PHP NW group in May. Unfortunately being stuck in the US due to the Icelandic Volcano and its dust cloud didn’t give me much time to prepare for it. However by the time of the group meeting I had a basic talk. This meant I could devote the rest of the time up to DPC preparing the tutorial.

Since it is still early in my speaking career I don’t yet have the experience to accurately judge how long a talk will take. I had never done a tutorial before so I had no experience to base it on. In the end I came up with a plan where I had some ‘optional’ sections which I could add on the end if I ran short. It was scary to see how much content I required and took me several weeks to prepare in odd evenings. In the end it came in at over 100 slides together with four example extensions.

I flew to Amsterdam courtesy of KLM’s direct flight from Leeds Bradford Airport to Schipol. Since the hotel was right by Amsterdam Centraal train station it was a simple train ride from the airport and a short walk. After meeting other attendees and speakers in the hotel foyer I headed up to my room to finish preparation for the Friday. It turned out that I wasn’t by the station, my room was in a building over the station. It straddled two platforms and a set of tracks.

The following morning I got up early and Lornajane helped me, and others, get to the conference venue. I was extremely nervous. This wasn’t helped by finding out that many of iBuilding’s own staff would be in my Extensions tutorial. In the end the day went very quickly. As usual when I’m nervous I spoke to quickly. Luckily I could answer all questions and also had a chance to talk about some side projects. I finished early so I turned the last session in to a workshop to any who wanted to try their hand at writing an extension. I was very pleased at how well it had been received.

That evening a whole bunch of us were going to an Indonesian fusion restaurant. Unfortunately due to our guide getting a little lost and my impractical shoes I arrived tired with sore feet. The food was great but I wanted to get back to the hotel and sleep. As I was still nervous about the talk the following day I didn’t sleep well. I also had the dilemma of either being too warm or it being too noisy with the trains.

The following morning I woke very tired. I met with some friends and fellow conference people at breakfast and we all headed off for the first of the two days of conference talks. It was an awesome Friday keynote from Kevlin Henney. I had seen him speak before an PHP NW 2009 and he did not disappoint. Following talks were equally impressive. My slot was on after afternoon tea which is always hard work and by then I was tired out. It was not a great talk. Although fine for the PHP NW group meeting it was a little basic for an international conference. I will know for next time.

That evening was the Speakers dinner which was thoroughly enjoyable. I got to talk to Kevlin and others and since by then I had given all my content I could have a bit of a drink and not worry about having to make it the following morning although since the Saturday keynote was being given by Chris Shiflett who I had also seen before and thoroughly enjoyed I was too late to bed so that I could be there on time to see him.

Sunday provided another day of great speakers and talks. Thoroughly enjoyable. Then the conference wound down. Those of us who were staying the Saturday night headed off for pancakes. Marcus and I got completely lost in Amsterdam due to confusing instructions from Ivo (it was the wrong social he was talking about) and eventually turned up about an hour later than everyone else. However the pancakes were well worth it. It was followed by some more drinking and then bed.

Since Lornajane and I live in the same city we were on the same KLM flight back from Amsterdam so we became travel partners. Sunday was spent mostly hanging out in Amsterdam followed by an unstressed journey to the airport, a couple of beers waiting for our flight, and an uneventful flight home.

DPC 2010 was really good fun. I learnt a lot, both from the talks and giving the tutorial and the talk. I met many good friends and made lots of new ones. Too many to have a check list here. I’m now looking forward to my ‘home’ conference, PHP NW 2010 in October.

PHP Extensions

This tutorial covered writing PHP extensions from the very beginning right through to writing objects and classes in C. I think this went well. Its a lot for beginners to cover so naturally some people got lost towards the end but I have had some good feedback. Links to the slides and examples are below.

Web Services For Consumer Devices

This talk covered what to consider when writing a service to be used by an application on a consumer devices. I agree with the commenters who felt it was a little light. Yes it needs revision before it gets reused.

WebServicesForConsumerDevices-20100612.pdf

I will be running a tutorial Writing a PHP extension in C and speaking about Web Sevices for Consumer Devices. I look forward to seeing you there.

Framegrab adds two classes to PHP. FrameGrabDevice represents a video capture device and FrameGrabImage an image captured with a FrameGrabDevice.

You can create a new FrameGrabDevice for the default video capture device as follows:

	$device = new FrameGrabDevice();

The extension will iterate through available video devices until it finds one that supports video capture. A FrameGrabDeviceException will be thrown either if no video devices are available or if the available video devices do not support video capture.

You can supply an argument to the constructor (see below) if you want to initialise a specific video device. In this case the FrameGrabDeviceException will be thrown if that specific device does not exist or does not support video capture.

	$device = new FrameGrabDevice('/dev/video1');

Once you have a device you can then grab an image using the grab() method. The method takes no arguments and returns a FrameGrabImage object or false on error. As the FrameGrabImage constructor is a protected method you cannot create objects directly using new.

Once you have the image you can either save the image to the file in PNG format or have it returned as a string in PNG format using the writeAsPNG() and toStringAsPNG() methods respectively. The former takes a filename as the sole argument and returns false on error. The latter takes no arguments and returns either the PNG data as a string or false on error.

The two objects also support a number of properties. The code below demonstrates the extension in use. It returns an image captured from the default video device as a PNG. The image has capture device and image meta data embedded in it visible in the top left corner of the image.

<?php
 
try {
	// Get the default frame grabber device.  Throws an exception if a device
	// cannot be found.
	$device = new FrameGrabDevice();
 
	// Grab am image.
	$fgimage = $device->grab();
	if ($fgimage) {
		// Create a GD image from a frame grab image
		$gdimage = imagecreatefromstring($fgimage->toStringAsPNG());
 
		// Output data about the image on to the image
		$font  = 1;
		$black = imagecolorallocate($gdimage, 0, 0, 0);
		$fh    = imagefontheight($font);
		$x     = 10;
		$y     = 10;
		imagestring($gdimage, $font, $x, $y, "Device: ".$device->device, $black);
		$y += $fh;
		imagestring($gdimage, $font, $x, $y, "Card: ".$device->card, $black);
		$y += $fh;
		imagestring($gdimage, $font, $x, $y, "Width: ".$fgimage->width, $black);
		$y += $fh;
		imagestring($gdimage, $font, $x, $y, "Height: ".$fgimage->height, $black);
		$y += $fh;
		imagestring($gdimage, $font, $x, $y, "Format: ".$fgimage->format, $black);
		$y += $fh;
		imagestring($gdimage, $font, $x, $y, "Bytes per line: ".$fgimage->bytes_per_line, $black);
 
		// Output the image
		header('Content-Type: image/png');
		imagepng($gdimage);
		imagedestroy($gdimage);
	}
} catch (Exception $e) {
	// Handle the FrameGrabDevice exception here.
}
 
?>

The extension is available at the PECL site.