Microtuning Function

Creations & Ideas
1

Hi,

I’m experimenting with microtuning and have the following code: [Update, I think I got it working!]

define :microTune do |note, isSample|
  # Bohlen–Pierce
  cents = (map a: 1316.74,
           as: 1463.05,
           b: 1609.35,  #! unmapped h: 1755.66 , j: 1901.96
           c: 0,
           cs: 146.30,
           d: 292.61,
           ds: 438.91,
           e: 585.22,
           f: 731.52,
           fs: 877.83,
           g: 1024.13,
           gs: 1170.44)[note]
  
  # 10 out of 13-tET
  cents2 = (map a: 1107.69,
            as: nil,
            b: nil,
            c: 0,
            cs: 184.61,
            d: 276.92,
            ds: 369.23,
            e: 553.84,
            f: 646.15,
            fs: 738.46,
            g: 923.07,
            gs: 1015.38)[note]
  
  # 12 out of 17-tET, chain of fifths
  cents3 = (map a: 847.05,
            as: 988.23,
            b: 1058.82,
            c: 0,
            cs: 70.58,
            d: 141.17,
            ds: 282.35,
            e: 352.94,
            f: 494.11,
            fs: 564.70,
            g: 635.29,
            gs: 776.47)[note]
  
  if isSample
    return (cents / 100) # Return pitch adjustment
  else
    return note + (cents / 100) # Return note with adjustment
  end
end

define :getPitchFromNote do |note, sampleBaseNote, fineTune|
  return note - sampleBaseNote + fineTune
end


live_loop :testNote do
  notes = (ring :c, :cs, :d, :ds, :e, :f, :fs, :g, :gs, :a) #, :as, :b)
  
  with_synth :chiplead do
    with_octave -1 do
      play microTune(notes.tick, false), amp: 1
    end
  end
  
  sleep 0.5
end


live_loop :testSample do
  s = :bass_dnb_f
  notes = (ring :c, :cs, :d, :ds, :e, :f, :fs, :g, :gs, :a) #, :as, :b)
  
  sample s, rpitch: (getPitchFromNote notes.tick, :f3, microTune(notes.look, true)), amp: 1
  
  sleep 0.5
end

Thanks,
Lee.

3

I’ve been studying this again recently and found out the above code is actually incorrect. The below appears to work correctly (if I compare it to the build-in meantone tuning).

define :micro_tune do |note, is_sample|
  # Meantone
  cents = (map c: 0,
           cs: 76.0-100,
           d: 193.2-200,
           ds: 310.3-300,
           eb: 310.3-300,
           e: 386.3-400,
           f: 503.4-500,
           fs: 579.5-600,
           g: 696.6-700,
           gs: 772.6-800,
           a: 889.7-900,
           as: 1006.8-1000,
           bb: 1006.8-1000,
           b: 1082.9-1100,
           r: 0)
  
  tuned_notes = []
  note_map = ""
  
  if !note.kind_of?(Array)
    note = [note]
  end
  
  note.each { |n|
    if n.length > 1
      chars = n.to_s.split("")
      chars.each { |c|
        if !(true if Float(c) rescue false)
          note_map += c.downcase
        end
      }
      
      note_map = note_map.to_s.to_sym
    else
      note_map = n.downcase.to_sym
    end
    
    tuned_notes.push(n + cents[note_map] / 100)
    if !is_sample
      note_map = ""
    end
  }
  
  if is_sample
    return cents[note_map] / 100
  else
    return tuned_notes
  end
end

12.times do
  notes = (ring :c4, :cs4, :d4, :ds4, :e4, :f4, :fs4, :g4, :gs4, :a4, :as4, :b4) 
  play micro_tune(notes.tick, false)  
  sleep 0.5
end
1 Like