Author: b0b

These two pieces were retuned to Bohlen=Pierce with the Melodyne 5 Editor. The first is a jazz piece I wrote on guitar as a teenager, reimagined in Band-in-a-Box with a trombone as the lead instrument. I wonder if an actual trombonist could play these notes.

---

The second is a sound collage based on Dennis C. Lee’s “Psi-seX 1”. Running these somewhat random noises through a musical scale filter makes a rather pleasant effect, in my opinion.

---

Here’s one way to adapt a standard 12-tone keyboard to play Bohlen-Pierce music. Some of the black keys are not used because the BP scale has fewer accidentals. The actual pitch reassignments must be done in software somehow.

 

I usually tune my steel guitars to D6/G (G B D F# A B D F#). The Bohlen-Pierce F Lambda tuning below uses the same string gauges with a BP fretboard designed by Andy DePaule.  I simply place the fretboard over the standard one and retune to play in BP.

If you use a Peterson Strobe HD tuner, you can install the BP tuning table from the “Uncategorized” list at petersontuners.com/sweeteners/shared.  That’s a lot easier than eyeballing the cents numbers on a traditional electronic tuner.

This Bohlen-Pierce arrangement of Terry Riley’s “In C” was realized on the musical hardware described in Rehearsal Room. It was performed by 13 identical algorithmic musicians known collectively as The Technical Academy. A characteristic feature of the ensemble is an indiscriminate fader controlled by a Markov chain on each voice. This is the third recording of the completed algorithm.

 

The notes of Terry Riley’s original score were remapped to Bohlen-Pierce notes in a slightly modified A Moll I mode; the B note would have mapped to BP’s J, but it was changed to Jb simply because Jb sounded better.  Riley’s C D E F F# G A Bb B becomes A B C D E F G H Jb. The work is titled “Not In C” because it’s based on this different scale.

Source code written in Ruby can be viewed at github.com/b0blee/TechAcademy.

Developing Ruby code to drive antique synths with MIDI pitch bend messages.  This is a Roland D-110 coupled to a Roland U-110.  Each MIDI channel can only play one note because MIDI pitch bend affects the whole channel.  The audio track is monotonous, but useful for ringing out the instruments.

This table demonstrates some of the logic behind the Lambda scale.  It shows the 17-limit just intonation (JI) intervals that are closest to the equally tempered Bohlen Pierce scale.  Notice that there are no close JI intervals for the F#, H#, and A# notes.  Also, melody fragments in the D E F G range are virtually equal tempered with respect to one another.

The original JI scale has accidentals that are beyond the 17 limit: C# is 25/21, F# is 75/49, H# is 49/25, and A# is 63/25. Using those ratios would bring the accidentals within 10 cents of the ET notes, but the ear gravitates towards ratios with lower denominators.  In any case, it’s good to avoid H# because of its proximity to the octave. 49/25 can’t compete with 2/1. Same with A# against a strong C – most listeners will hear it as a too-sharp 10th.

I acquired a nice little 17-key kalimba (thumb piano), and tuned it to BP with a Korg AT-1 chromatic tuner. It sounds real nice. Here’s a demo just fooling around with it:

 

17-key Kalimba BP Notes
(highest to lowest)

SuperCollider is an algorithmic music language that can be used to generate microtonal music. Here’s a quick example of random Bohlen-Pierce notes.

This is a tribute to the early music of Steve Reich. It was realized on the Sonic Pi, using the Bohlen-Pierce scale, equal tempered as MIDI notes.

 

Source code:

# Reichish Phase

tritave = 19.02 # a 3/2 tritave is 1902 cents, or 19.02 in MIDI
half = tritave / 13 # size of the BP half step in MIDI
whole = half * 2

a3 = 69 # MIDI 69 is A440
b3 = a3 + whole
c3 = b3 + half
d3 = c3 + whole
e3 = d3 + half
f3 = e3 + half
g3 = f3 + whole
h3 = g3 + half
j3 = h3 + whole
a4 = a3 + tritave

a2 = a3 - tritave
b2 = b3 - tritave
c2 = c3 - tritave
d2 = d3 - tritave
e2 = e3 - tritave
f2 = f3 - tritave
g2 = g3 - tritave
h2 = h3 - tritave
j2 = j3 - tritave

notes = (ring a2, a3, f2, c2, c3, h2, e2, e3, b2, g2, g3, d2, j2)

in_thread(name: :slower) do
use_synth :pretty_bell
for i in 0..326
print i
n = notes.tick
np = n / a4
play n, amp: 1.0 - np, pan: -np / 2
sleep rrand(0.298,0.302)
i +=1
end
end

in_thread(name: :faster) do
use_synth :pretty_bell
for i in 0..329
print i
n = notes.tick
np = n / a4
play n, amp: 1.0 - np, pan: np / 2
sleep rrand(0.294,0.3)
i +=1
end
end

Using a sampled A=440Hz piano note, I squished and stretched it to play a BP chromatic scale. Here it is juxtaposed against random MIDI BP notes using the Sonic Pi’s FM synth.

Code:

# Bohlen-Pierce notes

tritave = 19.02         # a 3/2 tritave is 1902 cents, or 19.02 in MIDI
half = tritave / 13     # size of the BP half step in MIDI
whole = half * 2

a = 69  # MIDI 69 is A440
b = a + whole
c = b + half
d = c + whole
e = d + half
f = e + half
g = f + whole
h = g + half
j = h + whole
a_ = a + tritave

bpScale = [a,b,c,d,e,f,g,h,j,a_]

exp = 3 ** (1.0/13)

# play random notes with FM synth

divs = [1.0/exp,exp,1] # divisors add random BP flavor for FM synth
in_thread do
  use_synth :fm
  for i in 0..48
    highN = bpScale.choose
    lowN = highN - tritave
    play highN, divisor: divs.choose, depth: 0.5, pan: 49/highN, amp: rrand(0.1,0.2), attack: rrand(0,0.01), sustain: 0.2, release: rrand(0.1,0.5)
    sleep 0.15
    play lowN,  divisor: divs.choose, depth: 0.7, pan: -34/lowN, amp: rrand(0.1,0.2), attack: rrand(0,0.01), sustain: 0.2, release: rrand(0.1,0.5)
    sleep 0.15
  end 
end

# play chromatic BP scale with sampled piano

speed = 5.0/9 # initial sample speed yields BP E note (JI) calculated from A=440Hz
for i in 1..36
  sample "~/Sonic Pi/piano-a440.wav", rate: speed, pan: speed - 1.5, amp: rrand(1.0/3,2.0/3)
  speed = i < 18 ? speed * exp : speed / exp
  sleep 0.4
end