Just Tuning In

Some resources for microtonality, just intonation, xenharmonic systems, being out of tune, and other tunings.


I’ve been thinking about microtonality and alternate tuning systems a bit recently. It’s not really my area of expertise but I’ve got a sense that an upcoming composition will need some understanding of Just Intonation. While I’ve read some Partch and Tenney in the past, and some Ben Johnston last year, I can’t say that I really understand it… or rather, I’m not sure I have a feeling for it as much as I’d like to. I need to re-read some things, certainly, but I wonder what I’ve missed in the past, or maybe I’ve been starting from the wrong point…

Given that I’m teaching a bit these days, I started thinking more about how I’d want to learn about microtonality if I were coming to it fresh… and what some of the useful resources might be useful for diving into this strange world of seemingly endless tuning systems. Now, I think listening is generally the route into an area like this, but I’m curious about how it’s explained and discussed, so I’m looking for books/readings/resources. I asked the hive lattice-mind:

I had a sense of some of the key touchstones (Helmholtz, Partch, Tenney) that would crop up, but then in the sprawling comment threads lots more interesting material started to turn up. I thought I might list them here to make it easier to find things. This is of course by no means a comprehensive list of where to start with microtonality, but, if you’re curious, it might give you a nudge to go and read some things:

Lawrence Dunn offers these:

(I’ve not had a chance to read through all of this yet, so recommendations are not necessarily endorsements.)

Thanks to everyone who got back to me with suggestions. (*deep breath* @frozenreeds, @DrPAlvarez, @wednesday_club, @moderncomp, @stephanmathieu, @l_a_dunn, @azzigotti, @swayzeroundhaus, @aaronhnahum, @chayaczernowin7, @rchrdbkrmuso, @michaelbegg, @fantasticdrfox, @mugloch, @heathen_specs, @larrygoves, @_anthonyvine_)


What did I miss? Obviously, this is a massive field of musical thinking, so there’s no reason to try and cover everything. But if there’s some really useful introductory resources, I’d love to know about them. If you have any more ideas of where to look, please send me a message or tweet at me and I’ll update this list. (You’ll note that these resources are white-male heavy… I’m also interested in hearing about writings from those outside this particular demographic if you know of any!)

Finally, I’ll leave the last word to my sage colleague, Scott Mc Laughlin:

Building a USB MIDI controller

Figure 1: A basic 6-button footswitch USB MIDI controller. LEDs show button state.
I’m working on some pieces at the moment that require some electronics to be triggered via footpedals in performance. The problem is that I don’t have any MIDI foot pedals, and those that exist are expensive or overkill or both. All I need is a simple, passive MIDI pedal, connectable via USB that can give me a bunch of footswitch triggers (and maybe more features down the road). So, I decided that I’d build my own, and thought that if I documented the (surprisingly easy) process, others might see how easy it is to get custom hardware controllers…

There are a few simple options out there. In the first instance, an Arduino would probably cut it. I could use the serial port, or run a MIDI library to get what I need. Arduino is simple to learn, but I didn’t really need all the extras (or the board size). A Teensy is a smaller, equally affordable, and in some cases, a more versatile microcontroller that gets used a lot in USB MIDI and Music Tech related projects. And there’s a handy MIDI library already out there. So I opted for a Teensy (v3.2).

I sourced a cheap aluminium box here (a nice diecast Hammond box would have been lovely and heavier duty, but they’re expensive. This (Takachi Electric Industrial, MB-14) was 5 quid). For my current purposes, I only need 4 switches, but I got carried away and cut holes for 6 — not realising that this narrows the footprint considerably, making this a tricky thing to trigger with shoes on. It’s also a real mess of wiring inside as a result. If I’d thought about it before, I would have limited the switches to 4. As they say: measure twice, cut once. Lesson learned.

Switches are simple momentary (not-latching) switches, with some LEDs for visual confirmation. Below is a quick breadboard mock-up of the setup:
Figure 2: A breadboard mock-up of the circuit (in the finished product, I skipped the breadboard and chained the ground on each component) [made with Fritzing]
Figure 3: I took the strain off of the Teensy’s USB port by adding a panel-mount USB cable. It also allows me to use a slightly heavier-duty USB-B-type connector, as opposed to the Teensy’s micro port.
The code for the Teensy is simple given Josh Nishikawa’s MIDI controller library available here (Note, that I’m interested in MIDI controller numbers/values, not MIDI notes, Teensy can handle regular notes without a library). I’m only using the Pushbutton, assigned as MIDI control numbers (20-25) as they’re typically unassigned. This could also be serial, or MIDI note numbers rather than controller number. The code is simple: when a footswitch is pushed, fire off a MIDI control value of 127, otherwise it’s zero. When the pedal goes down, the LED pin is also lit up. In Max, all I need to read this is a [ctlin], [pak] and a [route 20 21 22 23 24 25] and I’ve got my pedal triggers into Max (see .maxpat in my git below). Easy.

In the Arduino IDE (Teensy uses the Arduino IDE, just with an additional library. There’s a guide to getting started with it here), I wanted the MIDI device to show up with it’s own name, so use the {name.c} file to set that. Set your USB Type to ‘MIDI’ in the Tools menu, and set your Board to ‘Teensy 3.2’, upload all that to the board and you’re done! A cheap, custom MIDI controller…

Improvements:

  • We’re gonna need a bigger boat. The initial plan was to include jack sockets and a stereo TRS jack so that I could plug in keyboard sustain pedals and an expression pedal to read as MIDI controllers. The code is simple, but since I didn’t leave myself enough space in the box, they won’t fit now.
  • Push-and-hold. My Max patch takes care of held buttons for flexibility, but this could easily be programmed in at the MIDI device level. Currently, if a button is held for x seconds or more, it clears a buffer.
    • Writing in at the Teensy level would let me have LED feedback too (light flashes after x seconds). I suppose I could set this anyway, but without it linking directly to the Max value (via serial?) there’s little point.

Files:

String harmonics, multiphonics and partials map {Processing}

double-bass-E1-string-harmonics-snip

There is some excellent research on performance techniques over at CelloMap.com on a variety of subjects, but the area of most interest to me lately has been string multiphonics. A criminally overlooked and beautifully fragile technique.

It seems a slightly murky area (a lot folk-lore, hearsay, speculation), but an interesting one that I hope people continue to plug away at. The two best resources I’ve found so far are Ellen Fallowfield and Thomas Resch’s aforementioned Cello Map project, and Seth Josel and Ming Tsao’s excellent new book The Techniques of Guitar Playing (2014; Bärenreiter, pp.118-24). Both map out the location of their partials in similar ways. Despite the different instruments the authors address, we are ultimately just dealing with a vibrating string and as such should not be too difficult to figure out…

double-bass-E1-string-harmonics

A recent composition of mine, yet another example of the porousness of certain borders (score .pdf, 15mb) for solo double bass uses quite a few multiphonics, and as part of the composing process I created a little Processing script which uses the Cello Map scheme. The script allows one to calculate and map out (theoretical) partials for a string of any tuning (my piece was initially going to feature some evolving scordatura but this was written out early on).

The benefit of coding this out that you can quickly generate a partial map of any tuning and as many partials as you like (though by default this is capped at 15, past then it gets tricky to find what you’re looking for). This becomes pretty helpful when searching for and identifying clustered sounding partials within multiphonics. It is worth noting however, that this is all fairly theoretical, and that real-world physics may not play as nicely on your string of choice…

You can find the script on my GitHub page. The script requires Processing, a free, open-source programming language.

My thanks to the Cello Map project for doing all the hard work on this and many other subjects.

 

Piano harmonics calculator

piano harmonics calculator

Most likely of interest to no-one, I’ve knocked up a little spreadsheet to help calculate string harmonics on a prepared piano.

If you set the partial number, it gives you the sounding pitch. If you calibrate the string length, it gives you the node location.

Download the Excel .xlsx spreadsheet