After installing the new SIM, I quickly headed to the network settings to try out tethering. Instead of breathing new life into the phone however, the ‘Internet Tethering’ button merely brought up a message informing me that the feature was not enabled and that I would have to contact Vodafone. Perhaps it needed a restart? No, it turns out that if you use the iPhone with one of the official carriers, then they must authorize it. Without jailbreaking the phone, which in hindsight might have been a better option, it is not possible to enable it even on an unlocked phone.

Given that I had already clarified with Vodafone that data could be used in any way, I gave them a call to request tethering be enabled. Perhaps unsurprisingly, the first assistant I spoke to said that this was not possible on a non-iPhone contract. I then had a relatively lengthy conversation with his supervisor who told me that the iPhone plans (which have tethering enabled) are set by Apple and their is no way that Vodafone can change these or offer any form discount. When I put it to her that customers who end their 18 month contracts will likely ask for a discount as the contract has been subsidising the phone, she said that a discount would be unlikely. Her manager however was able to give me a discount, not a perfect one admittedly, but an acceptable one.  For £20/month for 6 months I get 300 minutes, unlimited texts and 1GB data which can be used for tethering.

First off, I wouldn’t consider myself an audiophile but I dislike hearing music through cheap speakers. My HiFi consists of a pair of Bowers and Wilkins DM601s and I also have a pair of Sennheiser HD555 headphones. Whilst these are not the best on the market, they do sound exceptionally good. Usually I don’t listen to music on the go, but when I do the Senns aren’t suitable and as we all know the standard iPod earphones are simply terrible. For £17.99  I picked up a pair of Ultimate Ears MetroFi 220 from Play.com Ultimate Ears manufacture some of the most well respected IEMs on the market but the MetroFi are designed to capture to general consumer market who are looking for decent quality without breaking the bank.

Comfort and Fit

UE provide three sizes of eartip; small, medium and large. For me the medium were a perfect fit, however I can well believe that if none of the sizes are appropriate for you they may be quite disappointing. I wore the earphones on my train between London and Bristol which was about a 1:30 hour journey. They certainly did not block out all sound but they knocked out the sound of the train and attenuated people’s voices making the journey much more pleasant than it might otherwise have been. I was quite surprised at how noisy the carriage seemed when I took them out at the end of the journey. In terms of comfort, I found I very quickly forgot they were in and my ears did not feel sore at the end of the journey.

Sound Quality

As I have already stated, I am no audiophile so my review is purely my uneducated opinion. The frequency response of these IEMs is quite reasonable for a cheap pair of headphones, most of the treble and mids appear to be there and whilst the bass doesn’t reverberate around your head, it is reasonably respectful. In fairness, when I tried the Sennheiser CX500s I felt they were too bassy and hence unenjoyable. For listening rock, they are relatively balanced; vocals are clear, the guitars don’t sound too harsh and the bass guitar can be clearly heard but is not intrusive. Mozart’s Piano Sonatas certainly showed up the flaws in the treble, the phones sound almost murky and certainly don’t make for enjoyable listening. Film music was handled was handled better; some energy is certainly lost but there isn’t too much to complain about. Dance, Trance and Hip-hop fans will probably want a little bit more bass however for the casual listener I think they pretty good. The soundstage is certainly improved with auto panning effects incorporated into these genres.

Conclusion

Overall I would say the 220s are very good for £17.99, they certainly do not compare to Sennheiser HD555 but it would be madness to expect them too. They are a huge improvement over the standard iPod earbuds and for many people will probably represent a vastly superior sound. If the eartips fit your ears, the sound isolation is good and they are not uncomfortable. If I were to lose them I probably would replace them with a more expensive model such as the SuperFi 5s however the are over 3 times the price.

s = serial('COM3', 'BaudRate', 9600);
fopen(s);
fprintf(s, 'Hello World!');
line = fscanf(s);
fclose(s);

If we have data continually being sent by our device there are two ways of capturing it. We can create a loop within Matlab to constantly check if any data has been received however this doesn’t seem like brilliant coding practise. Alternatively we can make use of the Matlab’s BytesAvailable event and read the input buffer only when data is received.

Unfortunately, unlike languages like C++, Matlab is only able to pass variables by value and not by reference. So if we create an array in our workspace to hold the received data, our callback function will be unable to update it. However in Matlab it is possible to nest functions within the body of another. The variables defined in the outer function will be accessible to the inner function.

% Calling the function myFunc will display the number 10.
% Demonstrates that nested function has access to variables.
function myFunc

    myVar = 10;

    innerFunc()

    function innerFunc
        myVar
    end

end

The code to establish a serial connection is written into a Matlab function which also contain an array of all received data. The callback function of the BytesAvailable event is defined as a nested function and hence  can add to the data array when new data is received. This allows us to perform analysis on the data in parallel to it being read.

The full sourcecode of my function is shown below:

%
%   SerialArduino
%
%   Makes a serial connection via COM3 to the Arduino. Uses the
%   BytesAvailableFcn event to trigger a function to record data sent by
%   device. The recorded value and time are stored in the vectors values
%   and times respectively.
%
%   Inputs: Time (in seconds) to listen to device.
%   Outputs: Times and Values
%
%   Tested in Matlab 2009b
%
%   Written 12 February 2010
%   by Leo Kent
%
%   http://leo.me.uk/
%
function [times values] = SerialArduino (time)

    % Declare the vectors to hold time and value data.
    times = zeros(0,1);
    values = zeros(0,1);

    % Setup serial connection.
    ser = serial('COM3', 'BaudRate', 9600);

    % Attach the callback function.
    ser.BytesAvailableFcnMode = 'terminator';
    ser.BytesAvailableFcn = @Callback;

    % Open the connection.
    fopen(ser);

    % Record the time at which we open the connection.
    start_time = tic;

    % This is the callback function for when bytes are availble.
    % It adds the received value to the values array and gets time.
    function Callback(obj, event)

        % Get the new values.
        v = str2double(fscanf(obj));
        t = toc(start_time);

        % Update the vectors.
        values = [values; v];
        times = [times; t];

    end

    % Wait 5 seconds and close connection.
    time = 5;
    pause(time);

    % Close the serial port connection.
    fclose(ser);

    % Plot the output.
    plot(times, values);

end

Serial transfer is where we send each bit of data sequentially, one after another. The Arduino stores each byte (8 bits) it receives into its input buffer array. When we call the Serial.read() function, we grab one byte form the input buffer. So, if we send the number 100 we will read a one followed by a zero followed by another zero. To make things a little more confusing, each number will be ASCII encoded. We must convert each received byte to an integer and then join each individual integer into one value.

After a few attempts to concatenate integers,  I came across this insightful post on the Arduino forums. The following code is adapted from the code suggested by user PaulS.

value = 0;

while (Serial.available() > 0)
{
  value *= 10;
  value += (Serial.read() - '0');
  delay(1); 
}

We start by initializing an integer to zero, this will hold our read value. Within the while loop, the value is multiplied by 10 to shift the place value of the digits to the left. In line 6, we subtract the ASCII value of character zero (48) from the input byte (which we know is ASCII encoded) and hence obtain a numeric value. It should be noted that each number is placed in the units column and then shifted to the left each time another value is added.

I found that at a baud rate of 9600, the Arduino was executing the run loop faster than the serial bytes were being received. As a result if I sent the number 100, the while loop only ran once and so the value was set to 1. The one ms delay gives the Arduino time to receive the next byte.

Full source code is provided below:

/*
*  Serial Delay
*
*  Reads value from serial input and stores it as an integer.
*  Switches an LED on for the number of milliseconds defined
*  by the integer.
*
*  Note: Does not check to see if input is numeric.
*
*  By Leo Kent
*  Created 11 February 2010
*
*  http://leo.me.uk/
*/

// Declare a variable to hold the delay value.
int value;

void setup()
{
  // Begin serial communication at a baud rate of 9600.
  Serial.begin(9600);
  
  // Set pin 13 as an output.
  pinMode(13, OUTPUT);
}

void loop()
{
  // Check to see if serial data is available.
  if (Serial.available() > 0)
  {    
    // (Re)set the value to zero.
    value = 0;
    
    // Append each byte to the delay value integer.
    while(Serial.available() > 0)
    {
      value *= 10;
      value += (Serial.read() - '0');
      delay(1); // Give the AVR time to receive all bytes.
    }
    
    Serial.println(value);
    
    // Turn the LED on.
    digitalWrite(13, HIGH);
    
    // Delay by the requested number of ms.
    delay(value);
    
    // Turn the LED off.
    digitalWrite(13, LOW);
  }
}

So I have finally succumbed to temptation and bought myself an Arduino Duemilanove from eBay. Having previously played around with AVRs, the range of microprocessors which power the board, they seem extremely easy to use. I’m still playing around with the device at the moment, but expect updates soon!

Before we begin downloading and building the source code there are a few dependencies we must install. I shall be using subversion to obtain the latest version of the source. The build essential package contains the various tools need to compile from source. Although not actually required, checkinstall creates a Debain package file and adds the installation to the package database allowing for easy removal. Finally, a stock version of Python is required for the build to be successful. To install these dependencies, issue the following command (as root).

apt-get install subversion build-essential checkinstall python

svn checkout http://svn.python.org/projects/stackless/tags/python-2.52/

cd python-2.52
./configure
make

checkinstall -D make install

If all has gone well, you should now have Stackless Python installed. Please be aware that the stock version of Python installed from the repositories will have been overwritten. It is likely that if the package is updated then our Stackless build will be overwritten.