def send(self, msg, toPortProxy):
if msg.type == 'control_change' and (
20 <= msg.control and msg.control <= 22) and msg.value == 127:
# Change the key priority
key_priority = int(msg.control) - 20
byte_list = [
0xF0, 0x00, 0x20, 0x32, 0x00, 0x7F, 0x0A, 0x01, 0x00,
key_priority, 0xF7
]
# print byte_list
toPortProxy.send(mido.parse(byte_list))
return
if msg.type == 'control_change' and (
28 <= msg.control and msg.control <= 29) and msg.value == 127:
# Change multi trigger option
multi_trigger = int(msg.control) - 28
byte_list = [
0xF0, 0x00, 0x20, 0x32, 0x00, 0x7F, 0x0A, 0x02, 0x00,
multi_trigger, 0xF7
]
# print byte_list
toPortProxy.send(mido.parse(byte_list))
return
# print msg
toPortProxy.send(msg)
def readEWI():
try:
os.remove(EWIDATAFILE)
except:
if PRINT: print "file already deleted"
if PRINT: print "Reading EWI via USB..."
# send "enable" request
USBOUTPORT.send(mido.parse([0xB0, 0x63, 0x01]))
USBOUTPORT.send(mido.parse([0xB0, 0x62, 0x04]))
USBOUTPORT.send(mido.parse([0xB0, 0x06, 0x20]))
time.sleep(0.2)
# request bank 0 data
USBOUTPORT.send(mido.Message('sysex', data=[71, 127, 109, 64, 0, 0]))
time.sleep(0.2)
# send "enable" request
USBOUTPORT.send(mido.parse([0xB0, 0x63, 0x01]))
USBOUTPORT.send(mido.parse([0xB0, 0x62, 0x04]))
USBOUTPORT.send(mido.parse([0xB0, 0x06, 0x20]))
time.sleep(0.2)
# request bank 2 data
USBOUTPORT.send(mido.Message('sysex', data=[71, 127, 109, 66, 0, 0]))
time.sleep(0.2)
# send "finished" request
USBOUTPORT.send(mido.parse([0xB0, 0x63, 0x01]))
USBOUTPORT.send(mido.parse([0xB0, 0x62, 0x04]))
USBOUTPORT.send(mido.parse([0xB0, 0x06, 0x10]))
return
def send(self, msg, toPortProxy):
# print msg
if msg.type == 'note_on' or msg.type == 'note_off' or msg.type == 'aftertouch':
msg.channel = self.part
if msg.type == 'control_change' and msg.control == 123:
self.part = int(msg.channel)
return
if msg.type == 'control_change' and msg.control == 0:
# Bank select MSB
# Novation controller always sends MSB = 0
# Swallow this message
return
if msg.type == 'control_change' and msg.control == 32:
# Bank select LSB
# Novation controller sends LSB in range 0..127
# print "Bank LSB = " + str(msg.value)
(program, bank_lsb) = self.xg.lookup(self.program_group, msg.value)
# print "(program, bank_lsb) = " + str(program) + ", " + str(bank_lsb)
msg = mido.Message('control_change',
channel=self.part,
control=0,
value=0)
toPortProxy.send(msg)
msg = mido.Message('control_change',
channel=self.part,
control=32,
value=bank_lsb)
toPortProxy.send(msg)
msg = mido.Message('program_change',
channel=self.part,
program=program)
toPortProxy.send(msg)
return
if msg.hex().startswith('F0 43 10 4C 08'):
# Sysex messages for controlling QY100 parts
byte_list = msg.bytes()
byte_list[5] = self.part
if byte_list[6] == 3:
# Part program change (Sysex) message
# detect special values for changing program group
data = byte_list[7]
if data % 8 == 0:
self.program_group = data / 8
msg = mido.parse(byte_list)
if msg.type == 'program_change':
byte_list = msg.bytes()
byte_list[1] = self.program_group * 8 + byte_list[1] % 8
msg = mido.parse(byte_list)
toPortProxy.send(msg)
def map(self, msg):
if msg.type == 'control_change':
cc = int(msg.control)
chan = int(msg.channel)
value = int(msg.value)
if cc in self.cc_to_note:
note = self.cc_to_note[cc]
if value == 127:
# 127 => Note on
byte_list = [0x90 | chan, note, 100]
msg = mido.parse(byte_list)
else:
# 0 => Note off
byte_list = [0x80 | chan, note, 100]
msg = mido.parse(byte_list)
return msg
def callback(self, event, _):
event, _ = event
event = mido.parse(event)
print(event)
frame = self.compositor.new_frame()
if event.type == 'control_change' and event.value == 0:
if event.control == 102:
self.led_index += 1
if event.control == 103:
self.led_index -= 1
if event.control == 51:
self.save_mapping()
self.m[self.key] = self.led_index
frame.effect_manager.spawn_led_selection_effects(
self.led_index, palette=compositor.YELLOWS)
if event.type != 'note_on':
return
self.key = event.note
self.led_index = self.m[self.key]
frame.effect_manager.spawn_led_selection_effects(
self.m[self.key], palette=compositor.GREENS)
wire_event = frame.as_state_event()
payload = wire_event.serialize().encode()
print("payload", payload)
self.s.sendall(payload)
def MIDI_packet_process(run_event):
while run_event.is_set():
MIDIread = mido.parse(MIDI_readqueue.get())
if MIDIread.type == "control_change": #Only responds to CC messages for now
Type = MIDIread.type
Channel = MIDIread.channel
Control = MIDIread.control
CC_value = MIDIread.value
for i in range(len(Message_type)
): #Could be any variable from this array really
if (Message_type[i]
== Type) and (Channel_number[i] == Channel) and (
CC_number[i]
== Control) and (Value_on[i]
== CC_value) and (Effect_state[i]
== False):
#If this effect is off and being turned on through MIDI
Toggle_effect(i)
elif (Message_type[i]
== Type) and (Channel_number[i] == Channel) and (
CC_number[i]
== Control) and (Value_off[i]
== CC_value) and (Effect_state[i]
== True):
#If this effect is on and being turned off through MIDI
Toggle_effect(i)
def message_from_oscmidipayload(bites):
"""Convert the last 4 OSC-midi bytes into a mido message.
"""
bites = bites[0][::-1][0:4]
msg = mido.parse(bites)
log.debug("Midi message to send is {}".format(msg))
return msg
def test_encode_and_parse(self):
"""Encode a message and then parse it.
Should return the same message.
"""
msg1 = Message('note_on')
msg2 = mido.parse(msg1.bytes())
self.assertTrue(msg1 == msg2)
def make_message(command_id, address, data_or_size):
the_bytes = [0xF0, 0x41, 0x10, 0x6A] \
+ [command_id] \
+ address \
+ data_or_size \
+ [int(checksum(address, data_or_size), 16)] \
+ [0xF7]
return mido.parse(the_bytes)
def process(frames):
global offset, i
global msg
global syx_iter
global controller_map, patch_no, vals, latent
port.clear_buffer()
needs_update = False
for offset, data in inport.incoming_midi_events():
msg = mido.parse(bytes(data))
if msg.type == 'note_on':
port.write_midi_event(
0,
mido.Message('control_change', control=123).bytes())
if msg.type != 'control_change':
continue
if msg.control not in controller_map:
if len(controller_map) == 8:
continue
print(f"latent {len(controller_map)} set to encoder {msg.control}")
controller_map[msg.control] = len(controller_map)
l_i = list(controller_map).index(msg.control)
print(f'Latent: {latent}')
latent[:, controller_map[msg.control]] = msg.value
needs_update = True
# print("{0}: 0x{1}".format(client.last_frame_time + offset,
# binascii.hexlify(data).decode()))
# print(time.time()-offset)
inport.clear_buffer()
if (needs_update):
offset = time.time()
z = vals.gather(0, latent)
msg = model.generate(z, t=0.001).sample()
msg = DX7Single.to_syx(msg.numpy().tolist())
port.write_midi_event(1, msg.bytes())
mido.write_syx_file('example_single_voice.mid', [msg])
def main():
device = '/dev/ttyACM0'
with mido.open_output('MiniX1', client_name='MiniX1',
virtual=True) as output:
found_device = True
while True:
try:
connection = None
try:
connection = serial.Serial(device,
115200,
timeout=1,
exclusive=True)
except serial.SerialException as e:
if found_device == True:
print("Could not find device ", device,
". Please connect it")
found_device = False
continue
except Exception as e:
printException(e)
connection.close()
print("Opened device", device)
found_device = True
try:
while True:
buf = connection.read(3)
if len(buf) != 3:
continue
message = mido.parse(buf)
print("[MIDI]", message)
print("[MIDI]", message.hex())
output.send(message)
except Exception as e:
printException(e)
connection.close()
except Exception as e:
printException(e)
def make_b00_file(self):
new_add_syx_0 = [0xF0, 0x43, 0x10, 0x4C, 0x00, 0x00, 0x7E, 0x00, 0xF7]
new_add_syx_1 = [0xF0, 0x43, 0x70, 0x70, 0x73, 0xF7]
send_request = [0xF0, 0x43, 0x70, 0x78, 0x20, 0xF7]
send_bank = [
0xF0, 0x43, 0x70, 0x78, 0x44, 0x7e, 0x00, 0x00, 0x00, 0xF7
]
save_forbidden = [
0xF0, 0x43, 0x70, 0x78, 0x44, 0x7e, 0x00, 0x02, 0x01, 0xF7
]
cancel_forbidden = [
0xF0, 0x43, 0x70, 0x78, 0x44, 0x7e, 0x00, 0x02, 0x00, 0xF7
]
midi_new_add_syx0 = mido.parse(new_add_syx_0)
midi_new_add_syx1 = mido.parse(new_add_syx_1)
midi_cancel_forbidden = mido.parse(cancel_forbidden)
midi_save_forbidden = mido.parse(save_forbidden)
midi_send_request = mido.parse(send_request)
midi_send_boo = self.dump_b00()
midi_send_bank = mido.parse(send_bank)
file_path = self.save_path
messages = [
midi_new_add_syx0,
midi_new_add_syx1,
midi_cancel_forbidden,
midi_save_forbidden,
midi_send_request,
midi_send_boo,
midi_send_bank,
]
file_upload = UploadFile()
file_upload.mkdir_temp(self.dir_name)
mido.write_syx_file(file_path, messages)
fname, fpath = file_upload.oss_upload(self.name_path, file_path)
file_upload.remove_temp(self.dir_name)
self.sql_path = fpath
return self.sql_path
def send(self, msg, toPortProxy):
# print msg
if msg.type != 'control_change':
# Pass through by default, for non-CC messages
toPortProxy.send(msg)
return
if msg.type == 'control_change' and (int(msg.value) - 64) == 0:
# Zero increment => do nothing!
return
if msg.type == 'control_change' and ((msg.control >= 102
and msg.control <= 115)):
knob_index = int(msg.control) - 102
chan = int(msg.channel)
sysex_code = self.sysex_codes[knob_index]
value_list = self.value_list_allchannels[chan]
new_val = self.increment_value(value_list[knob_index],
int(msg.value) - 64)
value_list[knob_index] = new_val
byte_list = [
0xF0, 0x43, 0x10, 0x4c, 0x08, chan, sysex_code, new_val, 0xF7
]
# print byte_list
toPortProxy.send(mido.parse(byte_list))
return
if msg.type == 'control_change' and msg.control == 116:
knob_index = int(msg.control) - 102
chan = int(msg.channel)
value_list = self.value_list_allchannels[chan]
# Program
program_group = self.increment_value(value_list[knob_index],
int(msg.value) - 64,
max_val=15)
value_list[knob_index] = program_group
# Reset the Bank LSB to zero also
value_list[knob_index + 1] = 0
msg = mido.Message('control_change',
channel=chan,
control=0,
value=0)
toPortProxy.send(msg)
msg = mido.Message('control_change',
channel=chan,
control=32,
value=0)
toPortProxy.send(msg)
msg = mido.Message('program_change',
channel=chan,
program=program_group * 8)
toPortProxy.send(msg)
return
if msg.type == 'control_change' and msg.control == 117:
knob_index = int(msg.control) - 102
chan = int(msg.channel)
value_list = self.value_list_allchannels[chan]
# Bank select LSB
program_group = value_list[knob_index - 1]
group_len = self.xg.program_group_len(program_group)
new_val = self.increment_value(value_list[knob_index],
int(msg.value) - 64,
max_val=group_len - 1)
value_list[knob_index] = new_val
(program, bank_lsb) = self.xg.lookup(program_group, new_val)
# print "(program, bank_lsb) = " + str(program) + ", " + str(bank_lsb)
msg = mido.Message('control_change',
channel=chan,
control=0,
value=0)
toPortProxy.send(msg)
msg = mido.Message('control_change',
channel=chan,
control=32,
value=bank_lsb)
toPortProxy.send(msg)
msg = mido.Message('program_change', channel=chan, program=program)
toPortProxy.send(msg)
return
#else
toPortProxy.send(self.note_mapper.map(msg))
def message_from_oscmidipayload(bites):
"""Convert the last 4 OSC-midi bytes into a mido message.
"""
bites = bites[::-1][0:4]
return mido.parse(bites)
def send_sysex(sysex):
global _midi_out
sysex = mido.parse(sysex)
_midi_out.send(sysex)
def on_midi_event(self, event, data):
event, dt = event
event = mido.parse(event)
print(event, data)
self.on_parsed_event(event)
def parse_midi(stream):
for time, msg in stream:
msg = mido.parse(msg)
msg.time = time
yield msg
def test_sysex(self):
original = Message('sysex', data=(1, 2, 3, 4, 5))
parsed = mido.parse(original.bytes())
self.assertTrue(original == parsed)
def test_pitchwheel_encode_parse(self):
"""Encode and parse pitchwheel with value=0."""
a = Message('pitchwheel', pitch=0)
b = mido.parse(a.bytes())
self.assertTrue(a == b)
def test_parse_channel(self):
"""Parser should not discard the channel in channel messages."""
self.assertTrue(mido.parse([0x90, 0x00, 0x00]).channel == 0)
self.assertTrue(mido.parse([0x92, 0x00, 0x00]).channel == 2)
def send_to_channel(self, msg, toPortProxy, chan):
byte_list = msg.bytes()
# Replace original channel with 'chan'
byte_list[0] = (byte_list[0] & 0xF0) | chan
toPortProxy.send(mido.parse(byte_list))
return
def configEWI(PRESET):
# Sends the Sysex commands to the EWI
# to change the configuration.
# preset 0 is used when the config update is requested from the web page
# it uses the file that is written by the webpage. This includes
# the "reset to defaults" function
if PRESET == 0:
FILE = open(EWICONFIGFILE, 'r')
if PRESET == 1:
FILE = open(P1CONFIGFILE, 'r')
if PRESET == 2:
FILE = open(P2CONFIGFILE, 'r')
if PRESET == 3:
FILE = open(P3CONFIGFILE, 'r')
if PRESET == 4:
FILE = open(P4CONFIGFILE, 'r')
L1 = (FILE.readline()).replace("\n", "")
L2 = (FILE.readline()).replace("\n", "")
FILE.close()
L1 = L1.replace(
"F0 47 00", "F0 47 7F"
) # replace "receive" with "send" - only needed for the presets
L2 = L2.replace("F0 47 00", "F0 47 7F")
# create lists from hex strings
LINE1 = L1.split()
LINE2 = L2.split()
if PRINT: print "Configuring EWI via USB..."
# send "enable" request
USBOUTPORT.send(mido.parse([0xB0, 0x63, 0x01]))
USBOUTPORT.send(mido.parse([0xB0, 0x62, 0x04]))
USBOUTPORT.send(mido.parse([0xB0, 0x06, 0x20]))
# remove F0 and F7 chars
LINE1.pop(0)
LINE1.pop(-1)
INTLIST = [int(x, 16) for x in LINE1]
# send bank 0 data
USBOUTPORT.send(mido.Message('sysex', data=INTLIST))
# send "enable" request
USBOUTPORT.send(mido.parse([0xB0, 0x63, 0x01]))
USBOUTPORT.send(mido.parse([0xB0, 0x62, 0x04]))
USBOUTPORT.send(mido.parse([0xB0, 0x06, 0x20]))
# remove F0 and F7 chars
LINE2.pop(0)
LINE2.pop(-1)
INTLIST = [int(x, 16) for x in LINE2]
# send bank 2 data
USBOUTPORT.send(mido.Message('sysex', data=INTLIST))
# send "finished" request
USBOUTPORT.send(mido.parse([0xB0, 0x63, 0x01]))
USBOUTPORT.send(mido.parse([0xB0, 0x62, 0x04]))
USBOUTPORT.send(mido.parse([0xB0, 0x06, 0x10]))
return
def handle_data(data):
msg = mido.parse(data) # use parser
outport.send(msg) # make sound
return True
def process(frames):
global offset, i
global msg
global syx_iter
global controller_map, patch_no, vals, latent, flow
port.clear_buffer()
needs_update = False
X = syx[[patch_no]]
a = X_a
for offset, data in inport.incoming_midi_events():
msg = mido.parse(bytes(data))
if msg.type == 'note_on':
# print(msg.__dir__())
patch_no = msg.note % 32
print(f"patch set to {patch_no}")
needs_update = True
a = X_a[[0]]
flow = model.features(X, a | 1)
q = flow.q_z
vals = q.mean + torch.linspace(-4, 4, 128)[:, None] * q.stddev
if msg.type != 'control_change':
continue
if msg.control not in controller_map:
if len(controller_map) == 8:
continue
print(f"latent {len(controller_map)} set to encoder {msg.control}")
controller_map[msg.control] = len(controller_map)
l_i = list(controller_map).index(msg.control)
print(f'Latent: {latent}')
latent[:, controller_map[msg.control]] = msg.value
needs_update = True
# print("{0}: 0x{1}".format(client.last_frame_time + offset,
# binascii.hexlify(data).decode()))
# print(time.time()-offset)
inport.clear_buffer()
if (needs_update):
offset = time.time()
# X = next(iter_X)['x'][[0]]
# X_d = torch.distributions.Categorical(logits=mask_parameters(torch.zeros(1, 155, 128)))
# X_a = torch.rand_like(X.float()) < 0.3
# X_a = torch.ones_like(X).bool()
# X_a[:,:-10] = 0
# X[~X_a] = X_d.sample()[~X_a]
# max_to_sample = max((~X_a).sum(-1))
# # X = X[[0]*1]
# # for i in tqdm(range(max_to_sample)):
# logits = model.generate(X, X_a)
# samples = logits.sample()
# batch_idxs, sample_idx = (~X_a).nonzero().t()
# X[batch_idxs, sample_idx] = samples[batch_idxs, sample_idx]
# X_a[batch_idxs, sample_idx] = 1
# z = slerp(next(x_iter), m1, m2).unsqueeze(-2)[...,[0]*155,:].unsqueeze(0)
# z = q.mean
# z = torch.from_numpy(latent).float()
# print(q.stddev)
# z = torch.randn_like(z)
# z = z.mean().unsqueeze
# z = q.mean# + torch.randn(q.mean.shape) * 0.1 + q.stddev
# val = torch.from_numpy(vals).float()
# print(latent)
# print(time.time())
z, _ = flow.flow(vals.gather(0, latent))
# print(time.time())
# print(a)
msg = model.generate_z(X, a, z, t=0.001).sample()
# print(time.time())
msg[a] = X[a]
# msg = X if i%2 else msg
# msg[:,-(len(name)):] = name
# msg = DX7Single.to_syx([list(next(syx_iter).values())])
msg = DX7Single.to_syx(msg.numpy().tolist())
# import mido
# print([int(i, 2)mido.Message('control_change', control=123).bytes()])
port.write_midi_event(0, msg.bytes())
port.write_midi_event(
1,
mido.Message('control_change', control=123).bytes())
port.write_midi_event(
2,
mido.Message('control_change', control=123).bytes())
port.write_midi_event(
3,
mido.Message('control_change', control=123).bytes())
port.write_midi_event(
4,
mido.Message('control_change', control=123).bytes())
def create_midi(status, value, data):
msg = mido.parse([status, data, value])
return msg
def test_parse(self):
"""Parse a note_on msg and compare it to one created with Message()."""
parsed = mido.parse(b'\x90\x4c\x20')
other = Message('note_on', channel=0, note=76, velocity=32)
self.assertTrue(parsed == other)
