the τonnetz

The τonnetz was a project for Marcelo Wanderley’s MUMT 619 class at McGill, during Winter 2013. The course is called ‘Input Devices for Musical Expression’, and although I don’t know how traditionally ‘expressive’ the τonnetz is, it’s an interesting thing on a few levels.

The device itself is heavily influenced by Joseph Malloch’s T-Stick, in that it is a cylinder with touch buttons on it. Unlike the T-Stick, it takes the touch button idea to the extreme. The τonnetz is a little over a foot long, and has forty-eight capacitive touch buttons on it. Each button plays the appropriate note. In standalone mode, it has four voice polyphony, and plays notes through a speaker in one end. In MIDI mode, it has ten voices, and sends MIDI numbers over the USB cable. It has no other sensors, and thus no other ‘expressive’ control. No gyros, no accelerometers, no FSRs – just endless buttons. Think of it as a tiny harpsichord, wrapped and packaged up.

A ‘real’ Tonnetz is a conceptual layout of pitch-space (like the circle of fifths). It was first described by, of all people, Leonard Euler, in 1739 – see above.  One axis moves by major thirds, one by minor thirds, and one by perfect fifths. Here’s a better picture:

The cool thing about a Tonnetz is that if you tune the intervals using just intonation, it goes on forever: a B# does not equal a C. But! If you tune them using equal temperament, suddenly it snaps into a torus, a donut:

This is super cool for a bunch of reasons. For me, it is cool because it takes a totally theoretical construct and turns it into a physical shape. This, of course, means that we can build it. I did not build a torus because tori are hard to build. Instead, I made a much simpler cylinder, with major thirds wrapping around it (This, in theory, means that my major thirds are equal tempered, and my other intervals are just – but I made the entire output equal tempered for simplicity).

With 48 buttons, I had enough buttons for four octaves. However, I ran into a tricky problem. The Tonnetz is a theoretical construct that works in terms of pitch classes. The τonnetz, on the other hand, has to play back real notes, with real pitches. And, if you start from, say, an ‘A’ and move away from it in major thirds, well:

A3 – C#4 – F4 – A4 – C#5 – F5

But wait! That A3 and F5 are adjacent. Ooops.  It turns out that there’s no way to assign pitches to make the real cylindrical object behave in a theoretically proper manner. So, I simply cut the thing in two, and put 24 buttons in one octave and 24 in a higher octave.  This gives:

A4 – C#5 – F5 – A4 – C#5 – F5

This mean that some major thirds were in fact minor sixths, but felt like a good, consistent compromise (And my tiny speaker couldn’t really handle four octaves anyways).


Everything’s driven by an Arduino. It talks to the six 8-channel capacitive touch chips over I2C, and play the appropriate note through the speaker using the Mozzi synthesis library. The buttons are copper tape, and the battery was duct-taped in. It’s a tremendously simple setup – but not one without problems. I made two major mistakes.

First, I didn’t cut the tube open. I though that I could push the wires through, solder them to the board, and then drag everything back in…which was possible, but lead to amazingly snarled wires:


Second, I got hideous, awful, terrible, capacitive interference: my buttons were going off all the time, despite me not touching them. I tried a million things to fix this. I shortened my wires, I increased the button size, I soldered the buttons on, I tried conditioning the signals in software, and nothing worked. Then, at my wit’s end, I looked at the datasheet, and saw a NOISE_THRESH setting on the chip.


Turns out that all I had to do was increase that. Wups. That left me with slightly unresponsive buttons, but that was much better than an instrument that would randomly start playing twelve-tone music.

The synthesis was done using the Mozzi library. Mozzi was a dream to work with.  It took this poor Python hacker a bit of time to remember how to declare variables, but in general it worked well…until I tried to make it work with an amplifier. Turns out that I2C control with wire.h is a blocking call. This means that my speaker, which was running at Mozzi’s 16K sample rate, was also stopping each time my I2C loop ran. This manifested itself as a low square wave buzz, which I had not heard until I added the amplifier to the the circuit. As much as I like square waves, having a loud ~400 Hz drone was not part of the project.

Lucky for me, a brave soul had written a non-blocking I2C library, and after some tweaking and cursing I got it to work. This resulted in ever slower response, as my touches could only be read when the Arduino was not bossing the speaker around.  It was, however, better than having no touches at all.

I need to thank Joseph Malloch, Avrum Grant, Ian Hattwick, Håckon Knutzen, and Marcello Giordino for all their help with making this work – I could not have built it without them.)

So how does it actually work, in practice?  Really well, actually.  The two ‘grips’ on either end are not quite big enough to hold easily, and the buttons are too close together to make holding it in the middle easy.  An additional grip in the middle, splitting the octave, might help, or simply making it larger and spreading the buttons out more.  It is also heavy:  holding it up for a long time gets tiring.


It does lend itself to a tai-chi-esq sort of rotation as the player goes looking for pitches, which is on the border of being idiosyncratic enough to make it its own thing.  It is not a tool for playing traditional melodies, at all.  Indeed, the buttons are a little too close together for me to easily play triads, though my hands fit nicely on 1-5-7 chords.  Again, a slightly larger layout might help.  It most certainly pushes people towards a particular playing style, which make me very happy.

In terms of the future, it was suggested that a better way to do it would be to use two Arduinos:  one for sensing and one for playback.  This is an excellent idea, though it was too difficult for me to implement at the time.  The insulation between the wires also needs oit be improved, which will allow for faster response times.

On the development side, extra sensors are tempting…but also open a huge can of worms.  What should be added?  Force sensing to get the dynamics of each touch?  The orientation of the tube?  And how should those be mapped?  While more sensors would lead to a more instrument-like device, the current controller is not without its simple charms.

However, it would be nice to be able to change which note is the lowest, or somehow reconfigure the ‘key’ of the device.  Being able to do that implies a fairly total redesign of the entire thing, but it would increase the musical potential while keeping the harpsichord-in-a-tube idea broadly the same.