All documentation, source files and binary files are available for free from this site, so you can build your own. Be sure to read the disclaimer before you start however.

I would love to hear your success stories using this modular system!

Note: make sure you have Xcode installed.

• Delete any existing bundle. For example MyApplication.app. This is important because if the bundle already exists when you try to create it MonoMac will give you the cryptic error message “Unhandled error in packaging”
• In MonoDevelop go to Project -> Create Mac Installer… and choose to only create a bundle
  
  This should create a bundle with a name like MyApplication.app
• Start PackageMaker by going to Spotlight and searching for it. It can also be found in /Developer/Applications/Utilities.
• Drag your bundle MyApplication.app to the left hand side of PackageMaker.
• Select the package, click on “Components” and uncheck “Allow Relocation”
  
• Build and run the installer

You may or may not want to uncheck the option to allow relocation. On your development Mac if you don’t uncheck this then the installer will find a version of your application inside your MonoDevelop solution and overwrite it rather than putting it into /Applications. This makes it appear as if the installer didn’t work. On non-development Macs this option allows the application to be overwritten even if the user has moved it after installing an older version.

public static class Program
{
  public static Foo MyFoo = new Foo();

  static void main()
  {
    Main = new MainForm(MyFoo);
  }
}

The same can’t be said for MonoMac. The mistake is to equate the static MainClass class as being the same as the WinForms Program class in the example shown.

The solution is to put the global class instantiation inside the NSApplication delegate. MonoMac creates this automatically and calls it AppDelegate. The above example becomes:

public partial class AppDelegate : NSApplicationDelegate
{
  MainWindowController mainWindowController;

  public Foo MyFoo = new Foo();

  public AppDelegate ()
  {
  }

  public override void FinishedLaunching (NSObject notification)
  {
    mainWindowController = new MainWindowController(MyFoo);
    mainWindowController.Window.MakeKeyAndOrderFront(this);
  }
}

Quite a lot actually. The one on the left was bought on ebay for £3.50 and came with no packaging or information. The one on the right was bought from Amazon for £11.20 and came with Nintendo packaging and a warranty. Read on for details of all the differences I discovered.

Wiring

The wiring of the knock-off defied logic with the red wire being used for the I2C SDA signal rather than supply voltage (which is a worldwide convention). This causes a lot of confusion as all the Wii Nunchuk wiring information you will find on the Internet describes how the genuine item is wired. The knock-off used blue for 3.3V, brown for ground, red for SDA and yellow for SCL. The only consistency with a genuine item is yellow for SCL. All the other wires are different.

Another important difference is that the genuine version uses shielded cable but the knock-off does not. That’s not great if you are using your Nunchuk in an environment with lots of EMI.

Performance

If the knock-off Nunchuk was slowly moved in any direction then all three accelerometer values would freeze until either the Nunchuk was jerked or it had been moved more than 30 degrees from when it froze. This is a total disaster for the application I need the Nunchuk for.

The knock-off Nunchuk would reach the maximum and minimum values for the joystick when the joystick was half way between the center and the edge. The genuine Nunchuk uses the full range of motion.

Another issue was that the knock-off version would not return data when the I2C clock was at 400kHz regardless of delays inserted. Dropping to 100kHz fixed the issue. Intermediate frequencies were not tested. The genuine version works fine at 400kHz.

Lifespan

The knock-off version stopped functioning properly after about two hours of use. When power is applied it sends zeros for all data for a few seconds before switching to sending FFH instead. Note that I was supplying 3.3V to the Nunchuk before anyone suggests that 5V is bad.

Conclusion

I think many of the issues come down to the accelerometer used. Perhaps I bought a defective unit, but my advice is to save yourself some time and hassle and get a genuine Nunchuk for your project. I’m sure some knock-off versions work fine – the problem is how can you tell which are OK?

The I2C bus was running at about 100kHz. The time between the handshake and the first data read sequence is about 1.8ms and the time between each subsequent data read sequence is also about 1.8ms, although I feel that these times can probably be reduced.

Unlike many code examples I have seen there are no delays between each write operation in the handshake or between the write and read operations of the data read sequence.

First up is the handshake to send “unencrypted” data:

Next is the data read sequence containing a six byte chuck of data with the values we need:

Hopefully these will be useful to people developing application with a Wii Nunchuck.

An initial test showed that a 39MB XML file is processed in 4.9 seconds using Mono on a quad core server running Ubuntu. This is about 8MB/second which means that my 780MB file should be processed in around 98 seconds. Nice!

Obtain a 3.5mm to 3.5mm audio cable, for example this one. Connect one end to the audio source (for example a PC) and the other end to the microphone in on your linux box (I tried line in but that didn’t work for some reason).

Make sure ALSA utilities and ffmpeg are installed (at a console prompt):

$ sudo apt-get install alsa-utils ffpmeg

Start recording with:

$ arecord -f cd -t wav test.wav

Start the audio source and once complete press Ctrl-C to stop recording. Convert to MP3 with:

$ ffmpeg -b 128k -i test.wav test.mp3

I then run the file through MP3Gain as the recordings tend to be a bit quiet and add tags in iTunes.

However, never fear. After trying several approaches, all of which failed in some way, the solution can be found on timheuer.com. Tim presents a clear and straightforward method without needing to do anything weird (except for the Visual Studio bug workaround).

Here is my script:

#!/usr/bin/perl
# Converts ping output into a CSV file for graphing
# andy at british ideas dot com - March 29th 2011
# Public Domain
# Run using:
# ping -D 100.101.102.103 | ./pingtocsv.pl > output.csv
# or:
# cat pingdump.txt | ./pingtocsv.pl > output.csv
print "Measurement Time,Ping Time\n";
while (<STDIN>) {
  if ($_ =~ m/^\[([0-9\.]+)\].*time\=([0-9\.]+).*/i) {
    print "$1,$2\n";
  }
}
close(STDIN);

Run this using something like:

ping -D 100.101.102.103 | ./perltocsv.pl > pingtimes.csv

This will generate a CSV file. Hit Ctrl-C to terminate. Now use LibreOffice to open the CSV file and generate a graph. Here is mine (click to enlarge):

Fast forward to March 2011 and Ubuntu 10.10. I’ve used lots of different versions of Ubuntu since 2006 on a variety of machines including for CNC control, but the last time I installed in a dual boot system was two years ago. Ubuntu 10.10 works fine in a virtual machine inside Windows 7 but I wanted to run it at full speed.

I had a blank PC with two hard drives, both blank and installed Windows 7 on the first one. That went fine.

Next I installed Ubuntu 10.10 on the second blank drive choosing the option to install “alongside another operating system”. That’s when it went pear-shaped of course.

The first issue was when I was prompted to reboot. That produced a cascade of errors saying the hard drive that it just installed on wasn’t accessible. Eh? Then it stopped and I had to use the reset button.

Upon booting there was no grub bootloader! It went straight to Ubuntu. OK, fine. I know where /boot/grub/menu.lst is so this will be easy to fix. No such luck. Things have obviously changed and now I am back in 1998 searching web pages for possible solutions on how to avoid reinstalling Windows 7.

First attempt: gedit /etc/default/grub. Oops. Obscure error time again.

Second attempt: I know nano and at least that worked giving me access to the file. Sadly the contents of the file don’t show any references to kernels like I expected.

Third attempt: apt-get install startupmanager. Looks good. Shows Ubuntu as the only option though. No way to add additional operating systems – how useless is that?

The last issue I noticed is that Ubuntu failed to detect I had two monitors and stretch the desktop automatically. This is after installing the proprietary ATI drivers. I remember the Linux Action Show complaining of this exact issue with Ubuntu over two years ago!

At this point I am fed up and regretting venturing back into the Ubuntu world. I don’t want to spend hours working out how to get access back to Windows 7. Perhaps I am too stupid to use it?

If this is how the user experience is after years of hard work then I can’t see how Linux will ever make any significant gain on the desktop.

Some things never change.