- Michael Peacock's Blog

-

{pub_date} GMT

Over at Ground Six the development team each run a number of virtual machines hosting their development environment. We also have an internal ESXi server which hosts a number of projects and staging areas.

For our local machines, tools such as LocalTunnel and PageKite are great. These are free services which tunnel out and expose a particular port (for us this is always the web server) on a subdomain they provide. This is essential for testing services with webhooks such as PayPal or GoCardless.

Both of these services are very good and customisable. The v2 of LocalTunnel and PageKite offer some facility to run your own service or front-end without needing to rely on their own servers. Unfortunately, LocalTunnel v2 is very much unstable software, and PageKites documentation is a little overwhelming (although I'm told their rpm and deb files help with that). With this in mind I set about putting something (very basic) together myself, primarily for the servers we have running on our ESXi box; PageKite is more than suitable for our local machines for now.

-

{pub_date} GMT

As developers, it's sometimes tempting to reinvent the wheel.

You need some code, a tool, an API, a CMS or framework that works in a specific way. You find tools out there that do most of what you want, but not quite everything. And so, we give in to temptation. Before you know it, you have spent more time reinventing things that you need just so that you can start developing your product - but you haven't yet started on the product!

Sometimes there is a genuine case for reinventing the wheel. If you rely too heavily on external frameworks, or APIs, you can find that your product can only be extended in ways that the external code allows. You might not want to be tied to the development cycle of someone else (Facebook's ever shifting sands anyone?). These particular risks come down to your business needs, and in many cases, are an acceptable risk, especially over building things entirely from scratch.

Even if you find the risk of existing frameworks or platforms too great, or you just want to retain architectural control of your product, there is an alternative: Components.

-

{pub_date} GMT

Over at Ground Six last week we put Own My IP online. This was our first project as a development team. Alongside this we have worked on some other projects, including ShareScribe, our first team Hack-Day and the redevelopment of a high-traffic news service - more on those another day.

-

{pub_date} GMT

I'm currently working on a project which has been split into a number of distinct parts, and as a result we have a number of seperate Git repositories of code for the project. We decided to use submodules to manage these dependencies, and set it up so that the four repositories were nested, one inside the other, inside the other, inside the other.

When working with nested submodules, its a little bit of a pain to get all of the submodules checked out, and updated (assuming you want your projects to update as each dependant submodule changes). Lewis and I put our heads together and came up with this solution.

When you have cloned a project with submodules, first run this. It will intiailise and subsequently clone each of the submodules.

git submodule update --recursive --merge --init

When you are ready to update the code to take into account changes to submodule code, first, do a pull on your main repository.

git pull

Then tell git to look recursively through each submodules, ensure we are tied to a branch and not running headless (which will prevent a pull), then pull the changes.

git submodule foreach --recursive 'git checkout master && git pull'

Now you can make use of nested submodules in your project and have changes down the line pulled all the way up to your main project.

-

{pub_date} GMT

Full Disclosure: I'm a full time member of the Ground Six team (more on that in a future post), so this review is slightly biased, however its a great milestone for us so I felt the need to share it.

Today marks the official launch of SalesJump, an iPhone app developed by Ground Six, a web and mobile app company based in Newcastle.

-

{pub_date} GMT

The automotive industry makes extensive use of a standard called CAN bus, a Controller Area Network which allows the various components of a vehicle to talk to each other without the need for a host. Typically, messages sent on the CAN bus are short 16 character hexadecimal words, with an identifier associated with them. To get from these 16 character words to meaningful information you need two things: a CAN specification provided by the relevant component manufacturer, and a way to process the information and decode it as per the specification.

Recently, I've been doing some work which has involved verifying the information that has been extracted from the CAN bus is correct, and that we are interpreting the CAN specification correctly. This has proved difficult, as while I can see where the specification hasn't been correctly translated into the application which processes it, it isn't easy to see (when it has been translated correctly) where the incorrect values are coming from. To make things easier, and to try and further my knowledge of the CAN bus, I have written a PHP based CAN processing tool. This allows me to perform the translations and calculations myself and see why certain pieces of information have been translated incorrectly.

As a seperate project I'm working with a group of engineers to develop a small autonomous robot, which will use a CAN bus to keep itself aware of its location and what its various components are doing. With this PHP tool, I will be able to quickly process what it is doing and display this in a web browser without the need for some middleware application.

The CAN processing tool is relatively simple. You provide an XML based specification detailing which type of CAN bus messages can be translated into which useful pieces of information, detailing which bytes and bits of the hexadecimal word contain the information, as well as which scaling, multiplication and data type conversion (e.g. convert two a short by applying a two's compliment) factors need to be applied to get the correct output.

Get the code

The code is available on GitHub: https://github.com/mkpeacock/PHP-CAN-Processor

How to use it

There are two ways to use the application, you can either provide an XML specification to the application, pass a message and let it do the work, or you can manually tell the application which messages need to be translated in which ways.

Providing a specification

The easiest way to use this system is to provide an XML based "specification" of the different CAN message types you wish to decode, and the pieces of information from within.

<?xml version="1.0" encoding="UTF-8"?>
<canspec>
    <canID id="ABC" type="multiplex" multiplexByte="0" namePrefix="" nameSuffix="_Piston%1$d">
        <engineeringUnit type="multi-byte">
            <name>Piston_position</name>
            <unit>mm</unit>
            <mostSignificantByte>2</mostSignificantByte>
            <leastSignificantByte>3</leastSignificantByte>
            <dataType>null</dataType>
            <multiplier>0.01</multiplier>
            <offset>0</offset>
        </engineeringUnit>
    </canID>
</canspec>

You can then use a factory to build the keys, the decoders and turn that into a collection of decoders.

$factory = new CentralApps\CAN\Decoder_Factory();
$spec = $factory->makeDecoderFromXMLFile('sample_can_specification.xml');

Passing a message to the collection of decoders will find the decoder for that can message type, and perform the decoding logic from within.

$message = new CentralApps\CAN\Message( 'ABC', '0000000000000000' );
$units = $spec->decode( $message );
foreach( $units as $unit )
{
    echo $unit;
}

Manual

$message = new CentralApps\CAN\Message( 'ABC', '0000000000000000' );


$multiByteKey = new CentralApps\CAN\Decoder_Keys_MultiByte();
$multiByteKey->setCanID( 'ABC' );
$multiByteKey->setName( 'Piston_position' );
$multiByteKey->setUnit( "mm" );
$multiByteKey->setMultiplier( 0.01 );
$multiByteKey->setOffset( 0 );
$multiByteKey->setMostSignificantByte( 2 );
$multiByteKey->setLeastSignificantByte( 3 );
$multiByteKey->setDataLength( 16 );
$multiByteKey->setDataType( 'short' );

$decoder = new CentralApps\CAN\Decoder_Multiplex();
$decoder->setMultiplexByte(0);
$decoder->setNameSuffix('_Pison%1$d');
$decoder->add( $multiByteKey );
$units = $decoder->decode( $message );
foreach( $units as $unit )
{
    echo $unit;
}

Other notes

This tool makes use of the PSR-0 autoloading "standard", so if you use an autoloader compatible with this you should just be able to drop the code in. If you find you need to support another data type conversion, simply create a new class in the /src/CentralApps/CAN/Decoder/DataTypes folder which implements the Decoder_DataTypes_Interface. If you need to decode information differently, create a new class in /src/CentralApps/CAN/Decoder/Keys which extends the Decoder_Core class. You will need to update the Decider_Factory to correctly build decoder keys of that type.

-

{pub_date} GMT

Today, myself and Sam Lambert were at the 4th Annual AMQP Conference and Launch of the version 1.0 of the protocol. We were there representing Smith Electric Vehicles, who use StormMQ a cloud based message queue (more on that in a forthcoming post about my work at Smith). AMQP is the "Advanced Message Queueing Protocol" a protocol which is currently in the process of establishing itself as a formal standard through the OASIS group.

-

{pub_date} GMT

This is just a quick note to say I'll be speaking at PHPNW 2011 in their Unconference track, delivering two 15 minute talks:

PHP and Continuous Data Processing
PHP and Twilio

If you are at the conference, I hope to see you swing by for my talks.

PHP and Continuous Data Processing

At Smith Electric Vehicles, the worlds largest manufacturer of commercial electric vehicles, we run the largest telemetry system outside of Formula 1. This telemetry system involves our vehicles transmitting thousands of pieces of information back to us every second. We need to be able to process this information, keep on top of it, generate reports and calculations and display real-time, historical and analytical data through our web interface for customers, engineers and service technicians. This talk discusses some of the challenges we face and some of the solutions we have both in terms of the system itself and also making PHP play nicely with large volumes of continuously processing information.

PHP and Twilio

Twilio is a set of Infrastructure APIs which allow developers to integrate voice and SMS services into their applications. This includes receiving inbound calls, making outbound calls, transferring calls, processing responses and so on. This talk walks quickly through Twilio and shows how to quickly build a telephone interface for customers to manage their accounts on PHP based systems.

-

{pub_date} GMT

I was recently creating a system with a multi-step form. The form itself wasn't particularly complicated, it just had a number of steps which the user needed to complete. It didn't make sense for each stage of the form to be a seperate form which is posted to a server, and then fully processed at the end. Instead, it seemed more appropriate to hide each section of the form, except for the current section being completed, using jQuery.

-

{pub_date} GMT

One of my final few projects working with the team at Peacock Carter has come to a close, following a launch in mid-April, and I wanted to write up a post about the project and my involvement: the website redesign and redevelopment for Equality South West.