iPhone running TouchOSC

Today, in addition to working hard on my upcoming app release (which I am very excited about) I have been playing with the TouchOSC app from hexler.net. TouchOSC, available from the Apple App Store, provides several touchable interfaces including virtual faders, cross-faders, knobs, pads, keys, buttons, grids and x-y pads; all of which send OSC data over Wi-Fi using UDP. It is kind of  like a mini JazzMutant Lemur in your pocket.

The OSC data from TouchOSC can be used in software capable of receiving OSC messages, such as MaxMSP or Processing, or you can parse the OSC data to MIDI and then on to any MIDI controllable software such as Ableton Live. To translate the OSC to MIDI on a Mac I highly recommend you check out OSCulator. If you own Max you could build yourself a maxpat to do the same thing but OSCulator is prebuilt and there are some excellent presets available on the hexler.net website. Mac users will find instructions on using TouchOSC with Osculator and Ableton Live here. Windows users will find instructions to do something similar using a combination of Pure Data and MIDI Yoke here.

Setting up TouchOSC on your home wi-fi network is a piece of cake. All you have to do is open the TouchOSC Network settings and set the host and the  outgoing and incoming ports. The ports can be whatever you want to use; I use 8000 for outgoing and 9000 for the incoming port. The host should just be YOURCOMPUTENAME.local. This worked flawlessly for me the first time I tried it.

If however you are not at home, or are somewhere without wi-fi, and you want to use TouchOSC with your MacBook or MacBookPro, you need to create an ad-hoc wireless network. All an ad-hoc network is is a wireless network where the communciation between devices is direct, rather than through an access point or a router. Here are the steps to create an ad-hoc network and set up TouchOSC to communicate with your Mac:

1. Open up System Preferences->Network.

2. Click on the Network Name drop down and select  Create Network.

3. Give your network a name. A password is optional though probably a good idea.

4. Click on Advanced.

5. Click on the TCP/IP tab.

6. Click the Configure IPv4 drop down and select Manual.

7. Enter an IP and NetMask for your computer. I use 192.168.2.1 and 255.255.255.0.

8. Click OK and then Apply and close System Preferences.

9. On your iPhone open Settings->Wi-Fi and select the network you just created.

10. Click the arrow to the right of the network name.

11. Select Static for your IP type and enter your IP and NetMask for the iPhone. I use 192.168.2.2 for the IP. The NetMask must be the same as for the network which is 255.255.255.0.

12. Exit your iPhone settings and open TouchOSC.

13. Touch the field under the heading Network.

14. Enter the IP address you created for your Mac. In my case this is 192.168.2.1.

15. Make sure your ports are as you want them. Remember, the ports can be whatever you want to use, just make sure that they agree with whatever you are communicating with, ie OSCulator, MaxMSP, Processing etc. I use 8000 for the outgoing port and 9000 for the incoming port.

16. Touch the done button and then once you are at the mainscreen of TouchOSC, select your Layout and touch done again.

It sometimes takes a few seconds to connect to the network and open the TouchOSC Layout but once it opens you should be able to communicate with your Mac over the ad-hoc wireless network. To test out the ad-hoc network try using OSCulator or one of the Max patches provided on hexler.net. This is what worked for me; hopefully you will find that these instructions get you up and running TouchOSC over an ad-hoc network too. If you have any problems please leave a comment and I will do my best to help you.

A lone pushbutton switch

Before setting out to debounce my pushbuttons I did some searching on Google and discovered an excellent article on debouncing called simply, A Guide To Debouncing. It covers multiple techniques for both hardware and software debouncing.

After reading the article, I decided to go with a software counting algorithm. I did some more research but I wasn’t happy with the examples that I found. All of them involved debouncing a single switch. I wanted to debounce an entire port of switches. To do this you could just repeat the debouncing code for each switch but I decided to write a single piece of code to handle an entire port.

Below is my solution using PORTB on an Arduino. PORTB is a six pin port. This could easily be ported to be used on any AVR microcontroller or indeed any other microcontroller that can be programmed in C.

My Arduino NG

All the pushbuttons in my example are active high with pull down resistors. The code could easily be adapted for active low. (Note that my prototype actually only has two buttons connected to it. I set up wires with pull downs to act as switches for the remaining pins)

First we define the number of switches on our port (in this case six), then the debounce depth. Debounce depth is the number of consecutive times that a switch must be read to have a certain value (HIGH or LOW, 1 or 0) before a press of that switch is validated.

#define numButtons 6
#define debounceDepth 10

Next we set up the variables we will need. The first one is used to read the PORTB value into. The second is to keep a memory of the last debounceDepth number of reads. The next keeps tabs on whether the pushbutton switch has been released after pressing. This variable provides a form of hysterisis so that we don’t get multiple toggles on one button press. The buttonPressFilter is a bitwise ANDed sum of all of the debounceDepth number of memories. The result in the buttonPressFilter is what determines if a pushbutton switch has been validly pressed.

char buttonRead;
char buttonMemory[debounceDepth] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int buttonHasReleased[numButtons] = {true,true,true,true,true,true};
char buttonPressFilter = 0xFF;
int buttonState[numButtons] = {0,0,0,0,0,0};

So that is the end of initialization. Now onto the code that you would put in your loop. The buttonPressFilter is an 8-bit variable with each of the lower 6 bits representing the state of a pushbutton switch, pressed or not-pressed. (Remember, PORTB on Arduino only has 6 pins) Each time we loop through here, we reset the buttonPressFilter to start as all 1′s. As it is bitwise ANDed with the previous button memories, any button read of a zero value will fall through as a zero, the rest will be left as 1′s. It basically ‘filters’ out any button presses that are not yet stable.

buttonPressFilter = 0xFF;

Here we shift all the memory by one, dumping the oldest reading to make room for the new reading. Then we AND all the old memories together.

for(i=(debounceDepth-1); i>0; i--) {
    buttonMemory[i] = buttonMemory[i-1];
    buttonPressFilter &= buttonMemory[i];
}

Here we read the current status of the switches on PORTB.

buttonRead = PINB;

Now for each pushbutton switch we check if the current read indicates a press. If it does, then we set its memory bit, otherwise we clear it.

for(i=0; i<numButtons; i++) {
    if((buttonRead & bitMask[i]) != 0) { // if current read shows button is pressed
        buttonMemory[0] |= bitMask[i];     // set the memory bit for that button
    } else {
        buttonMemory[0] &= ~(bitMask[i]); // otherwise clear the memory bit for that button
    }
}

Take account of the newest read into memory.

buttonPressFilter &= buttonMemory[0]; // AND the final memory bits into the buttonPressFilter

Now the buttonPressFilter contains the current pressed or non-pressed state of the switches. If any switch has had a consistent value for debounceDepth number of times, then toggle the state in the buttonState array and do whatever it is you want your button to do.

for(i=0; i<numButtons; i++) {
    if((buttonPressFilter & bitMask[i]) != 0) {
        if(buttonHasReleased[i] == true) {
            if(buttonState[i] == 0) {
                // ENTER CODE HERE FOR WHAT YOU WANT TO HAPPEN WHEN BUTTON IS ON
                buttonState[i] = 1;
            } else {
                // ENTER CODE HERE FOR WHAT YOU WANT TO HAPPEN WHEN BUTTON IS OFF
                buttonState[i] = 0;
            }
        }
        buttonHasReleased[i] = false;
    } else {
        buttonHasReleased[i] = true;
    }
}

One final thing to mention is that the debounceDepth value is something that you need to experiment with for the specific switches in your project. Currently with my cheap pushbuttons sitting in a cardboard chassis and wired to a breadboard, I need a value of 10 to get stable results. Using better switches, a stable chassis and a PCB I expect this number to drop.

DIY cardboard MIDI controller

I am planning on using this Arduino based prototype to experiment with fine tuning the firmware for a line of boutique and custom MIDI controllers. The final project will be ported to C using the AVR C library and I will make the whole project open source.

Here is a look at the back. I just used whatever pots I had, so they aren’t matched. The LCD is a serial one from SparkFun.

Underbelly of the cardboard MIDI controller

Oxygen 49 transport controls

The Oxygen 49 is a natively supported control surface in Ableton Live. To setup the controller go to Preferences->MIDI/Sync and select your device from the Control Surface dropdown list at the top left. Then select your MIDI input and output ports from the next two adjacent dropdown lists. If you are using an Oxygen 49 via USB then the ports will be something like “USB Oxygen 49”. You should now be able to use all of the transport buttons on the controller except for Forward and Reverse which will cause the crazy play-head problem.

A common use of Forward and Reverse transport buttons is to move the play-head through an arrangement window, usually by some user defined length; 1-bar, 8^th notes, 16^th notes etc, and sometimes to navigate through user defined locators. As far as I know the former is not possible in Ableton Live as of version 7, at least not with an Oxygen controller. What we can do though is setup locator navigation by assigning the Forward and Reverse keys to the Previous and Next Locator buttons using MIDI Map Mode. Settings in MIDI Map Mode override control surface defaults.

To enter MIDI Map Mode click the MIDI button at the top right of the Live window. Click on the Previous Locator arrow and press the Reverse button on your controller. Click on the Next Locator arrow and press the Forward button on your controller. Press the MIDI button to exit MIDI Map Mode. Now you can create locators in the arrangement window using the Set Locator button and move through them using the Forward and Reverse transport buttons.

It would be nice to be able to assign these buttons to increment or decrement the play head location by the global quantize amount. Hopefully this will be a MIDI assignable option in future versions of Live. In the meantime this is a much better use for the Forward and Reverse transport buttons than locking up the program.

This driver is a virtual midi device that you can use to route MIDI to, through and from. My Max patch parses the serial data from the Arduino to the IAC Driver. By choosing the IAC Driver as a MIDI input in Live (or any other MIDI capable app) you can then use the serial MIDI CC data sent from the Arduino to control your software.

The MIDI data that the Max patch expects at the serial input is in the standard MIDI format for a CC message; a status byte, a control number and a value. This simple patch just listens for a status byte of 176 which is a control change on channel 1. The baud rate I chose for this patch was 57600. Note that you do not have to use the standard MIDI data rate of 31250 baud.

MIDI Devices

To enable the IAC Driver go to Applications->Utilities->Audio MIDI Setup, click on the MIDI Devices tab and then double click the IAC Driver icon make sure that the Device is online check box is checked.

To use this patch you need the MaxMSP Runtime. Once you have that installed open it up and then open the patch with it. Double click on the midiout object and select the IAC Driver. Then click the button at the top of the chain to start reading the serial port and parsing the data. You should now be able to use  midi learn to map your controllers and start tweaking stuff in realtime with your potentiometers.

Here is what the patch looks like:

Serial to MIDI Max patch

If you own Max just copy the following code and then paste it in a blank patcher.

----------begin_max5_patcher----------
488.3ocuVsrahCCEccxWwUdclQ9QdTlcUpa5h9ETUMxPLTOJwFkXTof5+9X6
.COFjvIjhDgHesu1m64dNIYabDZpdsnEA+BdEhh1FGE4C4BDsabDpludVEu0
uLjR7gd5ePIcSYDqM9vapf4xJinAHE46mUspVppDFelzCA0qLmGctVYT7Zge
ydrQxq1uIK4lYuKUK9ciXloCozT7OwI.kl4tkOwOvFBdaWNcGf4ykhtDPnD6
0+l1cXsxM9IITa1cgkk9S2Vd+ffbg9JN18WxsQMKajJC7xyO87E4ExE4E7P3
ER1I7B6+3kqW3ECovM5EKpD8n5HWs2xv6A+0ZsVx8Pm8nJgMhsvZgoQCY8PW
StAccgu8kQtdsOkqVzGYMcD4jVgqZ.NjUjiwvC.Av8PBbKFeRmtfPxCSdzSy
OaLc+0xRoETe2VeZpWtvRSc2RmL.qOCOxk8bcSM+xUdwnaZnO3cMDbeejQ.t
lIiIw3p.2KIAkx9a.OzbPNl77fYmd8dxrioFehnJo57OovCLW7S4qV8plY6O
1caWBb.ZkhViTwMRs53EcxZdWVVJTG6arRukZaKdGFf2tXyKXHE.hrBDKod2
fDKDLcFU9ciIZ.Phce6brP5b2WRZRHrD99puCwxUbCPxN3q3+JxEVKJ
-----------end_max5_patcher-----------

If you don’t own Max then you can download the patch here.

I will try and put together a more complete patch with user selectable options sometime soon.