Looks Like a New Project Coming Up

17 06 2012

So this is a little different subject.

In my life away from Agile software development, one of the things I do is play the electric bass.  Not particularly well, but it’s something I enjoy.  My favorite bass has six strings and no frets.

Since I’m a computer geek, though, I’ve been playing around with MIDI for years.

So for quite some time, I’ve been developing a blue-sky fantasy about a fretless stringed MIDI controller–that is, something that would have a user interface similar to that of a fretless bass (but better, because it wouldn’t have to tolerate certain physical realities that actual fretless basses do) and would allow the player to control a synthesizer.

One thing that any MIDI controller must be able to do is determine what pitch the user wishes it to direct the synth to play.  I’ve been able to find two different methods by which this is done by existing guitar-shaped MIDI controllers (EGSMCs).

The most common way is to use a real electric guitar with real guitar strings and a real pickup feeding a real note into an analog-to-digital converter and running a pitch-extraction algorithm on the resulting stream of samples. I don’t like this way because of the unavoidable inherent latency.  You have to identify the attack transient and wait for it to pass; then you have to identify at least two clean cycles of the actual note after it has begun to ring; then you have to do a Fourier transform to find the fundamental frequency; then you have to convert it into (at least) a three-byte MIDI message; then you have to transmit it over a serial link at just over 3000BPS; then the synthesizer has to initiate the note.  Even with a lot of processing power, that can be 50-60ms of latency or even more, especially with low-frequency notes.  It’s hard to play decent music when you have to wait that long after playing a note before hearing it.

The other way I’ve seen is to use a series of switches, one for each fret/string combination, that the player depresses in much the same way he’d press a string against a fret on a real instrument.  This provides considerably less latency, because the entire pitch-extraction computation is eliminated; but it doesn’t lend itself to fretlessness.

I’d like to see a MIDI controller that determined which MIDI note number it would send exclusively  by position rather than pitch, like the discrete-switch solution, but in which the position measurement would be continuous rather than discrete, so that if you wanted to you could send MIDI pitch-wheel messages as well as note-on messages.

If you could do this, one of the coolnesses that would result would be that note spacing would be entirely soft.

On a real stringed instrument, the note positions, whether fretted or not, are significantly further apart near the head (the small end of the guitar that usually has the tuning keys on it) than they are near the bridge.  This has two tradeoff effects, at least for a fretless instrument.  First, playing quickly is more difficult near the head, because one’s fingers have to span a much larger physical distance, meaning more hand movement.  Second, playing with good intonation (that is, in tune) is more difficult near the bridge, where a half-step interval might be less than half an inch wide, making the positional tolerances very small.

Also on a real stringed instrument, the available pitch range is determined in a minor way by the number of strings, but in a major way by the length of the fingerboard in relation to the strings.  Is the fingerboard half the length of the strings?  Then you can play an octave on each string.  Three-quarters the length of the strings?  Then you can play two octaves.  Want three octaves?  Then you need seven-eighths of the string length underlaid by fingerboard, meaning that the notes are extremely close together for that last octave, and there is very little room between the end of the fingerboard and the bridge for pickup electronics, and usually the body of the instrument has to be mutilated to allow the player’s hand to get to that last octave.  Four octaves?  Forget it.

On a MIDI controller that depended on position rather than pitch to determine note number, you could:

  • define whatever length of fingerboard you had to hold whatever number of notes you wanted it to;
  • space those notes however you wanted, with no regard for the physics of a vibrating string; and
  • map position to note number in whatever way you liked–specifically, you could round a fingered position up to the next note, the way a fret does, if you wanted to simulate frets.

You could make different definitions for each string, if you wanted, enabling simulation of a five-string banjo with its fifth short string.  You could do diatonic quantization, like a mountain dulcimer, where the frets are irregularly spaced to prevent playing non-scale notes.  You could space the notes uniformly from one end to the other, so finger spacing was always the same.  You could make some of the strings “fretted” and not the others, or you could make some or all of the strings “fretted” in some places and not in others.

You could set up several of these different arrangements and impose them successively in the course of a single song, if you wanted to, with simple MIDI program-change messages.

So being able to sense continuous position admits a host of wonderful possibilities; but how do we sense it?

Well, I’ve been thinking about that.

Advertisements

Actions

Information

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s




%d bloggers like this: