OSStatus result = AudioSessionInitialize(NULL, NULL, NULL, self); if (result) { // Init error, handle error here }else { UInt32 category = kAudioSessionCategory_AmbientSound; result = AudioSessionSetProperty(kAudioSessionProperty_AudioCategory, sizeof(category), &category); if (result) { // set audio session error, handle error here }else { result = AudioSessionSetActive(true); if (result) { // Set audio session active error, handle error here } } }

Code, documentation, bugs, bugfixes, etc all welcome!

After conquering the indestructible box and charging the N900 I decided to have a quick play. I watched the getting started video which I found to be both beautifully smooth, showing off the high definition of the N900 screen immediately, and somewhat slow content-wise.

The N900 is similar in width and height to the iPhone but is much greater in depth at 1.8cm – just a millimetre deeper than the G1. This is not surprising due to it’s hard keyboard and more advanced hardware.

The first thing that struck me about the N900 (other than how high definition the hands were in the famous Nokia splash video!) was how much force it required to press on the screen. The iPhone (my current primary phone because I develop iPhone fitness apps) only requires the lightest of touches; whilst the Android G1 (my wife’s phone) requires a bit more. I later discovered the reason for this heavier interface was probably the stylus (which I discovered accidentally while interrogating the outside of the device), which is great to use – reminds me of my old iPaqs only much much higher resolution and more responsive!

I noticed that every time I touched the screen firmly enough the phone would do a very small vibration in the way of haptic feedback. This would be good if it weren’t for the fact that it does it every time, and not only the times when your touch actually triggers an action (opening a menu, etc) – this is becoming more annoying than useful.

Because of the devices HD screen I found it quite hard to be exact with my touches (my thumbs must be almost 200 pixels wide on that screen!) though the interface deals with this well by using large touch areas. After failing at playing Marbles (a pre-installed game with small touch areas) for a minute or so I quickly learned where the device thought my presses were and the device became even easier to use. (Sure this would have been much easier with a stylus but I hadn’t discovered that yet!)

The web browser is a pleasure to use, though it appears to support in page Flash which I personally hate – especially on a small screen mobile device. I went to YouTube to see how it handles and “very well” was the answer. The device supports the double tap to zoom in to a region of text paradigm of Safari on the iPhone though it obviously lacks the multi-touch pinch and zoom.

Pressing play on a YouTube video, I wished to turn the volume up and so I pressed the volume rocker on the outside of the phone. This surprisingly zoomed the web page (very smoothly!) but not the volume – a useful feature but definitely not what I had expected. I attempted to change the volume using the YouTube Flash control but could not drag the slider up as my fingers were too fat and dragging scrolled the page. (I hadn’t discovered the stylus at this time but have since attempted with they stylus with the same result.) To change the volume I had to click the web page, click the “toggle fullscreen” button at the bottom right, the status icons at the top and then drag the volume slider. Not too hard, but certainly more effort than just using the volume rocker – the video would play on a good few seconds more before you can change the volume and get back to it. Perhaps there’s a better way of doing it, but this is a “first impressions” post so I feel I should stick to first impressions!

One very cool feature of the N900 is how blazingly fast the screen lock/unlock is. There’s a sprung switch on the right side of the phone which when you flick it will lock or unlock the screen seemingly instantly (no slider here!). If you prefer the iPhone style slider then you can press the power button at the top of the phone and use the slider there, though I much prefer the flick button on the side.

I like the stand on the back of the phone – this would be immensely useful when you’re trying to watch a film on the train on the way back from London (rather than constructing a stand with your backpack, wallet and other accessories like I do for my iPhone…). The stand is fairly sturdy and definitely supports the phone well, though it does rock a bit when you use the stylus at the top right of the screen (not really the stands intention to be fair!).

I know virtually nothing about photography, but to me the camera seems to be a decent quality 5MP phone camera with a fairly decent flash. Coming from a 3MP iPhone with no flash the difference is astounding. The N900’s sheer performance is very visible here – as you move the phone around you can clearly see the surroundings – there is no massive blurring like when you wobble the iPhone’s camera. The photos themselves come out quite well, though there is still minor blurring due to handshake – but no where near the magnitude of the blurring on the iPhone. I bet a “bar code scanner” application on the N900 would be far faster and more accurate than any I have used on the iPhone or Android!

Connecting the device to my WiFi network was painless and intuitive. The major widgets (menu button [top left], fullscreen button [bottom right], close button [top right], status tray [top, right of menu button]) are well laid out and application switching (and closing [Symbian: I'm talking to you]!) is simple and intuitive.

Opening applications could do with some work – the menu first opens and shows you 15 icons (standard icons like Contacts, Phone, Web, Email, Conversations), with a More button at the bottom right. Pressing More is how you get to your other apps – games, utilities, etc. Unfortunately these apps appear ordered by the time they were installed and not separated into folders, and there is no obviously intuitive way to organise them. In fact I have yet to find out how to organise them through exploring the device – I will search the internet later.

That’s the end of my first impressions… When I discovered the X Terminal application I got immediately a lot more excited as I am by nature a hacker. Read on…

This post is part 2 of a three part series. You may also be interested in:
Part 1: N900: the tale of the indestructible box
Part 3: N900: a phone for hackers? (coming soon…)

A week ago I was contacted by Lydia of WOMWorld.com/nokia who asked me if I would be interested in receiving an indestructible box. I was told that she found me via my twitter profile and felt it would appeal to my passions. After confirming the email was not spam I replied, intrigued, “yes please” and sent her my address.

Yesterday it arrived. I opened the door to a delivery man who offered me a large cardboard box. Jof had suggested to me that it would likely be an N900 (which I had heard a little about but had not had time to look into) so I was expecting a small package. Surprised I was when the box the man handed me was so large and heavy – 35×35x35cm and 7.5kg!

I took it indoors and opened it, to find a large package, cold to the touch, wrapped up in brown parcel paper and surrounded by polystyrene balls. Unwrapping this (and making a hell of a mess with the styrofoam balls which attempted to mirror the snow outside onto my living room floor) unveiled a 25×25x25cm black shiny box with a Nokia logo on top, a hinge and a small USB mini-B socket barely visible on one side. It was obvious that the top would open… but how?

I wanted to attempt to hack it right away, but two things stopped me: firstly, I should be working; and secondly the box was wet with condensation from the sudden contrast with the cold outside. I went back to work.

A hour and a half later I got temporarily stumped with a programming problem and decided to attempt to hack the box.

My first step was to see what happened when I plugged it in to the USB. I booted into Ubuntu 9.10, ran dmesg -c to clear all the kernel messages, plugged it in, waited a few seconds, and ran dmesg again to see just the new logs:

[  314.544034] usb 6-2: new full speed USB device using uhci_hcd and address 2
[  314.747104] usb 6-2: configuration #1 chosen from 1 choice
[  314.811722] usbcore: registered new interface driver usbserial
[  314.811734] USB Serial support registered for generic
[  314.811764] usbcore: registered new interface driver usbserial_generic
[  314.811766] usbserial: USB Serial Driver core
[  314.823161] USB Serial support registered for FTDI USB Serial Device
[  314.823263] ftdi_sio 6-2:1.0: FTDI USB Serial Device converter detected
[  314.823283] usb 6-2: Detected FT232RL
[  314.823285] usb 6-2: Number of endpoints 2
[  314.823287] usb 6-2: Endpoint 1 MaxPacketSize 64
[  314.823289] usb 6-2: Endpoint 2 MaxPacketSize 64
[  314.823291] usb 6-2: Setting MaxPacketSize 64
[  314.825064] usb 6-2: FTDI USB Serial Device converter now attached to ttyUSB0
[  314.825077] usbcore: registered new interface driver ftdi_sio
[  314.825079] ftdi_sio: v1.5.0:USB FTDI Serial Converters Driver

I spotted the /dev/ttyUSB0 and instantly thought “minicom.” It took me a while to refamiliarise myself with the program and get it to connect, but soon I had fiddled with the speed settings (reduced it to just 9600baud from 115200) and was greeted the following output on my screen:

  _   _  ___  _  _____    _
 | \ | |/ _ \| |/ /_ _|  / \
 |  \| | | | | ' / | |  / _ \
 | |\  | |_| | . \ | | / ___ \
 |_| \_|\___/|_|\_\___/_/   \_\
 *******************************
    W3lc0m3 t0 n0k14 h4x0rb0x!
 *******************************                                               

 ? - displays help dialog                                                      

$-nokia h4x0rb0x->

Unfortunately I could not type into minicom. I experimented with the speed and parity settings some more (as they had helped before) but no use. Finally I disabled hardware flow control and voilà I could type. Then it was simply a case of typing “?” to find out what commands were available:

$-nokia h4x0rb0x-> ?
Available commands:                                                            

 ? - prints this help dialog                                                    

 connecting <argument> - opens box                                              

$-nokia h4x0rb0x->

And guessing what the argument to the nokia connecting command was…

$-nokia h4x0rb0x-> connecting people                                            

Initiation complete.                                                            

Start Connecting.                                                               

$-nokia h4x0rb0x->

Hardly a challenge! A nice clichéd progress bar appeared for a few seconds and then *click* the lid popped open a little. I opened it fully and was pleased to see that they had even included dry ice to maximise theatrics, with the N900 packed safely waiting to be admired.

They really put a lot of thought into this! I delved deeper and here are all of my winnings:

That’s: an N900 with accessories plus a butane soldering iron, sports band, cake, and a little fox figurine.

The box itself was powered by a Roboduino Nano (which I intend to repurpose later… not sure what as yet) hooked up to a solenoid:

UPDATE: Techcrunch have a video of the opening – check it out!

Continue reading:
Part 2: N900: first impressions
Part 3: N900: a phone for hackers? (coming soon…)

GymFu (that’s Jof Arnold, Jem Gillam and myself) has received just shy of £100,000 funding from 4iP (an angel/investment arm of Channel 4) to work on a new project improving the health of the nation in bitesize chunks. This is obviously very exciting for us all, but I’m afraid we can’t tell you any more until details are firmed up, though I can tell you that you should see output from this project by the middle of next year. Wish us luck!

Why not read 4iP’s press release and TechCrunch’s take on the funding?

Thanks to Matthew Zimmerman for sending me his modified version of MythPyWii, it now has power-saving – after 35 minutes of inactivity the Wiimote turns off. You can download the latest version, as always, here; or you can get this specific version (v17) here.

I love open source!

1. You can’t turn 2 arbitrary LEDs on at the same time unless they are on the same row/column. (Doing so would actually draw a square of LEDs.)
2. My Arduino doesn’t have enough digital input/output pins

Point 1 is easily solved – we simply update just one row at a time, letting Persistance Of Vision (POV) do the hard work for us. Point 2 is the subject of this post – multiplexing, combining multiple individual signals into just one signal. I will not be using this dot matrix display in this post, instead I will simply be powering normal LEDs. I wanted to find out if the Arduino is fast enough to multiplex the data through just a few pins in order to power this display. The answer (one of my favourite answers!) is: “Yes, but not without some hacking.” Read on…

The Hardware

In order to get a balance between the number of pins we use for this and the speed of the output I’ve decided to use 3 data pins, each controlling 8 bits, for a total of 24 bits (the same as the number of pins on the LED component – no coincidence!) The way that I have implemented it, we also need 2 pins for clocks (one fast, one slow) – read on. The clock pins will be common to all 3 data pins, so for the rest of this post I will only detail one data pin (8 bits).

(Sorry about the messiness. Click for a larger picture. There is a Roboduino (Arduino compatible) board on the left, the LEDs and resistors should be fairly obvious from the photo, then there are 3 chips. From left to right they are the Darlington array, the SIPO shift register and the flip flop array (see below for all of these)).

Fast clock – Shift Register

We want to send the data through one pin (data line 1, DL1) to an external Serial-In Parallel-Out (SIPO) chip, also known as a shift-register (I’m using a M74HC164B1 octal shift register). This does exactly what it says – it takes a serial (single) input and converts it to parallel (multiple) outputs. However the chip just receives some high signals and some low signals – how should it know how many digital 1s there are in a second’s worth of high signal? This is where the fast clock (FC) comes in. FC just goes from low to high and back again for every bit of data we send through the data lines, and when it changes from low to high the SIPO chip “reads” the value of DL1 and outputs it on it’s first output pin (Pin1). The next time the SIPO chip reads from DL1, it “shifts” the value from Pin1 to the second pin (Pin2), and again stores the value of DL1 (on or off) into Pin1. This continues indefinitely, shifting the data along a pin at a time, filling up all 8 of the SIPO chip’s output pins (and forever overwriting previous data). Here’s a diagram from the datasheet:

Time goes from right to left (the left shows an earlier time than the right). The data is the second signal (the third can just remain high always) and the 4th signal is the clock pulse. Signals 5-12 show the state of the output pins at each point in time.

Slow Clock – Flip Flop

We don’t want to display this shifting data though, so we use a “flip-flop” (FF) to store the values. A flip flop can be thought of as a Serial-In Serial-Out (SISO) chip in that it takes it’s input and uses that as the output. What’s so special about it then, I hear you ask, isn’t it just a bit of wire? The “special” thing about flip flops is that they “store” this value – recording it when it receives a clock pulse, like the SIPO chip above. We’re going to use the slow clock (SC) for this purpose, because we only want to store the values once all 8 bits have been output from the SIPO chip. (The SC is triggered once every 8 FC pulses.) Doing so we wait for the SIPO chip to correctly represent the 8 bits it has been sent, and then we store these values whilst the next 8 bits are loaded. I’m using a SN74HC273N octal flip flop chip which has 8 individual flip flops in it.

Boosting – Darlington array

Unfortunately the flip flop chip does not supply much current – not enough to power an LED – so we need to use transistors to boost the current. I’ve used a Darlington array to boost the current in my circuit as I had one left over from a previous project (it is a ULN2803A).

Display

I’ve displayed the output of just one of the data pins using 8 standard LEDs, each with a resistor that’s too big (didn’t have one the correct rating).

The Software

To test this, I decided to do some binary counting.

Initial Software

First I implemented my own solution, and when I turned of the debugging delays and optimized as much as I could it resulted in 2 of the LEDs (the ones signifying the most significant bits) visibly flashing, a sad result meaning that there would be visible flickering on the final display if I used this method, especially as I was outputting only 8 bits and not 24 (doing 24 would make it roughly half as fast due to the extra digitalWrite operations).

// The pins I will be using: int dataPin = 10; int fastClockPin = 11; int slowClickPin = 12; // The data to display: byte count=0; void setup() { // All the pins are output pins pinMode(dataPin,OUTPUT); pinMode(fastClockPin, OUTPUT); pinMode(slowClockPin, OUTPUT); // Reset all pins low digitalWrite(dataPin, LOW); digitalWrite(fastClockPin, LOW); digitalWrite(slowClockPin, LOW); } // This will pulse the fast clock pin void fastClock() { digitalWrite(fastClockPin, HIGH); digitalWrite(fastClockPin, LOW); } // This will pulse the slow clock pin void slowClock() { digitalWrite(slowClockPin, HIGH); digitalWrite(slowClockPin, LOW); } void loop() { // We don't want to edit count, so copy it. byte v = count; int i; // There are 8 bits in a byte, do the following for each bit. for (i=0; i<8; i++) { // Set the data: if v modulo 2 is 1, send high, otherwise low. (v modulo 2 is the remainder when you divide v by 2) digitalWrite(dataPin, v%2 == 1 ? HIGH : LOW); // I've written the data, let the SIPO chip know fastClock(); // Shift v 1 bit along, dropping the bit we just checked. v = v >> 1; } // All 8 bits have been output, tell the flip flops to store their current values: slowClock(); // Increase the value of count by one ++count; }

Abstraction Principle

Looking around at how to optimize this, I soon found that I could use a built in function shiftOut instead of my own method calling digitalWrite for every bit. I updated my code, changing 11 lines of code to just 1. This did speed it up (their binary arithmetic was faster than my method of the time) but not by enough – 1 LED still flashed – there would still be visible flicker. How annoying.

// The pins I will be using: int dataPin = 10; int fastClockPin = 11; int slowClickPin = 12; // The data to display: byte count=0; void setup() { // All the pins are output pins pinMode(dataPin,OUTPUT); pinMode(fastClockPin, OUTPUT); pinMode(slowClockPin, OUTPUT); // Reset all pins low digitalWrite(dataPin, LOW); digitalWrite(fastClockPin, LOW); digitalWrite(slowClockPin, LOW); } // REMOVED: fastClock(), because shiftOut() handles this for us. // This will pulse the slow clock pin void slowClock() { digitalWrite(slowClockPin, HIGH); digitalWrite(slowClockPin, LOW); } void loop() { // REMOVED: Most of the code here, shiftOut() does it all for us: shiftOut(dataPin, fastClockPin, LSBFIRST, count); // All 8 bits have been output, tell the flip flops to store their current values: slowClock(); // Increase the value of count by one ++count; }

Digging Deeper

I was a bit disappointed by this, as I knew from the last SoutHACKton meetup that on PICAXE boards you could set multiple pins at the same time. Setting just one pin at a time in Arduino seemed unnecessarily slow. I dug a bit deeper in the extended documentation, and came across the Port Manipulation page:

You may need to be able to turn pins on and off very quickly, meaning within fractions of a microsecond. If you look at the source code in lib/targets/arduino/wiring.c, you will see that digitalRead() and digitalWrite() are each about a dozen or so lines of code, which get compiled into quite a few machine instructions. Each machine instruction requires one clock cycle at 16MHz, which can add up in time-sensitive applications. Direct port access can do the same job in a lot fewer clock cycles.

Huzzah! I can write multiple pins at once, and not only that, I can skip a lot of the clever code that the Arduino libraries come with as I’m happy making assumptions about my program’s operation. Excellent!

I had a look at the built in functions, and revised my binary arithmetic so that I could be as optimized as possible, and ran the code…

// REMOVED: the pins (these are now implicit in the binary masks below rather than explicit as before) // The data to display: byte count=0; // Alternatively: unsigned int count = 0; void setup() { // The pins I am using are output pins: (12,11,10) DDRB = B00011100; // Reset all pins low: PORTB = B00000000; } int i; void loop() { // REMOVED: most previous code // Loop through the bits of count. (if count is an unsigned int, then use this instead:) for (i=0; i < 16; i++) { for (i=0; i < 8; i++) { // Turn all clocks off, and set the data pin PORTB = B00000000 | (!!(count & (1 << i)) << 2); // Leave the data pin as it is, turn on the fast clock pin, and if we're on the last bit also turn on the slow clock pin PORTB |= B00001000 | (!!(i == 7) << 4); // If we're working with an unsigned int, then change the 7 above to a 15. } // Increase the value of count by one ++count; }

... All the LEDs appeared on all the time... Either it's working perfectly or something's very wrong. Fortunately by adding a delay into the loop, I could see it was the former, and I celebrated! But just how much faster is it? I couldn't use the Arduinos internal timing, as timing it would cause it to use more processing power and thus slow down... Instead I decided to display the 8 most significant bits of a 16bit number, and see how many of those flickered. All except one flickered (not unexpected) but this meant it was significantly faster than before.

I timed the slowest flashing LED - one full cycle (on to off and back on again) of this 1st bit took an average of 2.2 seconds. This meant that one full cycle of the 9th bit (the one we're bothered about - the slowest of the initial 8 bits) was taking 2.2/256 = 0.0086s, or, in other words, it was running at 116Hz - good enough to not be noticeable by human perception (standard TV is 25-30 Hz). (This also means that the fastest bit is being pulsed at around 15,000Hz.) This is just 8bits, mind, not 24. Adding in the extra bits would not be too taxing on the system though - purely mathematics - as we can set all the pins in the same step. I would expect it to run all 24 bits at around 40-60Hz.

That is all.

If you’ve got a line like this:

LOGGING_FACILITY1( sanityCheck == noErr, @"Problem adding private key, OSStatus == %d.", sanityCheck );

But you don’t know what the OSStatus value means, and you’re devving on iPhone, here’s the answers:

enum { errSecSuccess = 0, /* No error. */ errSecUnimplemented = -4, /* Function or operation not implemented. */ errSecParam = -50, /* One or more parameters passed to a function where not valid. */ errSecAllocate = -108, /* Failed to allocate memory. */ errSecNotAvailable = -25291, /* No keychain is available. You may need to restart your computer. */ errSecDuplicateItem = -25299, /* The specified item already exists in the keychain. */ errSecItemNotFound = -25300, /* The specified item could not be found in the keychain. */ errSecInteractionNotAllowed = -25308, /* User interaction is not allowed. */ errSecDecode = -26275, /* Unable to decode the provided data. */ };

This was taken from /Developer /Platform /iPhoneOS.platform /Developer /SDKs /iPhoneOS3.0.sdk /System /Library /Frameworks /Security.framework /Headers /SecBase.h [remove spaces] (so quite easy to find then… NOT!) because SecCopyErrorMessageString doesn’t work on iPhone OS.

I hope this helps you – if it does, let me know in the comments!

To help you find this in the search engines this might be triggered if you are using SecItemAdd, SecItemCopyMatching or any of the other keychain services in the iPhone SDK. You might be using Apple’s [SecKeyWrapper sharedWrapper] functions too… Anything security related really. Or private key, public key, asymmetric key, signing, blah blah blah.

Apple Sucks

If your app won’t upload but you’re sure you’ve compiled it and signed it right, the fault might not be yours. For me, it was the built in “Compress [Folder]…” option – the archive produced from this might be missing files. You’re likely to see such errors as:

“The binary you uploaded was invalid. The signature was invalid, or it was not signed with an Apple submission certificate.”

“Icon specified in the info.plist not found under the top level app wrapper”

Seriously, Apple, what the f*ck? Thats 2 hours of my life lost because Apple couldn’t nail the basics: an archive utility. I’m so angry right now.