While programs like Remote Buddy and Mira allow you to get much more from your apple remote, there is one drawback: it has only 6 buttons. This may work well for many people, and for applications specifically designed for it, but I just like to have much more control. As a recent switcher from a Windows desktop/media pc and FreeBSD/Unix server to a one-Mac-Mini-fits-all setup, I had one of those MCE remotes lying around, so that’s the one I wanted to use.

However, an intensive search on google and all sorts of forums did not help: as far as I know, the thing just isn’t supported. Using Remote Buddy or Mira I can use the eHome receiver delivered with my MCE Remote, but only with an Apple Remote and not the MCE Remote itself. Even looking at the Linux community did not help: while a port of the LIRC software is available in MacPorts it does not have any hardware support, but can only connect to a remote host. Having some good experience with running Windows and Linux as a virtual machine in Parallels Desktop I came to the following “solution” for my problem:

• Take a small Linux distribution, and run it as a VM
• Install LIRC and the needed linux kernel modules in this VM
• Connect my USB eHome IR receiver to LIRC in this VM
• Also install LIRC on the Mac natively and connect it to LIRC in the Linux VM
• Convert the button presses on the Remote Control to keypresses on my Mac using a combination of LIRC software and AppleScript

It took quite a bit of digging, but in the end I got everything working and I am now controlling my VLC media player using an MCE remote control.

A few words of warning: this tutorial is not for people who:

• Expect ready to use software with a graphical installer, neat configuration screens etc. All of this is basically a clever workaround, and it works well for me, but if the only thing you want is a way to reconfigure some buttons from your Apple remote, then Remote Buddy or Mira is the way to go.
• Are afraid of using the Terminal. You do not need to be a UNIX guru to follow the steps in this tutorial, but if you do not know what the Terminal is within Mac OS X, you better look through some basic toturials first.

If you still want to proceed, read the following three articles for the nitty gritty instructions:
- Step 1: installing Finnix as a Parallels VM
- Step 2: installing LIRC in the Finnix VM
- Step 3: configuring LIRC in OS X

Installing LIRC using MacPorts

The LIRC client executables can be installed using MacPorts. We will use these executables to connect to the LIRC daemon in the Finnix VM.

First you need to install:

• Apple Xcode
• MacPorts (installation instructions)

Then fire up a terminal, and execute the following commands in a Mac terminal to initialize your ports tree and install LIRC:
$ sudo port -v selfupdate
$ sudo port install lirc

While you are waiting for lirc to install, let’s already execute the next step: in order to connect to your virtual machine, you need to know the IP address used by it. Run the ifconfig command in your Finnix VM. The output looks someting like:
root@tty1:~# ifconfig eth0
eth0    Link encap:Ethernet HWaddr 00:1c:42:f0:e5:19
        inet addr:10.37.129.3 Bcast:10.37.129.255 Mask:255.255.255.0
        UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
        RX packets:813 errors:0 dropped:0 overruns:0 frame:0
        TX packets:145 errors:0 dropped:0 overruns:0 carrier:0
        collisions:0 txqueuelen:1000
        RX bytes:73804 (72.0 KiB) TX bytes:11687 (11.4 KiB)
        Interrupt:10 Base address:0x8200

The ip address you are looking for is the one after ‘inet addr:’ on the second line.

When lirc is installed, let’s connect to it by typing the following in your Mac terminal (and not the Finnix VM), obviously replacing the ip address with the one you found in the previous step:
# sudo lircd --connect 10.37.129.3
# sudo chmod 666 /opt/local/var/run/lircd

Now let’s test your setup by running ‘irw’ and pushing some buttons. Your terminal should look like:
# irw
000000037ff07bf2 00 Home mceusb
000000037ff07bf2 01 Home mceusb
000000037ff07bf2 02 Home mceusb
000000037ff07be9 00 Play mceusb
000000037ff07be0 00 Down mceusb

Congratulations! You are now receiving your MCE Remote events on your Mac. Read on for information on how to control an application with it.

Controlling VLC with LIRC

This tutorial will now show you how to control the VLC media player using your MCE remote by mapping your remote buttons to keypresses.

First of all a script is needed that can send keystrokes. AppleScript is the most logical candidate. A script like the following should do the trick (note: at the end of this posting you can find a link to download a full version of this script):
-- Filename: keystroke-simple.applescript
-- Author:   Edwin Woudt
-- Version:  20090407-1
--
-- Note:     This is a simplified version of the full script.
--           Download keystroke.applescript below for the full version.
 
on run argv
    
    set xkey to (item 1 of argv)
    
    if ((count of argv) > 1) then
        set xmod to (item 2 of argv)
    else
        set xmod to ""
    end if
    
    set xcode to 0
    if xkey = "down" then set xcode to 125
    if xkey = "up" then set xcode to 126
    
    if xmod = "" then
        if xcode = 0 then
            tell application "System Events" to keystroke xkey
        else
            tell application "System Events" to key code xcode
        end if
    else
        if xcode = 0 then
            if xmod = "x" then tell application "System Events" to keystroke xkey using command down
        else
            if xmod = "x" then tell application "System Events" to key code xcode as integer using command down
        end if
    end if
    
end run

This script can be called with two command line parameters:

1. A key, either a letter or a special key like ‘up’, ‘down’, ‘esc’ or ‘enter’
2. An optional modifier, consisting of one or more of the following letters: ‘c’ for Control, ‘o’ for Option, ’s’ for Shift and/or ‘x’ for Command (note: the simple version only supports the ‘x’ modifier, the full version below supports all modifiers and all combinations).

This script will be called from a ‘lircrc’ file, of which the following is a small example:
# Filename: vlc-simple.lircrc
# Author:   Edwin Woudt
# Version:  20090407-1
 
#  Note:     This is a simplified version of the full file.
#           Download vlc.lirrc below for the full version.
 
# Play button
begin
    prog   = irexec
    button = Play
    config = /usr/bin/osascript ~edwin/Documents/Scripts/keystroke.applescript p x
end
 
# Volume buttons
begin
    prog   = irexec
    button = VolUp
    config = /usr/bin/osascript ~edwin/Documents/Scripts/keystroke.applescript up x
end
begin
    prog   = irexec
    button = VolDown
    config = /usr/bin/osascript ~edwin/Documents/Scripts/keystroke.applescript down x
end

This file will basically instruct lirc to output a ‘Command-P’ when I click on the Play button, ‘Command-Up Arrow’ for the volume up button and ‘Command-Down Arrow’ for the volume down button. These correspond to the default keys used by VLC, according to the VLC Preferences -> Hotkeys.

Create the file with a texteditor (or download my full version below) and run it in a terminal using:
irexec ~edwin/Documents/Scripts/vlc.lircrc

Note: all my scripts assume their location to be in the Documents/Scripts subdirectory of my home directory. Feel free to change it to a different location.

Now start up a video in VLC media player and try to use some buttons!

Download attachments:
vlc.licrc
keystroke.applescript

Next steps

You have now reached the end of this three part tutorial on getting your MCE remote control to work on your Mac. Hopefully this has all worked out for you: let me know through a comment or by mailing me at edwin AT woudt DOT nl.

A few things you could do after this tutorial:

• change the configuration for the VLC media player to be more of your liking
• add configuration files for other applications
• somehow extend all this with detection of which application is running (using AppleScript?) and change the behaviour of the remote based on that
• use a different linux distribution
• use VirtualBox as a free alternative to Parallels

If I get around to one of these things, I will post the results on this blog. Of course: should you have anything to add, let me know, whether it is a solution to one of the above suggestions, or a completely different thing.

Configure and Reboot the VM

First we need to attach our IR receiver permanently to the Finnix VM.

1. In the ‘Parallels Desktop’ menu, select the ‘Preferences’ option
2. On the ‘USB’ page, click the ‘+’-sign at the bottom and select the ‘eHome Infrared Transceiver’ to connect to the ‘Finnix IR’ virtual machine. [screenshot]

Now here comes the tricky part: while you installed Finnix on the virtual hard disk, you need to reboot it from the original virtual CD. This is because the hard disk is read-only when you boot from it, thus you cannot make any configuration changes. You can boot from the LiveCD using the following instructions:

1. In the configuration for the Finnix VM, select the ‘Boot Order’ page and check the ‘Select boot device on startup’ option. [screenshot]
2. Then go to the ‘CD/DVD-ROM 1′ page, check the ‘Connected’ option and make sure the .iso file is still selected. [screenshot]
3. Boot the VM and press the ‘Esc’ key. Then select option ‘3′ to boot from the live CD. [screenshot]
4. To prevent the VM from booting from the hard disk (the livecd finds the installation in the hard disk before it’s own), select the first option and press the ‘Tab’ key. Add ‘root=/dev/hdb’ to the line and press ‘Enter’. [screenshot]

To check if you have correctly booted from the Live CD instead of the hard disk, use the following command:
mount -l | grep ramdisk
If the result starts with /ramdisk/dev/hdb then you were succesful. On the other hand if the result starts with /ramdisk/dev/hda1 then try again!

Read on for the gory details of LIRC installation.

Installing LIRC and compiling the LIRC kernel modules

Some fiddling is required with the build names to get things right. This is because Finnix adds a ‘-finnix’ to the kernel version, and replaces the 486/686 with a x86. For example, Finnix 92.1 reports its kernel version as ‘2.6.26-1-x86-finnix’ while the corresponding Debian package with the correct headers needed for building kernel modules has version number ‘2.6.26-1-686′. The following commands will give you two environment variables that are helpful there (note: all of these commands need to be entered in the Finnix VM and not the Mac Terminal):
# FINNIX=`uname -r`
# VERSION=`uname -r | sed s/-finnix/ | sed s/x86/686/`
# echo $FINNIX -- $VERSION

Let’s go and install some software:
# apt-get update
# apt-get install lirc lirc-modules-source linux-headers-$VERSION
# m-a prepare
Just press Enter on any questions.

Now here comes the fiddling: we need to trick Finnix to think the installed header files are actually from a Finnix kernel:
# echo \#define UTS_RELEASE \"$FINNIX\" > /usr/src/linux-headers-$VERSION/include/linux/utsrelease.h
# echo $FINNIX > /usr/src/linux-headers-$VERSION/include/config/kernel.release
# mv /usr/src/linux-headers-$VERSION /usr/src/linux-headers-$FINNIX

And now we can build the lirc modules:
# m-a a-b lirc

Next we’re going to install all relevant packages in an overlay directory which Finnix will load automatically on the next boot from the harddisk:
# mount /dev/hda1
# mkdir -p /mnt/hda1/FINNIX/overlay.d/lircoverlay
# cd /mnt/hda1/FINNIX/overlay.d/lircoverlay
# dpkg -X /usr/src/lirc-modules-*.deb .
# dpkg -X /var/cache/apt/archives/lirc_*.deb .
# dpkg -X /var/cache/apt/archives/liblirc*.deb .
# dpkg -X /var/cache/apt/archives/libasound*.deb .

Install the right remote control file for our remote control. Should you have another remote control, have a look around in the usr/share/doc/lirc/remotes directory to see if your remote is supported.
# cd /mnt/hda1/FINNIX/overlay.d/lircoverlay
# cp usr/share/doc/lirc/remotes/mceusb/lircd.conf.mceusb etc/lirc/lircd.conf

Finally create a startup script so the kernel modules are automatically loaded and lircd is automatically started:
# cd /mnt/hda1/FINNIX
# cat > /mnt/hda1/FINNIX/finnix.sh <
> #!/bin/bash
> depmod
> modprobe -f lirc_dev
> modprobe -f lirc_mceusb2
> lircd -d /dev/lirc0 -l
> EOF
Again here: if you have a different receiver then the eHome ‘new-style’ IR receiver, edit the line with ‘lirc_mceusb2′ on it and replace it with the correct driver for your IR receiver.

Finishing up

Now that all is installed, let’s tune the VM down a bit so that it does not use that many resources. You need to shutdown the VM before changing these settings.

1. The VM does not need networking, so let’s confine it to ‘Host-Only Networking’ on the ‘Network Adapter 1′ page in the VM configuration. [screenshot]
2. The amount of memory needed is not that much. I use 48 MB, but 40 MB also works at the cost of extra startup time. [screenshot]
3. When saving Parallels will give you a warning which can be ignored. [screenshot]

Screenshots

Installation instructions

This part is about installing the Finnix Linux distribution so that it runs in a virtual machine (VM) on your Mac. This instruction assumes you have a copy of Parallels Desktop for Mac 4.0 installed (it should work fine with their 14 day evaluation version). Potentially a similar procedure can also be applied with VMware Fusion, or (if you want a free solution) with VirtualBox, but I have not tried it. Let me know if you succeed!

Now here are the instructions. Install Finnix in Parallels Desktop using the following 12 steps:

1. Open the “File” menu for Parallels Desktop and choose the “New Virtual Machine…” option. A wizard will appear. Click “Continue” in the first screen.
2. Select the .iso image file you downloaded from the Finnix site.
3. Parallels cannot auto-detect the operating system type. Finnix is a Debian derivative, so let’s enter that.
4. Choose a “Custom” virtual machine type.
5. Leave the number of CPU’s to 1. Set the memory requirement to 512 MB, if it’s not already set to that value. Later on we’ll decrease this value much further (48 MB is enough), but for lirc installation a big ramdisk is needed.
6. We’ll need a new image for the hard disk.
7. A mere 1 gigabyte should be enough. Using the “Expanding disk” option saves even more space.
8. Use “Share Networking”. Later on networking can be confined to “Host-Only Networking”, but for now we need the connectivity to install software.
9. We do not want the VM to drain too much resources, so we optimize the performance for the Mac
10. Use any name you like. I use “Finnix IR”.
11. Click “Start” to boot the Finnix Live CD.
12. Choose the first line (x86) instead of the default (AMD64). You could boot in AMD64 mode just fine, but there are some problems with the lirc kernel modules in 64 bit mode.

After a little while you’ll be presented with a booted up Finnix. Congratulations!

Read on for the screenshots and for installation on the virtual hard disk.

Installing on the virtual hard disk

First, let’s create a partition the disk and format the partition with the linux (ext2) filesystem.
# sfdisk /dev/hda << EOF
> 0,,L
> EOF
# mke2fs /dev/hda1
This instructs Finnix to create one big partition on the 1GB disk of the ‘L’ (=Linux) type and then create an Ext2 filesystem on it.

Next step: mount the disk and copy the files from the virtual cd to the hard drive.
# mount /dev/hda1
# cp -R /cdrom/* /mnt/hda1

Finally we need to install a grub boot menu so that it can actually boot into Linux:
# mkdir -o /mnt/hda1/boot/grub
# cat > /mnt/hda1/boot/grub/menu.lst << EOF
> timeout 5
> title Finnix
> root (hd0,0)
> kernel /isolinux/linux root=/dev/hda1 quiet
> initrd /isolinux/minirt
> EOF
# /usr/sbin/grub-install --root-directory=/mnt/hda1 /dev/hda

Now that’s all done, you could reboot from the local hard disk.

Screenshots