iPad Mini and Apple Bluetooth keyboard

Pairing

Holding the power button puts it in to pairing mode.

Before pairing keyboard

Pairing keyboard

How do I get the on-screen keyboard back?

Using bluetooth keyboard

The first question I think everyone will ask is “How do I get the on-screen keyboard back?”. This is simple. Just press the Eject button on the keyboard in the top right corner. Press it a second time to use the keyboard again. Of course this means you need access to your keyboard. It has a pretty good range so if its say, locked in a draw, you will have to ‘forget’ the keyboard in settings and re-pair the next time you want to use it.

Using on-screen keyboard

What else can it do?

Function keys

The function keys on the keyboard also double as control/media keys. The iPad supports the following keys:

• The screen brightness keys (F1 and F2)
• The player (iTunes) control keys for rewind, play/pause and fast forward (F7 to F9)
• The volume control keys e.g. mute, volume down and volume up (F10 to F12)

Text selection

The arrow keys will move the caret around text input as you would expect. Holding down shift as you use them allows selection of text for cut, copy or delete as follows:

• shift and left/right arrow selects previous/next character.
• shift and option/alt and left/right arrow selects previous/next row.
• shift and control and left/right arrow selects to start of line/end of line.
  

Cut, copy, paste, undo, redo

These are as you would expect if you’re a Mac user.

• command and x – cut
• command and c – copy
• command and v – paste
• command and z – undo
• command, shift and z – redo

Alternative characters and accents

By now you’ll realise that this keyboard near enough supports all the functionality you would expect from a keyboard used with Apple’s desktop operating system (OSX). This isn’t a surprise since iOS and OSX are very closely related.

Holding alt down when typing a character will give you an alternative character. Usually this are related to the standard character for that key. For example on a UK keyboard shift and 3 gives you £ but alt and 3 gives you # (the reverse of the US case). Both # and £ are known as pound which is why Apple has mapped them that way. alt and ./> gives you ≥. alt and s gives you ß (which is a double S symbol used in German words such as Schloß).

The exceptions to the above rule is where the key is used to create accented characters. In that case you use alt and a key to create an accent modifier the you type the character you want to apply the accent too. Again the key used is related to the accent generated. For example back tick for a grave (accent that slopes down to the right), e.g. è. e for ecute (accent that slopes down to the left), such as é. u for umlaut (double dots) e.g. Mötorhead, and so on.

Other keys

When using Pages on the iPad I have found that the following are also supported:

• command and B to toggle the bold on text.
• command and I to toggle the italics on text.

When using Textastic the tab key can indent blocks of text (and shift tab to reverse indent).

Tab and shift tab will select the next/previous field in a form in Safari.

And that’s it. If I find any more I shall update this post. However I think that with the addition of a keyboard an iPad fulfils most of my day to day non-development requirements together with some minor development duties as well.

P.S. This post was written on my iPad.

I have an Apple USB Network Adapter that I use to provide a second network port. I connect this, using a CAT-6 cable, directly to my target device when developing. Enabling Internet Sharing will forward network traffic from either my primary ethernet port or wi-fi adapter. The only problem with this is the network IP address as I said above. This seems to be a hardcoded default.

However behind all the UI utilities Apple has command line ones that do the grunt work. Internet Sharing is no different. Checking out the man page for InternetSharing provides all sorts of gems.

$ man InternetSharing

Specifically these two snippets of information. This:

     InternetSharing reads the property list com.apple.nat.plist stored in the
     /Library/Preferences/SystemConfiguration.

And this:

     One property worth mentioning is SharingNetworkNumberStart.  This prop-
     erty controls the behavior of InternetSharing when it configures IP
     addresses for the local interfaces.  The property is encoded as a string
     containing the dotted decimal network IP address, assumed to be a class C
     network.

You can change the network IP address for the private network by defining a new value for the SharingNetworkNumberStart property.

Open a terminal and edit the file /Library/Preferences/SystemConfiguration/com.apple.nat.plist in vim. (You will need to us sudo to give you administrator/super-user privileges.)

$ sudo vim /Library/Preferences/SystemConfiguration/com.apple.nat.plist

At the bottom of the file, just above the second from bottom </dict> add a key value pair for SharingNetworkNumberStart as follows:

                <key>SharingNetworkNumberStart</key>
                <string>192.168.111.0</string>
        </dict>
</dict>
</plist>

Where the 192.168.111.0 can be any network IP address you choose.

Once edited if you restart Internet Sharing you will see the new IP address is used for the network.

Here are the slides to the talk I gave at Open Source Hardware Camp 2012 here in the UK.

http://www.cyberspice.org.uk/downloads/EmbeddedLinux.pdf

On the server

Creating a “git” user

Firstly we need to create a “git” user. On Linux you would use useradd on OSX the tool dscl (See man dscl) is used to create new users as one of a many number of things it can do. Below are the steps to create a new user.

$ sudo dscl . -create /Users/git
$ sudo dscl . -create /Users/git UserShell /bin/bash
$ sudo dscl . -create /Users/git RealName "Git server"
$ sudo dscl . -create /Users/git UniqueID 504
$ sudo dscl . -create /Users/git PrimaryGroupID 20
$ sudo dscl . -create /Users/git NFSHomeDirectory /Users/git
$ sudo dscl . -passwd /Users/git ******
$ sudo mkdir -p /Users/git
$ sudo chown -R git:staff /Users/git

The ****** represents what ever password you want to set. The UniqueID is the user ID and must be unique. I picked the next free ID in the same range as the other users on my system. You can list all the user information as follows:

dscacheutil -q user

I got a list of sorted UIDs with a bit of shell magic.

dscacheutil -q user | grep ^uid: | cut -d\  -f2 | sort -n

The PrimaryGroupID must be a suitable existing group. I picked 20 as that’s “staff” on my system. On an Ubuntu Linux system it would be “users”. Again you can get a list of group information using dscacheutil like so:

dscacheutil -q group

You could create a new group with the dscl command. I leave that as an exercise for the reader.

Creating a git repo

Now we have the git user we can set up the server. A git server isn’t really a server in so much as it doesn’t have a daemon process. Its just another SSH user. Setting it up is no different on OSX to any other *NIX system so I just followed the instructions from the GIT site. But I’ve put them below for completeness.

$ su - git
$ mkdir -p repo/project
$ cd repo/project
$ git --bare init

Basically login as the git user. Create a “repo” directory to contain all your git projects and a project directory called what ever your project is called. Then initialise it.

On the client

Now switch the client.

Generating SSH keys

As I said above a git server is just another SSH user. The recommended way of using git is via secure keys. The commands to create keys are as show below:

$ mkdir .ssh
$ chmod 700 .ssh
$ cd .ssh
$ ssh-keygen -f my_key_name -t rsa -q
$ ssh-add my_key_name
$ cp my_key_name.pub ~/Desktop

Firstly create a “.ssh” directory if you don’t already have one. It must have only user read, write and execute privileges. In that directory create the keys. The “my_key_name” can be substituted for any name you wish to use. Finally copy out the public key to somewhere easily accessible. Finally you can copy the key to the git server using the command:

$ scp ~/Desktop/my_key_name.pub git@git.some.domain:/Users/git

Repeat this step for all clients which wish to use the server.

On the server

Back on the server.

Adding a client’s SSH key

Now we need to add the client public keys to the server. As the git user create an “.ssh” directory, if one does not exist, and then just append the client public key(s) to the “authorized_keys” file.

$ mkdir .ssh
$ chmod 700 .ssh
$ cat my_key_name.pub >> .ssh/authorized_keys

On the client

Back to the client again.

Setting the git server SSH port (optional)

SSH on my server is accessed via a non standard port because there’s another machine behind the firewall on port 22. So I have to tell git which port to use. To do this I have created a “config” file within the “.ssh” the follow contents:

Host git@git.some.domain
	Port 1234

Creating the local repository

Finally we need to create the local git repo.

$ mkdir project
$ cd project
$ git init
$ git add .
$ git commit -m "Initial commit"
$ git remote add origin git@git.some.domain:/Users/git/repo/project
$ git push origin master

Create the local project repo directory. Add any contents and commit them. Finally we set the remote git server to be the ‘master’ and push up all the content. Note that on Linux the remote path would be “git@git.some.domain:/home/git/repo/project”.

Cloning a repository

Now the repo is on the server further clients can clone and update it like so.

$ git clone git@git.some.domain:/Users/git/repo/project
$ # Modify, add and remove files.
$ git commit -m "Commit comment"
$ git push origin master

On the server

Disable shell access to git (optional)

Finally you can replace bash as the git shell with git-shell. On OSX use the command below. On Linux it is simplest just to edit the git line “/etc/passwd” file.

$ sudo dscl . -create /Users/git UserShell /usr/bin/git-shell

This will disable shell access. If you try and use it you’ll get the following message:

$ ssh git@git.some.domain
fatal: What do you think I am? A shell?
Connection to gitserver closed.

And that’s it!

#!/bin/bash
 
# Returns the SVN revision of a directory and whether it is modified.
getsvnrev() {
	if [ -n "$1" ] ; then
		dir=$1
	else
		dir=.
	fi
 
	if [ -d $dir ] ; then
		# Get the last changed revision
		ver=$(svn info $dir | sed -n "/^Last Changed Rev/p")
		if [ -n "$ver" ] ; then
			ver=$(echo $ver | awk '{ print $NF; }')
		fi
 
		# Test to see if there are modified files in the sandbox
		if [ -n "$ver" ] ; then
			mod=$(svn status $dir | sed -n "/^[AMD]/p")
			if [ -n "$mod" ] ; then
				echo "R$ver(modified)"
			else
				echo "R$ver"
			fi
		fi
	fi
}
 
# tempfile is nicer but not always supported
mktempfile() {
	if [ -n "$(which tempfile)" ]; then
		tempfile
	else
		mktemp /tmp/makerelease.XXXXX
	fi
}
 
# Output usage to stderr
usage() {
	echo "usage: makerelease [option] dir [dir]" >&2
}
 
# Output help to stdout
fullhelp() {
	echo "Usage: makerelease [option] dir [dir]"
	echo "  -r directory    commit specified release directory"
	echo "  -h              display this help"
}
 
# If no release directory supplied commits pwd
reldir=.
 
# Process command line options
while getopts :r:h opt
do
	case "$opt" in
		r)
			reldir="$OPTARG"
			;;
		h)
			fullhelp
			exit 0
			;;
		:)
			echo "Missing argument for $OPTARG" >&2
			usage
			exit 1
			;;
		*)
			echo "Invalid option: $OPTARG" >&2
			usage 
			exit 1
			;;
	esac
done   
 
# Skip all the options processed above
shift `expr $OPTIND - 1`
 
# Check we have at least one argument
if [ $# -ne 1 ] ; then
	echo "You need to supply at least one component directory." >&2
	usage
	exit 1
fi
 
# Check to see if release directory is modified
reldirmod=$(svn status $reldir | sed -n "/^[AMD]/p")
if [ -z "$reldirmod" ] ; then
	echo "No changes to commit." >&2
	exit 1
fi
 
# Create a log file and allow user to edit it
msgfile=$(mktempfile)
if [ $? -ne 0 ] ; then
	echo "Could not create temp file." >&2
	exit 1
fi
 
echo "Components..." > $msgfile
while (( "$#" ))
do
	echo "   $1: $(getsvnrev $1)" >> $msgfile
	shift
done
 
nano $msgfile
if [ $? -ne 0 ] ; then
	echo "Editor returned an error." >&2
	rm -f $msgfile
	exit 1
fi
 
# Commit changes
svn commit -F $msgfile $reldir
if [ $? -ne 0 ] ; then
	echo "Commit failed." >&2
	rm -f $msgfile
	exit 1
fi
 
# Clean up
rm $msgfile
exit 0

It is commented so I will not explain it further. To use it either run it in the directory you wish to commit, or use the -r option (followed by the path to the directory to commit), together with a list of directories comprising the SVN components.

I finally finished on this project mid 2011 and was given the chance to work on an in-house project that I have been proposing for some time. The in-house project was interesting in that it was related to the core areas of the expertise for employer but it was a completely different type of development. The project has given me a chance to use technologies that interest me outside of work but typically aren’t used in work. As I result I have found myself developing client server software running on a LAMP server, developing a PHP application, writing UIs in HTML, CSS, jQuery and JavaScript, using JSON-RPC and other web technologies. All good fun.

The in-house project is still on-going but I have fee paying work again. This latest project is pseudo-embedded but with a web UI again. This time the back-end is written in C but the front end is again HTML, CSS, jQuery, JavaScript and JSON-RPC. I even found myself testing on an iPad the other day.

There has been a bit of a learning curve and as I’m admittedly less experienced at commercial development in some areas there are elements I would do differently. But the products have had a good reception and I have a lot of ideas for new blog posts based on things I have learnt and issues I have had.

The first computer in the house was my father’s. It was a TRS-80 Model 1. He had bought it to learn computing and because he realised computers were the future. I used it a lot learning to program in the BASIC language and then in Z80 assembly language (the language of the
microprocessor that ran the computer).

I was also interested in electronics (thanks to my Uncle who taught it in schools) and around the same time I saw an advertisement for the
Acorn Atom in an electronics magazine and I wanted one. I started saving but the BBC Microcomputer (“The Beeb”) came out before I could afford one. My Parents offered to help buy a Beeb by way of multiple combined Birthday and Christmas presents and the deal I would not use it until after my ‘O’ levels which I mainly complied with. I remember the excitement of going in to the store to purchase my Beeb.

I learnt to program that machine from top to bottom. I had the reference manuals and the data sheets for all the chips. I loved how you got the full circuit diagram with the Advanced User Guide (it was a print of the one hand drawn by Acorn). I learnt BBC BASIC and 6502 assembly language. I learnt how to add to the operating system and how to do clever things by directly programming the chips in the machine. It taught me a lot about programming, such as interrupts, concurrency, race conditions, dead and live locks, and so on. Programming did become my first love and superseded electronics but I wouldn’t be the programmer I am today with out it!

I didn’t just program. I did play games with my favourites being Chuckie Egg and Elite! Elite was a complete time sink. No game following sucked me in as much as Elite did until World of Warcraft!

I didn’t completely give up on electronics and would develope small projects to connect to my Beeb. In the mid 80s I was studying for a Physics degree and naturally I used my Beeb. My final year project was based around the automation of an experiment. I designed hardware to drive the equipment, sensors and hardware to read data, and wrote software to drive it all from a Beeb.

In 1989 I got an Acorn A3000. It was the successor to the Beeb and also used in schools. It had the Acorn designed ARM processor (now used in nearly everything from a mobile phone to the iPad, set top boxes and televisions), what seemed like copious amounts of memory, loads of colours and a built in disk drive. It had BBC BASIC so I was at home and also taught me to program ARM assembly language (which I still use today). So the Beeb was basically retired.

I moved on to other machines, developing for Linux, higher degrees and becoming a research assistant but I never lost my love of my Beeb though and I still own mine almost 30 years after I bought it. I also still make projects for it. The most recent being an ethernet interface so that I can connect it to the internet.

I am now an embedded software consultant and I work for a company that was formed by employees of the company that bought Acorn Computers when it finally ended in 1999. My most recent project was optimising Linux on a device with an ARM processor. And my entire career is down to me and my Parents buying that Beeb 30 years ago!

At the core is the traditional key matrix. It is a grid of rows and columns with momentary push switches that connect a row to a column when pressed. All of the rows are tied high by resistors to the 5v supply rail. The rows are inputs to an octal NAND gate (IC4), which, in this case is better thought of as an OR gate with inverting inputs. I.e. but default the output of the NAND gate is low but if one of the rows is pulled low the NAND output goes high. The rows are also inputs in to the line data selector (IC2).

The synchronous 4 bit binary counter (IC1) is driven by the BBC Micro’s 1MHz clock and when the KB EN is high is in free running mode. The 4 bit outputs (outputs QA-QD) are decoded by the BCD to decimal decoder (IC3) such that the decoder’s outputs go low in turn. The outputs of the decoder form the columns of the grid. I.e. column 0 is low on the first clock pulse, column 1 on the second and so on. If a key is pressed the row the key is on will go low when the column goes low. This in turn makes the output of the NAND gate go high indicating a key is pressed. The output of the NAND gate is used to generate an interrupt in the BBC Micro’s CPU.

So normally the keyboard is being scanned by the hardware without any software influence. This is a good thing as it takes a lot of loading off of the BBC Micro’s CPU. When the key press interrupt is triggered the key scanning software takes over. As I said normally the 4 bit binary counter (IC1) is free running however if the LOAD pin (pin 9) is taken low the 4 bit input value (inputs A-D) are latched through to the outputs (QA-QD) and hence control the columns provided by the decoder (IC3). IC1′s load pin is connected to KB EN.

The S line of the data line selector (IC2) is the select line and is also connected to KB EN. The output of IC2 is 3 state meaning it either reflects the appropriate data input line when select is low or is high impedance. The data input lines are the row lines of the keyboard matrix. The input line is chosen using the three bit ‘address’ value on A-C. The row state is output via pin W.

So the keyboard is normally hardware scanning. If the user presses a key, the interrupt is triggered. The CPU enables the keyboard by setting KB EN low and then manually scans the key board by setting the columns in turn via IC1 and checking the state of the rows in turn via IC2. Once the scan is complete KB EN is set high and the hardware scanning continues.

There are three keys on the keyboard which are exceptions. The two SHIFT and CTRL keys are on a row that does not trigger an interrupt. This means that shift is only scanned manually or when another key is pressed. The BREAK key (labled RST) is completely separate from the matrix and triggers the CPU’s reset line. On boot the CPU scans the keyboard manually to see if any of the modifiers are held down to do a cold reset or mount the disk for example.

The BBC Micro keyboard can be easily interfaced with say an ATMEL ATMega328 (like in an Arduino). The micro-controller can drive a pin directly from one of the timers generating a square wave output to scan the keyboard. The interrupt can be connected to one of interrupt inputs and the rest connected to general purpose IO pins set as outputs or inputs as appropriate. Dick Streefland’s USBtiny code provides the functionality to support the USB protocol in software utilising three IO pins on the micro-controller and a few discrete components. All that is required by me is to write the keyboard scanning code and provide the missing bits of the HID device profile.

Overview

In order to install kind of new operating system I needed to have root access on the device. This meant I had to root it. Since Android 1.6 (Release R10) on the G1 doesn’t have any useful exploits I had to downgrade the OS to Release R7 first. Once it is downgraded it you can use the rooting exploit in R7 to get root access and install a recovery image that will allow the installation of an updated radio software and the new operating system.

Preliminaries

Firstly read all of this blog post and all of the pages linked to from this blog post. There is at least one point in this process where you can “brick your phone”. I.e. you can put it in a state where by a regular user cannot make it usable.

Secondly you will be wiping your phone and replacing the software on it. Back anything up you want to keep. This includes purchased applications, data, contacts, whatever.

Make sure the phone is fully charged. You don’t want it running out of power mid-flash!

Finally I provide no warranty express or implied. You are doing this to your phone. If it goes wrong its your fault! You have been warned!

Downgrading and rooting

Downgrading, rooting the phone, and installing a recovery image is described in the link below. However since there are specific requirements for upgrading to Android 2.X I’ll explain each stage here.

http://forum.xda-developers.com/showthread.php?t=442480

Downgrading

Before you do anything take note of the radio version string in the boot-loader. Its the fourth line down. You get the boot-loader screen up by holding down the camera button when powering on the phone. With the original loader you should have multi-coloured bars with yellow text in the top left hand corner. On my phone the radio version string read “RADIO-2.22.19.26I”. Write down the string and store it somewhere safe. You’ll need it later.

Now download the appropriate older image for your phone. The links to the image downloads are on the page above however here’s the link for RC7 for those with UK phones. Download the image, unzip it, and save the DREAMIMG.nbh file in the root of your SD card. While you’re at it also download recovery-RA-dream-v1.5.2.img which is a recovery image and will be used later. Save this in the root of your SD card also.

Turn off your phone, insert the SD card, and turn it back on again holding down the camera key as before. It should now re-flash your phone. There should be a progress bar. When its all complete you can restart your phone normally (without the camera key held down). This will result in some old school Android graphics and you wondering how anyone ever coped with that software. Once the phone has booted find the phone details in settings and check the software build version number. It should appear as something like TC5-RC7 112931.

Rooting the phone

Now you have exploitable image installed it is time to root the phone. This can be done using a back door. Go to the home screen then type…

<return>
<return>
telnetd
<return>

…on the slide out keyboard. This will look like a search in contacts for the name of telnetd. In fact telnetd is the telnet daemon which allows you to connect to shell on the phone via telnet. So now you need a telnet client. Use the Android Market to download a telnet client. Once installed you should be able to telnet to localhost and get a telnet prompt.

If all is well you have shell access as root (a ‘#’ prompt). Yay!

Installing a recovery image

Now we are going to install the recovery image we downloaded earlier. This will also give us permanent root access. In the shell type…

mount -o rw,remount -t yaffs2 /dev/block/mtdblock3 /system
cd sdcard
flash_image recovery recovery-RA-dream-v1.5.2.img
cat recovery-RA-dream-v1.5.2.img > /system/recovery.img

For those who are interested the lines do the following:

1. Remounts the flash memory in read/write mode. This allows you to save to the flash in the phone.
2. Navigate to the sdcard (which is mounted at /sdcard)
3. Flashes the recovery-RA-dream-v1.5.2.img image file in to the special recovery partition in the flash.
4. Copies the recovery-RA-dream-v1.5.2.img as /system/recovery.img (The Android busybox doesn’t have the copy command but cat with a pipe works just as well!).

Once you’ve done this and have a prompt again you can reboot the phone. This time if you hold down the home and power buttons when you power on the phone it will boot in to the recovery image. You can use the short cuts or the track ball to select a menu item.

Now we are ready to install the new software.

New radio software and DangerSPL

Now we have to repartition the flash to give enough room for the new platform. This is the scary bit. As I said before…

Finally I provide no warranty express or implied. You are doing this to your phone. If it goes wrong its your fault! You have been warned!

Read this page thoroughly http://wiki.cyanogenmod.com/index.php?title=Dream:DangerSPL. If you’ve gotten this far you fulfil the prerequisites to install Danger/SPL. You now need to download the appropriate radio image, place it in the root of your SD card and flash it. Remember that number we noted down from the boot-loader screen at the start (“RADIO-2.22.19.26I” or similar). You will need it now.

Boot in to recovery by holding down the home and power buttons. Select “Flash zip from sdcard”. Select update.zip (if that’s the name of the file) from the file menu. The image should be flashed and will then reboot the phone. Reboot the phone again.

Take out the SD card and boot back in to the boot loader. It should now appear as below.

Upgrading to FROYO and installing Google Apps

All the hard work is now done. You have a rooted phone with a nice recovery menu which allows you to flash anything that will fit.

To install the latest Android read this link: http://wiki.cyanogenmod.com/index.php?title=Dream:Installing_CyanogenMod_5%2B.

Clear out your SD card and download Froyo for the G1/Dream and the Google Tiny Apps (The G1 is a bit short on flash space so wont fit the all singing all dancing versions of the Google apps). Boot in to recovery as before (home and power buttons) and again select “Flash zip from sdcard”. Flash first Froyo and then the apps.

Finally reboot your phone. You should now have Android 2.2 installed!

Issues

The only issue I had was an exception from the keyboard software the first time I used Froyo. This can be solved using the “Wipe” menu in the recovery image. I wiped data, cache and delvik cache (The latter generated an error I ignored) and then re-installed Froyo.