167 lines
4.6 KiB
Python
167 lines
4.6 KiB
Python
from xmlrpc.client import TRANSPORT_ERROR
|
|
from chroma_case.Partition import Partition
|
|
from chroma_case.Note import Note
|
|
import asyncio
|
|
import sys
|
|
from mido import MidiFile
|
|
|
|
import board, neopixel
|
|
|
|
# on octave is 12
|
|
RATIO = float(sys.argv[2] if len(sys.argv) > 2 else 1)
|
|
OCTAVE = 5
|
|
OCTAVE_AMOUNT_KEYS = 12
|
|
TRANSPOSE_AMOUNT = OCTAVE_AMOUNT_KEYS * OCTAVE
|
|
|
|
pixels = neopixel.NeoPixel(board.D18, 20, brightness=0.01)
|
|
|
|
notePixels = { 'si': [19],
|
|
'la#': [18],
|
|
'la': [17],
|
|
'sol#':[15],
|
|
'sol':[13],
|
|
'fa#':[10],
|
|
'fa':[9],
|
|
'mi':[6],
|
|
're#':[5],
|
|
're':[3],
|
|
'do#':[1],
|
|
'do':[0]}
|
|
|
|
|
|
def hue_to_rgb(t1, t2, hue):
|
|
if hue < 0: hue += 6
|
|
if hue >= 6: hue -= 6
|
|
if hue < 1: return (t2 - t1) * hue + t1
|
|
if hue < 3: return t2
|
|
if hue < 4: return (t2 - t1) * (4 - hue) + t1
|
|
return t1
|
|
|
|
def hsl_to_rgb(hue, sat, light):
|
|
hue /= 60
|
|
if light <= 0.5:
|
|
t2 = light * (sat + 1)
|
|
else:
|
|
t2 = light + sat - (light * sat)
|
|
t1 = light * 2 - t2
|
|
|
|
r = hue_to_rgb(t1, t2, hue + 2) * 255
|
|
g = hue_to_rgb(t1, t2, hue) * 255
|
|
b = hue_to_rgb(t1, t2, hue - 2) * 255
|
|
return [round(r), round(g), round(b)]
|
|
|
|
async def to_chroma_case(data):
|
|
global pixels
|
|
|
|
hsl_starting_color = [100, 100, 50]
|
|
|
|
colored_pixels = notePixels[data["key"].lower()]
|
|
#if "announce" in data:
|
|
c = data["color"]
|
|
"""for i in range(5):
|
|
for pixelId in colored_pixels:
|
|
pixels[pixelId] = (c[0], int(c[1] * tmp), c[2])
|
|
tmp -= 0.2
|
|
await asyncio.sleep(data["duration"] / (5 * 1000))"""
|
|
"""for i in range(11):
|
|
for pixelId in colored_pixels:
|
|
pixels[pixelId] = hsl_to_rgb(hsl_starting_color[0], hsl_starting_color[1], hsl_starting_color[2])
|
|
hsl_starting_color[2] += 0.01
|
|
await asyncio.sleep(0.01)"""
|
|
for pixelId in colored_pixels:
|
|
pixels[pixelId] = data["color"]
|
|
await asyncio.sleep(data['duration'] / 1000)
|
|
for pixelId in colored_pixels:
|
|
pixels[pixelId] = 0
|
|
|
|
|
|
async def printing(data):
|
|
print(f"key: {data['key']}, c:{data['color']} for {data['duration'] / 1000}s, time: {data['time']}")
|
|
await asyncio.sleep(data['duration'] / 1000)
|
|
print(f"end of {data['key']}")
|
|
|
|
|
|
def midi_key_my_key(midi_key):
|
|
keys = list(notePixels.keys())
|
|
|
|
keys.reverse()
|
|
|
|
key_index = midi_key - TRANSPOSE_AMOUNT
|
|
if key_index >= len(keys):
|
|
print("key out of leb barre", key_index)
|
|
return "no_key"
|
|
|
|
return keys[key_index]
|
|
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
default_duration = 900
|
|
default_color = (255, 0, 0)
|
|
|
|
notes = []
|
|
# notes will start to play at 3500 ms (colors at the start takes this amount of time)
|
|
s = 3500
|
|
|
|
notes_on = {}
|
|
prev_note_on = {}
|
|
note_color = {}
|
|
|
|
for msg in MidiFile(sys.argv[1]):
|
|
d = msg.dict()
|
|
print(msg, s)
|
|
s += d['time'] * 1000 * RATIO
|
|
|
|
if d["type"] == "note_on":
|
|
prev_note_on[d["note"]] = 0
|
|
if d["note"] in notes_on:
|
|
prev_note_on[d["note"]] = notes_on[d["note"]] # 500
|
|
notes_on[d["note"]] = s # 0
|
|
if d["note"] not in note_color.keys():
|
|
note_color[d["note"]] = 1
|
|
note_color[d["note"]] = not note_color[d["note"]]
|
|
|
|
if d["type"] == "note_off":
|
|
#duration = s - notes_on[d["note"]]
|
|
duration = s - notes_on[d["note"]]
|
|
|
|
"""notes.append(Note(
|
|
s - min(s - prev_note_on[d["note"]], 500),
|
|
{
|
|
"duration": min(s - prev_note_on[d["note"]], 1000) / 2,
|
|
"color": (255, 255, 0),
|
|
"key": midi_key_my_key(d["note"]),
|
|
"announce": True
|
|
}
|
|
))"""
|
|
|
|
note_start = notes_on[d["note"]]
|
|
# time value is only used during debug
|
|
notes.append(Note(note_start, {"time": note_start, "duration": duration - 10, "color": default_color if note_color[d["note"]] else (255, 100, 0), "key": midi_key_my_key(d["note"])}))
|
|
notes_on[d["note"]] = s # 500
|
|
|
|
|
|
|
|
starting = []
|
|
|
|
for i in notePixels.keys():
|
|
starting += [
|
|
Note(000, {"duration": default_duration, "color": (255, 0, 0), "key": i, "time": 0}),
|
|
Note(1000, {"duration": default_duration, "color": (255, 255, 0), "key": i, "time": 0}),
|
|
Note(2000, {"duration": default_duration, "color": (0, 255, 0), "key": i, "time": 0}),
|
|
]
|
|
|
|
p = Partition("my_partition",
|
|
starting + notes
|
|
)
|
|
|
|
await p.play(to_chroma_case)
|
|
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(asyncio.run(main()))
|