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.

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.

To make control of modems easier over twenty years ago the Hayes Corporation developed a serial command protocol, the Hayes or AT command set. Many other modems adopted the protocol and now its a de-facto standard. Over the years as modem functionality expanded so did the command set. Now it supports FAX, cell phone address books, SMSes and so on. The AT command set comprises a set of text based commands terminated with CRLF. The responses are similarly text strings terminated with CRLF. Typically the modem responds with “OK”, “ERROR” or a setting value.

DIO currently provides two stream types raw and serial. Raw streams provide low level access to operating system devices. Serial streams provide access to, and abstract, serial ports. DIO stream support is accessed just like any other PHP streams. The appropriate URI is fopened. The relevant URIs are:

dio.raw://[device]

for raw streams and

dio.serial://[device]

for serials streams. In both cases [device] is the device name to open. For example this could be /dev/random for the random device on Linux; or /dev/ttyS0 for a comms port on Linux; or COM1 for a comms port on Windows. We’ll be using the later form of the URI as we’re opening a serial port.

The example code opens the serial port as follows:

$f = fopen("dio.serial:///dev/tty.ZTEUSBATPort_", "r+", false, $c);

The first argument is the device to open. In this case a serial port to the USB 3G modem connected to my MacBook. The second is the open mode, in this case read/write. The third is an optional argument that comprises a flag that indicates whether to search the include path for the file to open. We don’t want this. The final optional argument is a stream context which is a collection of stream specific additional parameters.

A stream context is created using stream_context_create(). The code in the example that creates the context, prior to opening the port, is shown below.

$c = stream_context_create(array('dio' => 
	array('data_rate' => 9600, 
		  'data_bits' => 8, 
		  'stop_bits' => 1, 
		  'parity' => 0, 
		  'flow_control' => 0,
		  'is_blocking' => 0,
		  'canonical' => 1)));

The first four context options are pretty obvious. The serial port is being configured for 9600 bits per second, 8 bits per byte with 1 additional stop bit per byte and no parity checking.

The next option disables hardware flow control. Serial ports are relatively slow so they often have hardware control lines which indicate when there is data ready to be sent and space in the buffer ready to receive data. My USB modem does not have these so the hardware flow control is disabled.

Next we turn off blocking. With blocking function calls the operating system waits for data and only returns when it is ready to return the data that was requested i.e. the operating system blocks on the data. Non-blocking function calls return whether there is data or not. The POSIX open call also blocks on the state of the Data Carrier Detect (“DCD”) hardware control line. Some modems have this control line and use it to indicate there’s a carrier signal on the telephone line. Again since the USB modem does not have this we disable it.

Finally we enable canonical mode. Canonical IO on POSIX means that the serial port driver will wait for a line of text ending in a newline (or the internal buffer being full) before returning. If less characters than were entered on the line were requested the driver buffers the data for subsequent reads until the entire line is returned. In canonical mode you can actually connect a terminal to the serial port as line editing is supported. Since Windows does not have a canonical mode DIO provides an implementation on top of the Windows driver. The alternative to canonical mode is byte mode where by DIO waits until the requested number of bytes have been read and returns regardless of whether there are more bytes available.

If all that sounds a little complicated think of it like this. If you’re reading strings terminated with a new line use canonical mode otherwise use byte mode.

Remember that blocking was disabled so that opening the serial device did not block. This isn’t desirable when actually reading data. Blocking mode can be re-enabled on an open stream using stream_set_blocking as follows:

stream_set_blocking($f, true);

Once the serial port has been opened with the appropriate port settings and blocking re-enabled the port can be written and read using the standard fprintf and fgets PHP functions.

There are two AT commands related to sending an SMS. The first is “AT+CMGF=1″ which tells the modem to operate in SMS text mode. This should respond with “OK”. The second is “AT+CMGS=” which is followed by a string comprising a telephone number. This accepts the text of an SMS which is sent when CTRL-Z is entered.

There’s a little bit of additional work in the example as the modem echos data sent to it back to the sender so the PHP code consumes data after a command is sent until it sees the sent command echoed back. The full example follows.

<?php 
 
define('PHONE_NUMBER', '5551234');
define('SMS_TEXT', 'Hello world!');
 
/**
 * Sends data to the modem
 */
function send_data($f, $string) {
	echo "< $string\n";
	fprintf($f, "$string\r\n");
}
 
/**
 * Reads lines from the serial port.  It reads until a non blank line is
 * received then returns it.
 */
function get_string($f) {
	do {
		// remove carriage returns, line feeds and excess white space
		$response = trim(str_replace(array("\r\n","\r","\n"), '', fgets($f)));
	} while ($response == '');
 
	return $response;
}
 
/**
 * Waits for OK to be sent back by the modem.
 */
function wait_for_ok($f) {
	do {
		$response = get_string($f);
		echo "> $response\n";
	} while ($response != "OK");
}
 
// MAIN CODE
 
// Create the context
$c = stream_context_create(array('dio' => 
	array('data_rate' => 9600, 
		  'data_bits' => 8, 
		  'stop_bits' => 1, 
		  'parity' => 0, 
		  'flow_control' => 0,
		  'is_blocking' => 0,
		  'canonical' => 1)));
 
// Open the port
$f = fopen("dio.serial:///dev/tty.ZTEUSBATPort_", "r+", false, $c);
 
if ($f) {
	// Re-enable blocking
	stream_set_blocking($f, true);
 
	// Set SMS text entry mode
	send_data($f, "AT+CMGF=1");
	wait_for_ok($f);
 
	// Send an SMS
	send_data($f, "AT+CMGS=\"" . PHONE_NUMBER . "\"");
	send_data($f, SMS_TEXT);
	// Send CTRL-Z to end SMS text entry
	fprintf($f, chr(26));	
	wait_for_ok($f);
 
	// Close the port
	fclose($f);
}
?>

The original DIO API is very basic and POSIX oriented. Serial support is not very configurable and doesn’t work at all on Window platforms. So I have been working on implementing PHP stream extensions that allow you to do raw and serial IO via streams. Anyway its ready for testing by people other than me on POSIX (Linux, OS X etc) and Windows platforms so I’m looking for beta testers.

Where to get it

The release candidate is downloadable as a package from:

http://www.cyberspice.org.uk/downloads/dio-0.0.4rc3.tgz

And directly from SVN at:

http://svn.php.net/repository/pecl/dio/tags/RELEASE_0_0_4RC3

Documentation

While I write proper PHP documentation below is a brief over view of how you use DIO.

Streams

DIO streams are just PHP streams. You use fopen() to open them and fread(), fwrite(), fgets(), stream_set_blocking() etc. There are two DIO streams, dio.raw and dio.serial.

dio.raw is as it sounds, raw streams. It uses the low level OS streams such as open(), read(), write(), close() etc. on POSIX and CreateFile(), OpenFile(), ReadFile(), WriteFile(), CloseFile() on Windows. It does not buffer except the internal PHP buffering.

dio.serial is full serial support. It allows setting of data rates, data size, stop bits, handshaking and raw/canonical modes etc.

Both stream types support timeouts and blocking/non-blocking use.

Example code

Below is a small example that opens a serial port, configuring it with a stream context, and then reads and writes from it before closing it.

<?php 
	// Create a stream context that configures the serial port
	// And enables canonical input.
	$c = stream_context_create(array('dio' => 
		array('data_rate' => 115200, 
		      'data_bits' => 8, 
		      'stop_bits' => 1, 
		      'parity' => 0, 
		      'is_canonical' => 1)));
 
	// Are we POSIX or Windows?  POSIX platforms do not have a
	// Standard port naming scheme so it could be /dev/ttyUSB0
	// or some long /dev/tty.serial_port_name_thingy on OSX.
	if (PATH_SEPARATOR != ";") {
		$filename = "dio.serial:///dev/ttyS0";
	} else {
		$filename = "dio.serial://COM1";
	}
 
	// Open the stream for read only and use it.
	$f = fopen($filename, "r+", false, $c);
	if ($f) {
		echo "Writing to port...\n";
		fprintf($f,"Hello world\n");
		echo "Reading from port...\n";
		$data = fgets($f);
		if ($data) {
			echo $data;
		}
		fclose($f);
	}
?>

Stream context

DIO uses the stream context to obtain the port configuration settings. There are settings which are common to all DIO streams and settings which are sub-stream specific. The common settings are:

Both the blocking setting and the timeout settings can changed after the stream is open using the PHP functions stream_set_blocking() and stream_set_timeout() respectively.

The serial stream has the following additional configuration settings.

Finally

So there you are. Any results, good or bad, are useful. DIO has error checking and will return useful warnings if you try and feed it silly values. Logs, PHP versions, etc. would be useful diagnosing issues. Thanks.

Usually I catch the train to London but as I was heading to Bristol from London on the Saturday I drove. Also normally when I drive I leave the car in outer London and catch the tube but a combination of lack of time and Barnet Council making all street parking short term meters or residents only I found it was easier to drive all the way in and leave the car in some free over night parking by the hotel. This worked well the first night because I entered the area after the end of congestion charging.

The Social

Thursday night was the social at The Brook Green Hotel on Shepherd’s Bush Road near to Olympia, which is where the conference was held. After a quick check in I changed and caught the tube to the Hotel. At the hotel I met up with my roomie for the two days, Kat, Lornajane, Derick and Sara. I also met a load of new people and put faces to the PHP Women I knew from online. I also drank rather a lot of vodka!

The social was organised by PHP London as a special one of their usual nights held at the hotel. There were two talks made during the evening. Derick made the first one on using DBUS with PHP. It was interesting . By the time of Sara’s talk I was both tired and quite drunk so I’m afraid I wasn’t paying attention. Although I did get an awesome photo of her.

A round midnight Kat and I started to wend our way back to the hotel. Once we got there Kat had a few transfers to apply to t-shirts for the “Booth Babes”. Then we set the alarm for 6.30 am and went to sleep.

The Conference

The morning started far too early with the alarm going off at 6.30 am but after waking up I was quite excited as this was my first ever conference of this kind. I’ve attended shows and expos before and even given talks in front of lots of people but never attended a ‘proper’ conference. Since I had to find parking for the car it seemed easiest to drive across town and leave it in the horendously expensive Olympia car park. Like Thursday night I was driving against the traffic and so it was a pain free trip.

Kat and I arrived at the Conference Centre around 8.30 am. We registered, grabbed tea and coffee and helped set up the PHP Women’s stand. The key note was due to start at 9.30 but due to registration issues it didn’t start until 9.45. This meant we could natter longer between ourselves.

The future’s so bright, I gotta wear shades

Aral Balkan gave the key note speech and what a speech to be introduced to conferences with. Aral is a flash developer. Quite trendy he is a sociable guy and we talked both at the social and at the after conference party. His talk was not just relevant to PHP developers or even Web 2.0 developers but all developers of any software that has an end user. And he’s absolutely right. What is the point of having the most perfectly architected piece of software which follows more computer science patterns that you can shake a stick at if you completely miss the boat, which in most cases is the market. Sometimes you do just have to code and refactor later. He talked about commodity hardware and commodity software, great new tools and technologies, and was totally inspiring. An excellent way to start the day.

What’s new in PHP 5.3

The talk on the new features of the PHP language by Scott MacVicar was, in some respects, the complete opposite of Aral’s talk. It was totally technically and just described each of the new features in PHP 5.3, just as it said on the tin. For someone still learning this was extremely useful.

Of lambda functions, closures and traits

The final talk of the morning I attended was another technical one which explained some of the upcoming facilities in PHP 5.4. It described how to define lambda functions and closured (quick throw away functions useful as callbacks and so on). And the upcoming traits mechanism that introduces a level of multiple inheritance to PHP classes whilst avoiding the diamond pattern issue and duplicating Java’s interface mechanism.

Then it was lunch.

(cont)