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!

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.

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.

Before we start, just to be clear – this is not for crackers (people who illegally break in to computer systems) but for hackers (people who modify the software or hardware of their computer system including building, rebuilding, modifying and creating software and electronic hardware either to make it better, faster, give added features or to make it do something it was never intended to do).

UPDATE: we have a google group: http://groups.google.com/group/southackton

I’m intending on setting up a “Hackerspace” in Southampton targeted around software programming (for fun) and hardware hacking (e.g. robotics). I anticipate that people would attend the hackerspace either with their own personal projects (such as controlling their television using a Wii remote), or looking to join in on a cool project. The idea is that we can all share knowledge and help each other out in a fun and innovative environment.

I am provisionally calling this project Southackton, though I expect (hope!) a better name will surface once more people are interested! If you or anyone you know is interested, please contact me via email (my name at benjiegillam.com) or by leaving a comment on this post.

The ultimate goal would be having an “office” somewhere in Southampton where members can drop in any time (within reason) and get to work on their project/just hang out with fellow hackers. If you work from home you could even work form the Hackerspace directly – it wouldn’t be so lonely! I am, however, expecting that we would run it as a “club” until we have enough interested members to make it feasible. Whether this club be weekly, fortnightly, monthly, or bi-monthly is a matter for interested persons to discuss – get in contact and let me know what you think!

As you may know if you read this blog (doubtful!), I am a great fan of open source, and have been a dedicated GNU/Linux user for almost 10 years now, so Linux users would be cool to have as they tend to be interested in tweaking hardware/software, however everyone would be welcome independent of their choice of operating system. Yes, that’s right – even Windows users!

Further, there is no required skill level. I’m happy to have people attend who want to acheive something (e.g. making a webcam recognise who is sat at the PC and change the computers background to a related picture/have their favourite teddy walk towards them) but have no idea how to go about it, so long as they are patient and willing to learn!

I hope you’re interested – let me know!

UPDATE: if you’re interested, sign up to our google group: http://groups.google.com/group/southackton.

Here’s a couple of bash scripts I’ve written recently that might be of use to someone.They work well under Ubuntu, and should work under any GNU/Linux or Unix system with the suitable software installed.

Improved “svn diff” command (ignores whitespace, colour highlights output, requires colordiff) – I put it in /usr/local/bin/svndiff:

#!/bin/bash svn diff -x -w $@ | colordiff

Improved recursive grep command (greps recursively, ignores files in the .svn folders, ignores temporary files, highlights output in colour) – I put it in /usr/local/bin/grepr:

#!/bin/sh SEARCHTERM=$1; shift; find . -type f -a -not -iname "*~" -a -not -iwholename "*/.svn/*" -exec grep -H --color=auto $@ "$SEARCHTERM" "{}" \;

You might also be interested in my previous “whoops I deleted files without telling svn” post here.

When deleting files in a working copy of an SVN repository you should do it on the command line: svn rm [filename]. If, however, you don’t do this (e.g. delete through a gui, or just do “rm” without the “svn“) then SVN gets confused, and puts a “!” in it’s status before all the deleted files. If you svn update, all the files will be recovered, rendering all your time spent deleting them wasted. Really you should use svn rm, but if it’s already too late for that, you can use this bash fragment to delete the files from SVN:

svn status | grep "^\!" | sed 's/^\! *//g' | xargs svn rm

This command does a status command, finds all lines starting with “!“, and then extracts the filename and runs it through “svn rm” – really deleting the file.

Caveats:

1. Manually deleted files are not the only things that makes svn use “!” – so beware of this! Ensure you do really want to delete all those files!
2. This works for filenames which are all_one-word/without/any.spaces but I am not sure if it will work or not for filenames with spaces in.
3. Use at your own risk. The code is simple enough so you should be able to grok what it does.

Enjoy!

Related articles by Zemanta

• Save Your Skin by Customizing Your Bash Prompt (ghacks.net)
• Moving Directories in a SVN Repository using Tortoise SVN (modhul.com)

PushupFu Demo

I had intended to get fit (and thin) before my wedding last August, however that never happened. And before I knew it it was Christmas, with all that loverly food. I’m not stupid enough to try and diet over the Christmas period! Instead, I thought, what else is the New Year for if not improving ones health?

My business partner Jof and myself had been working on a fitness app for the iPhone, PushupFu, for a couple of months and we finally uploaded it to Apple on 23rd December. In a very generous gesture from Apple, the app was released on 1st January (or 31st December, depending where you live!) – a full week earlier than we were expecting. I find that the app definitely motivates me to do pushups when users challenge me, plus I also intend to complete the training course (should be done by May) – when I can do 100 pushups I will really feel fit! (Currently I’m still only able to do single figures, but I have only just started!)

So, if you feel you need to get a bit more toned this year, why not give it a go by visiting http://www.GymFu.com/ ? At time of writing we have 5 reviews in the App Store, all are 5 stars, so give it a go! Check out our other reviews below:

Related articles by Zemanta

• PushupFu turns iPhone into fitness gaming network
• PushupFu – Portable Pushup Trainer
• iPhone Game Lets Your Pecs Battle With Push Ups [IPhone]

Image by FastJack via Flickr

I’ve just updated MythPyWii to handle the connection to Mythfrontend more smoothly, and to give feedback via the wiimote on error/disconnect. (i.e. if myth closes, the wiimote shakes, and the LED pattern changes to [ . # # . ] instead of [ # . . # ] just before the wiimote turns itself off). This means if there are issues connecting to Mythfrontend you can retry again simply by pressing 1&2 once more (fix any issues first though – e.g. closed mythfrontend/no remote interface enabled).

I’ve fixed a little bug with timestretching, and have also improved the timestretch responsiveness by emulating not just the left/right keys but also the up/down keys (which increase/decrease timestretch by 0.25 instead of just 0.05).

As always, download the latest version of MythPyWii here.

Ah hah, an update to Zemanta has just been released! Integration with Facebook and Flickr, eh? I best sign up for a Flickr account then, I suppose… Argh! They seem to have broken images with my theme – I fixed it by adding this CSS to my theme (copied from firebug):

.alignright { float:right; } .wp-caption { -moz-border-radius-bottomleft:3px; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:3px; -moz-border-radius-topright:3px; background-color:#F3F3F3; border:1px solid #DDDDDD; margin:10px; padding-top:4px; text-align:center; }

Related articles by Zemanta

• New release: My Friends, My Flickr and Filter
• Zemanta gets personal
• Zemanta Releases Major Upgrade – Now It’s All About You