aboutsummaryrefslogtreecommitdiff
path: root/intervals.lua
diff options
context:
space:
mode:
Diffstat (limited to 'intervals.lua')
-rw-r--r--intervals.lua489
1 files changed, 489 insertions, 0 deletions
diff --git a/intervals.lua b/intervals.lua
new file mode 100644
index 0000000..b29c5c9
--- /dev/null
+++ b/intervals.lua
@@ -0,0 +1,489 @@
+-- interval ear training
+--
+-- hear two notes;
+-- play two notes
+--
+-- enc2: repeat
+-- enc3: skip
+--
+-- to do:
+-- 1) keep a score
+-- 2) select scales
+-- 3) select base tone
+-- 4) key signatures
+-- 5) play from input
+
+-- graphics and audio utilities
+function midi_to_hz(note)
+ local hz = (440 / 32) * (2 ^ ((note - 9) / 12))
+ return hz
+end
+
+function interval_name(base, interval)
+ t = {
+ "unison",
+ "minor second",
+ "major second",
+ "minor third",
+ "major third",
+ "perfect fourth",
+ "diminished fifth",
+ "perfect fifth",
+ "minor sixth",
+ "major sixth",
+ "minor seventh",
+ "major seventh",
+ "octave"
+ }
+ return t[interval - base + 1]
+end
+
+function blit(x, y, bitmap, p)
+ for i=1,#bitmap do
+ for j=1,#bitmap[i] do
+ local level = bitmap[i][j]
+ if p and p.brightness then
+ level = level * p.brightness
+ else
+ level = level * 10
+ end
+ if level > 0 then
+ screen.level(math.floor(level))
+ screen.pixel(x + j, y + i)
+ screen.fill()
+
+ end
+ end
+ end
+end
+
+function blit_center(x, y, sprite, p)
+ local offset_before = sprite.offset_before or #sprite.data[1] / 2
+ local offset_above = sprite.offset_above or #sprite.data / 2
+ blit(x - offset_before, y - offset_above, sprite.data, p)
+end
+
+local quarter_sprite = {
+ data={
+ { 0, 0, 0, 0, 1, 0, 0},
+ { 0, 0, 0, 0, 1, 0, 0},
+ { 0, 0, 0, 0, 1, 0, 0},
+ { 0, 0, 0, 0, 1, 0, 0},
+ { 0, 0, 0, 0, 1, 0, 0},
+ { 0, 0, 0, 0, 1, 0, 0},
+ { 0, 1, 1, 1, 1, 0, 0},
+ { 1, 1, 1, 1, 1, 0, 0},
+ { 0, 1, 1, 1, 0, 0, 0},
+ },
+ -- metadata to center properly
+ offset_before=2,
+ offset_above=8
+}
+
+local sharp_sprite = {
+ data = {
+ { 0, 1, 0, 1, 0 },
+ { 1, 1, 1, 1, 1 },
+ { 0, 1, 0, 1, 0 },
+ { 1, 1, 1, 1, 1 },
+ { 0, 1, 0, 1, 0 }
+ }
+}
+
+local flat_sprite = {
+ data = {
+ { 1, 0, 0, 0},
+ { 1, 0, 0, 0},
+ { 1, 1, 1, 0},
+ { 1, 0, 1, 0},
+ { 1, 1, 0, 0}
+ }
+}
+-- parameters:
+-- p.y: offset from the top
+-- p.margin: distance from the side (since it's all centered)
+-- p.notes: all quarter notes for now
+function staff (p)
+ local x_start = p.margin;
+ local x_end = 128 - p.margin
+ local width = 128 - p.margin * 2
+
+ screen.level(1)
+ for i=0,4 do
+ for j=x_start,x_end do
+ screen.pixel(j, p.y + 5 * i)
+ end
+ end
+ screen.fill()
+
+ for i=1,#p.notes do
+ -- adjust for lines drawn
+ local bottom_y = p.y + 20
+ -- offset for this particular note
+ local y = math.ceil(bottom_y - 2.5 * p.notes[i].place)
+
+ -- evenly distribute along the x-axis
+ local total_x = 128 - p.margin * 2
+ local each_x = total_x / #p.notes
+ local x = x_start + each_x * (i - 1) + each_x / 2
+
+ -- draw the broken staff line, if it's out of range
+ if y > bottom_y or y < p.y then
+ screen.level(1) -- todo p.brightness
+ screen.move(x - quarter_sprite.offset_before - 1, y + 1)
+ screen.line(x + #quarter_sprite.data[1] - 1, y + 1)
+ screen.stroke()
+ end
+
+ if p.notes[i].accidental > 0 then
+ blit_center(x - 6, y, sharp_sprite, p.notes[i])
+ elseif p.notes[i].accidental < 0 then
+ blit_center(x - 6, y, flat_sprite, p.notes[i])
+ end
+
+ -- draw the note
+ blit_center(x, y, quarter_sprite, p.notes[i])
+ end
+end
+
+-- todo could probably do this more nicely
+function c_major_treble(midi_note)
+ local scale = {
+ -- c / c#
+ [60]={place=-2, accidental=0},
+ [61]={place=-2, accidental=1},
+ -- d / d#
+ [62]={place=-1, accidental=0},
+ [63]={place=-1, accidental=1},
+ -- e
+ [64]={place=0, accidental=0},
+ -- f / f#
+ [65]={place=1, accidental=0},
+ [66]={place=1, accidental=1},
+ -- g / g#
+ [67]={place=2, accidental=0},
+ [68]={place=2, accidental=1},
+ -- a / a#
+ [69]={place=3, accidental=0},
+ [70]={place=3, accidental=1},
+ -- b
+ [71]={place=4, accidental=0},
+ -- c
+ [72]={place=5, accidental=0},
+ }
+ return scale[midi_note]
+end
+
+-- little mode library...
+-- a mode is a thing with fields for enc, redraw, and key
+-- it can edit the state
+function state_call(state, name, args)
+ if state.stack[#state.stack] then
+ local fn = state.stack[#state.stack][name]
+ if fn then
+ local ret = fn(table.unpack(args or {}))
+ if ret then
+ ret(state)
+ end
+ end
+ else
+ print("empty state?")
+ end
+end
+
+function state_init(state)
+ -- destroy old timer, create a new one.
+ -- we need to do this because e.g. if we transition
+ -- to the next screen halfway between 1 and 2, then we'll
+ -- pause for half a second less than we ought to.
+ if state.timer then
+ state.timer:stop()
+ metro.free(state.timer.id)
+ end
+ state.timer = metro.init()
+ state.timer.time = state.tick_interval or 1.0
+ state.timer.event = function(t)
+ state_call(state, "tick", {t})
+ end
+ state_call(state, "init")
+ state.timer:start()
+end
+
+function state_redraw(state)
+ state_call(state, "redraw")
+end
+
+function pop(state)
+ table.remove(state.stack)
+ state_init(state)
+end
+
+function pop_n(n)
+ return function (state)
+ if state.timer then
+ state.timer:stop()
+ end
+ for i=1,n,1 do
+ table.remove(state.stack)
+ end
+ state_init(state)
+ end
+end
+
+function replace(modes)
+ return function (state)
+ top = table.remove(state.stack)
+ push(modes)(state)
+ end
+end
+
+function push(modes)
+ return function (state)
+ for i=1,#modes do
+ table.insert(state.stack, modes[i])
+ end
+ state_init(state)
+ end
+end
+
+-- end mode library
+
+engine.name = 'PolyPerc'
+function play(hz)
+ engine.hz(hz)
+end
+
+
+function message (msgs, tick_fn, midi_fn)
+ return {
+ init = function ()
+ return state_redraw
+ end,
+ redraw=function ()
+ screen.clear()
+ local total_height = 10 * #msgs
+ local y = (64 - total_height) / 2
+ local x = 64
+ for i=1,#msgs do
+ screen.move(x, y + 10 * (i - 1) + 5)
+ screen.text_center(msgs[i])
+ end
+ screen.update()
+ end,
+ key=function (n, x)
+ if n == 3 and x == 0 then
+ return pop
+ end
+ end,
+ tick=function(t)
+ if tick_fn then
+ return tick_fn(t)
+ end
+ end,
+ midi=function(ev)
+ if midi_fn then
+ return midi_fn(ev)
+ end
+ end
+ }
+end
+
+function correct_guess(known, guess)
+ return {
+ init=function ()
+ return state_redraw
+ end,
+ redraw=function()
+ local known_note = c_major_treble(known)
+ known_note.brightness = 10
+ local guess_note = c_major_treble(guess)
+ guess_note.brightness = 10
+ staff({y=20, margin=5, notes={
+ known_note, guess_note
+ }})
+ screen.move(64, 10)
+ screen.text_center(interval_name(known, guess))
+ screen.update()
+ end,
+ key=function(n, x)
+ if n == 3 and x == 0 then
+ return pop
+ end
+ end,
+ tick = function()
+ return pop
+ end
+ }
+end
+
+function play_and_wait_3 (known, guess)
+ return {
+ init=function ()
+ return state_redraw
+ end,
+ redraw=function()
+ screen.clear()
+ local known_note = c_major_treble(known)
+ known_note.brightness = 10
+ staff({y=20, margin=5, notes={
+ known_note,
+ {place=0,accidental=0, brightness=0}
+ }})
+ screen.update()
+ end,
+ key=function(n, x)
+ if n == 3 and x == 0 then
+ return pop
+ end
+ end,
+ midi=function(ev)
+ if ev.type == "note_on" and ev.note == guess then
+ return pop
+ end
+ end
+ }
+end
+
+function play_and_wait_2 (known, guess)
+ return {
+ init=function ()
+ play(midi_to_hz(guess))
+ return state_redraw
+ end,
+ redraw=function()
+ screen.clear()
+ local known_note = c_major_treble(known)
+ known_note.brightness = 5
+ staff({y=20, margin=5, notes={
+ known_note,
+ {place=0,accidental=0, brightness=0}
+ }})
+ screen.update()
+ end,
+ key=function(n, x)
+ -- forward button
+ if n == 3 and x == 0 then
+ return pop_n(2)
+ end
+ -- back button
+ if n == 2 and x == 0 then
+ return push({play_and_wait_1(known, guess)})
+ end
+ end,
+ midi=function(ev)
+ if ev.type == "note_on" and ev.note == known then
+ return pop
+ end
+ end
+ }
+end
+
+function play_and_wait_1 (midi_note)
+ complete = nil
+ return {
+ init=function ()
+ play(midi_to_hz(midi_note))
+ return state_redraw
+ end,
+ redraw=function()
+ screen.clear()
+ local known_note = c_major_treble(midi_note)
+ known_note.brightness = 5
+ staff({y=20, margin=5, notes={
+ known_note,
+ {place=0,accidental=0, brightness=0}
+ }})
+ screen.update()
+ end,
+ tick=function()
+ return pop
+ end,
+ key=function(n, x)
+ -- forward button
+ if n == 3 and x == 0 then
+ return pop_n(3)
+ end
+ -- back button
+ if n == 2 and x == 0 then
+ print("back on 1")
+ return replace({play_and_wait_1(midi_note)})
+ end
+ end,
+ }
+end
+
+function choose_interval ()
+ return {
+ init=function ()
+
+ local guess = math.random(60, 72)
+ return push({
+ correct_guess(60, guess),
+ play_and_wait_3(60, guess),
+ play_and_wait_2(60, guess),
+ play_and_wait_1(60)
+ })
+ end
+ }
+end
+
+-- drawing, state, etc
+intervals_state = {
+ stack = {
+ choose_interval(),
+ message({
+ "first I'll play middle c.",
+ "then a random major interval.",
+ "play both notes back",
+ "as best as you can"},
+ function (t)
+ if t > 2 then
+ return pop
+ end
+ end),
+ message({"yay."},
+ function ()
+ return pop
+ end),
+ message({
+ "plug in a midi keyboard",
+ "and give me a middle c."
+ },
+ nil,
+ function (ev)
+ if ev.type == "note_on" and ev.note == 60 then
+ return pop
+ end
+ end)
+ },
+}
+
+function init()
+ play(midi_to_hz(60))
+ -- initialize midi
+ m = midi.connect()
+ m.event = function (a)
+ b = midi.to_msg(a)
+ -- monitor
+ if b.type == "note_on" then
+ play(midi_to_hz(b.note))
+ end
+ state_call(intervals_state, "midi", {b})
+ end
+end
+
+function cleanup()
+ intervals_state.timer:stop()
+end
+
+function redraw()
+ screen.clear()
+ screen.aa(0)
+ screen.line_width(1)
+
+ state_call(intervals_state, "redraw")
+end
+
+function key(n, x)
+ state_call(intervals_state, "key", {n, x})
+end
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-21 21:52:15 +0000