def __init__(self, turtle, devname, cb=False):
self.turtle = turtle
if cb:
self.midi_in = mido.open_input(devname, callback=self.midi_callback)
else:
self.midi_in = mido.open_input(devname)
self.midi_out = mido.open_output(devname)
self.rgb = True
self.size = 1
self._update_rgb_indicator()
def eloop(self, render_callback):
cb = callback_factory(render_callback)
try:
midin = mido.open_input(
name=self.port, virtual=True, callback=cb)
except IOError: # couldn't create virtual port
midin = mido.open_input(name=self.port, callback=cb)
except:
raise complain.ComplainToUser("Could not find a valid MIDI input")
midin.close()
def __init__(self, input=None, output=None):
if input is None:
try:
input = mido.open_input('Launchpad S', callback=True)
except IOError:
input = mido.open_input('Launchpad S MIDI 1', callback=True)
if output is None:
try:
output = mido.open_output('Launchpad S')
except IOError:
output = mido.open_output('Launchpad S MIDI 1')
super(LaunchpadS, self).__init__(input, output)
def __init__(self, input=None, output=None):
if input is None:
try:
input = mido.open_input('Launchpad Mini', callback=True)
except IOError:
input = mido.open_input('Launchpad Mini MIDI 1', callback=True)
if output is None:
try:
output = mido.open_output('Launchpad Mini')
except IOError:
output = mido.open_output('Launchpad Mini MIDI 1')
self.lights = lights((8, 8))
self.buttons = buttons((8, 8))
super(Launchpad, self).__init__(input, output)
def __init__(self, input=None, output=None):
if input is None:
try:
input = mido.open_input('Launchpad Pro Standalone Port', callback=True)
except IOError:
input = mido.open_input('Launchpad Pro MIDI 2', callback=True)
if output is None:
try:
output = mido.open_output('Launchpad Pro Standalone Port')
except IOError:
output = mido.open_output('Launchpad Pro MIDI 2')
self.lights = lights((8, 8))
self.buttons = buttons((8, 8))
super(LaunchpadPro, self).__init__(input, output)
def messages(self):
if not mido:
raise ValueError(MIDO_ERROR)
try:
input_names = mido.get_input_names()
except AttributeError as e:
e.args = (MIDO_ERROR,) + e.args
raise
ports = [mido.open_input(i) for i in input_names]
if not ports:
log.error('control.midi: no MIDI ports found')
return
port_names = ', '.join('"%s"' % p.name for p in ports)
log.info('Starting to listen for MIDI on port%s %s',
'' if len(ports) == 1 else 's', port_names)
for port, msg in mido.ports.MultiPort(ports, yield_ports=True):
mdict = dict(vars(msg), port=port)
if self.use_note_off:
if msg.type == 'note_on' and not msg.velocity:
mdict.update(type='note_off')
elif self.use_note_off is False:
if msg.type == 'note_off':
mdict.update(type='note_on', velocity=0)
yield mdict
def start_key_thread(self):
port_name = mido.get_input_names()[0]
with mido.open_input(port_name) as inport:
for msg in inport:
if self.done: return
if not self.current_note_to_play:
print("cannot play notes during this state!")
continue
if hasattr(msg, 'note') and hasattr(msg, 'velocity') and msg.velocity > 0:
print(msg.note)
self.total_notes += 1
self.display_total_notes = self.info_font.render("Total Notes: " + str(self.total_notes), True,
(205, 92, 92))
if hasattr(msg, 'note') and msg.note % 12 == self.current_note_to_play % 12 and hasattr(msg,
'velocity') and msg.velocity > 0:
self.notes_correct += 1
self.display_note = self.note_font.render("Correct!!!", True, (0, 128, 0))
self.display_notes_correct = self.info_font.render("Correct Notes: " + str(self.notes_correct),
True, (205, 92, 92))
self.display_average_tries = self.info_font.render(
"Average Tries: " + str(round(self.total_notes / self.notes_correct)), True, (205, 92, 92))
self.average_note_time += time.time() - self.note_start_time
self.display_average_time = self.info_font.render(
"Average Time: " + str(round(self.average_note_time / self.notes_correct, 1)) + " seconds",
True,
(205, 92, 92))
self.current_note_to_play = 0
Thread(target=self.new_note()).start()
def wait(self):
with mido.open_input(self.device_name) as incoming:
for msg in incoming:
if msg.type == 'note_on' and msg.note in self.notes:
return (msg.note, msg.velocity)
return False
def Run():
global mt
global nvalue
global pnvalue
with mido.open_output(autoreset = True) as o:
with mido.open_input() as i:
while True:
for message in i:
if message.type == 'control_change':## and not message.control == 13:
print("in : " + str(message))
Translate(message,o)
if 'note' in mt:
if not pnvalue == nvalue:
mo = mido.Message(mt,note = nvalue, velocity = 100)
print("out : " + str(mo))
o.send(mo)
pnvalue = nvalue
##microgranny tends not to respond to off or time, or anything it doesn't like
if 'off'in mt:
mt = ''
o.send(mido.Message('note_off',note = pnvalue))
o.send(mido.Message('note_off',note=nvalue))
print("out : note_off")
o.reset()
o.panic()
ManualPanic(o)
def start_midi_stream(file_name, display):
last_note = int(round(time.time() * 1000))
mido.get_output_names()
port_name = mido.get_input_names()[0]
print('Starting on port: ' + port_name)
with MidiFile() as mid:
track = MidiTrack()
try:
print("Waiting For Keyboard Input ... ")
with mido.open_input(port_name) as inport:
for msg in inport:
now = int(round(time.time() * 1000))
msg.time = now - last_note
last_note = now
if hasattr(msg, 'velocity') and msg.velocity == 0:
msg = Message('note_off', note=msg.note, velocity=msg.velocity, time=msg.time)
track.append(msg)
if display:
print(msg)
except KeyboardInterrupt:
if file_name:
print("\nStopping and saving file ... ")
else:
print("\nStopping ...")
finally:
if file_name:
print(file_name)
mid.tracks.append(track)
mid.save(file_name)
print("File Saved!")
print("File Location: " + file_name)
else:
print("Done!")
def play_from_encoder(directory):
encoder = pickle_loader(directory + ".pkl")
sample_rate = encoder.sample_rate
buffer_size = 10 # sample buffer for playback. Hevent really determined what i does qualitatively. Probably affects latency
play_duration = 100 # play duration in miliseconds
pygame.mixer.pre_init(sample_rate, -16, 2,buffer = buffer_size) # 44.1kHz, 16-bit signed, stereo
pygame.init()
volLeft = 0.5;volRight=0.5 # Volume
z_val = np.zeros([1,encoder.dimZ]) # Initial latent variable values
port = mido.open_input(mido.get_input_names()[0]) # midi port. chooses the first midi device it detects.
while True:
mu_out = encoder.generateOutput(z_val)
for msg in port.iter_pending():
if msg.channel < z_val.shape[1]:
z_val[0,msg.channel] = msg.value
else:
print "Midi channel beyond latent variables"
mu_out = map_to_range_symmetric(mu_out,[-1,1],[-32768,32768])
mu_out = mu_out.astype(np.int16)
mu_out = np.array(zip(mu_out,mu_out)) # make stereo channel with same output
sound = pygame.sndarray.make_sound(mu_out)
channel = sound.play(-1)
channel.set_volume(volLeft,volRight)
pygame.time.delay(play_duration)
sound.stop()
def start(self):
if self.midi_inport:
with mido.open_input(self.midi_inport) as input:
for message in input:
if message.type == 'control_change':
if message.channel == self.channel:
if message.control == self.bcontrolnum:
self.beat.set_control_beat(message.value)
elif message.control == self.tcontrolnum:
self.bpm.set_control_bpm(message.value)
elif message.control == self.rcontrolnum:
self.rms.set_control_rms(message.value)
elif message.control == self.pcontrolnum:
self.pitch.set_control_pitch(message.value)
elif message.type == 'sysex':
prefix = list(message.data[0:len(self.sysex_prefix)])
command = message.data[len(self.sysex_prefix)]
data = list(message.data[len(self.sysex_prefix) + 1:])
if cmp(prefix, self.sysex_prefix) == 0:
if command == self.bsysexnum:
self.beat.set_sysex_beat(data)
elif command == self.tsysexnum:
self.bpm.set_sysex_bpm_two_bytes(data)
elif command == self.rsysexnum:
self.rms.set_sysex_rms(data)
elif command == self.fsysexnum:
self.frequencies.set_sysex_frequencies(data)
elif command == self.psysexnum:
self.pitch.set_sysex_pitch(data)
elif message.channel == self.channel:
if message.type == 'note_on':
self.pitch.set_note_pitch(message.note)
elif message.type == 'note_off':
self.pitch.set_last_note_pitch(message.note)
def main():
output_name = ''
input_name = ''
device_names = mido.get_input_names()
for device_name in device_names:
# FIXME: Heuristic to get our USB stick device
if '-' in device_name and 'Through' not in device_name:
output_name = device_name
break
else:
print "No appropriate MIDI device. MIDI device names: ", device_names
return
print "Connected devices: ", device_names
print "Opening device: ", output_name
# or, with mido.open_ioport(output_name) as iop:
with mido.open_output(output_name) as output:
with mido.open_input(output_name, callback=print_message) as inp:
#msg = mido.Message('sysex', data=[10]) Set type to digital output
#msg = mido.Message('sysex', data=[101]) # send watchdog timer reset
#msg = mido.Message('sysex', data=[99]) # Request device type
msg = mido.Message('sysex', data=[77]) # Request device name
#msg = mido.Message('sysex', data=[54,1,2,3,4]) # Set device name to '0x010203'
#msg = mido.Message('note_on')
print "sending msg: ", msg
output.send(msg);
print "waiting for response message"
time.sleep(1) # Pause while we get MIDO callback print-outs
print "script done"
def __init__(self):
self.log = logger()
if 'Teensy MIDI' not in mido.get_input_names():
self.log.error('Error connecting to Teensy foot controller.')
sys.exit(1)
self.input = mido.open_input(MidiController.DEVICE)
self.log.info('Device Registered.')
def open_port(self, portName):
if not self.port or self.port.name != portName:
if self.port:
self.port.close()
print(portName)
if portName in mido.get_input_names():
self.port = mido.open_input(portName, callback=self.dispatch_midi)
def __init__(self, input_midi_port, output_midi_port, texture_type,
passthrough=True):
self._texture_type = texture_type
self._passthrough = passthrough
# When `passthrough` is True, this is the set of open MIDI note pitches.
self._open_notes = set()
# This lock is used by the serialized decorator.
self._lock = threading.RLock()
# A dictionary mapping a string-formatted mido.Messages to a condition
# variable that will be notified when a matching messsage is received,
# ignoring the time field.
self._signals = {}
# A dictionary mapping integer control numbers to most recently-received
# integer value.
self._control_values = {}
# Threads actively being used to capture incoming messages.
self._captors = []
# Potentially active player threads.
self._players = []
self._metronome = None
# Open MIDI ports.
self._inport = (
input_midi_port if isinstance(input_midi_port, mido.ports.BaseInput)
else mido.open_input(
input_midi_port,
virtual=input_midi_port not in get_available_input_ports()))
self._outport = (
output_midi_port if isinstance(output_midi_port, mido.ports.BaseOutput)
else mido.open_output(
output_midi_port,
virtual=output_midi_port not in get_available_output_ports()))
# Start processing incoming messages.
self._inport.callback = self._timestamp_and_handle_message
def __init__(self, port_name, trace=False):
"""
Construct new MIDIReceiver object.
DO NOT instinate directly, use get_midi_receiver function instead.
ARGS:
port_name - String.
For a list of available ports execute the mido-ports
script on the command line.
"""
self._dispatch_table = {"note_on" : {},
"note_off" : {},
"program_change" : {},
"aftertouch" : {},
"control_change" : {},
"pitchwheel" : {},
"polytouch" : {},
"sysex" : {},
"quarter_frame" : {},
"songpos" : {},
"song_select" : {},
"tune_request" : {},
"clock" : {},
"start" : {},
"continue" : {},
"stop" : {},
"reset" : {},
"active_sensing" : {}}
self._port_name = port_name
self._port = mido.open_input(self._port_name)
self._thread = None
self._active = False
self.enable_trace(trace)
def capture(self):
self.capturing = False
self.final_tick = False
# Start clocks at -1 to account for Circuit's leading clock message after start
self.clocks = [-1, -1, -1]
self.total_ticks = 0
output_dir = os.path.dirname(self.output)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
mido.set_backend('mido.backends.rtmidi')
with mido.MidiFile(type=1, ticks_per_beat=TICKS_PER_BEAT) as mid:
# Create tracks
self.tempo_map_track = mid.add_track(name=SONG_NAME)
self.tracks = [mid.add_track(name="Synth 1"),
mid.add_track(name="Synth 2"),
mid.add_track(name="Drums")]
# Set synth instruments
self.tracks[CHANNEL_SYNTH1].append(mido.Message('program_change', program=PROGRAM_SYNTH1))
self.tracks[CHANNEL_SYNTH2].append(mido.Message('program_change', program=PROGRAM_SYNTH2))
with mido.open_input(self.input) as port:
print("Push 'Play' to start capture.")
for msg in port:
if not self.process_message(msg):
break
self.capturing = False
self.write_tempo_map()
mid.save(self.output)
print("All done!")
def __init__(self, input=None, output=None):
if input is None:
try:
input = mido.open_input(
'Ableton Push User Port',
callback=True)
except IOError:
input = mido.open_input('Ableton Push MIDI 2', callback=True)
if output is None:
try:
output = mido.open_output('Ableton Push User Port')
except IOError:
output = mido.open_output('Ableton Push MIDI 2')
self.lights = lights((8, 8))
self.buttons = buttons((8, 8))
super(Push, self).__init__(input, output)
def __init__(self, input_midi_port, output_midi_port): self._inport = mido.open_input(input_midi_port) self._outport = mido.open_output(output_midi_port) # This lock is used by the serialized decorator. self._lock = threading.RLock() self._control_cvs = dict() self._player = None self._capture_start_time = None self._sequence_start_time = None
def main():
"""reads the config file first, then opens the midi input and waits for commands"""
device, midi_to_shortcut = read_conf()
print(mido.get_input_names())
# input the name off your Midi device here.
with mido.open_input(device) as inp:
for message in inp:
process_message(message, midi_to_shortcut)
def monitor_midi():
inny = mido.open_input()
while True:
msg = inny.receive()
msg.time = get_usec_timestamp()
msg = str(msg)
print msg
msg += "\n"
midi_file.write(str(msg))
def __init__(self, daemonize=False, buflen=80):
self.scrollwheel = 0
self.buflen = buflen
self.lines = collections.deque([''] * self.buflen)
self.lock = threading.Lock()
try:
# Ports on MAC OSX
self.output = mido.open_output('Ableton Push User Port')
self.input = mido.open_input('Ableton Push User Port',
callback=self.callback)
except IOError:
# Ports on Arch Linux
self.output = mido.open_output('Ableton Push MIDI 2')
self.input = mido.open_input('Ableton Push MIDI 2',
callback=self.callback)
while True:
line = sys.stdin.readline()
if not line:
# EOF from STDIN
break
# We need to use mutex because concurrent reads and writes on
# dequeue (scrolling while there is new text coming in from stdin)
# will issue warnings.
self.lock.acquire()
self.lines.append(line)
self.lines.popleft()
self.lock.release()
self.redraw()
# Do not quit process if running daemonized
# This enables scrolling for one-show piping to Push
#
# e.g. ping www.google.de | pushcat is scrollable as long as ping runs
# ls | pushcat is not scrollable as ls immediately terminates
# ls | pushcat -d enables scrolling
if daemonize:
while True:
try:
time.sleep(0.1)
except KeyboardInterrupt:
sys.exit(0)
def wait(self):
try:
with mido.open_input(self.device_name) as incoming:
for msg in incoming:
if msg.type == 'note_on' and msg.note in self.notes:
return (msg.note, msg.velocity)
except IOError:
dsp.log('Could not arm MIDI device %s' % self.device_name)
return (None, None)
def open_pair(input, output):
if not isinstance(input, mido.ports.BaseInput):
state.inp = mido.open_input([i for i in mido.get_input_names() if i.lower().startswith(input.lower())][0])
else:
state.inp = input
if not isinstance(output, mido.ports.BaseOutput):
state.out = mido.open_output([i for i in mido.get_output_names() if i.lower().startswith(output.lower())][0])
else: state.out = output
setup_threads()
state.metronome = Metronome()
def __init__(self, target=MIDIOUT_DEFAULT):
self.midi = None
# don't ignore MIDI clock messages (is on by default)
# TODO: check
# self.midi.ignore_types(timing=False)
self.clocktarget = None
ports = mido.get_input_names()
if len(ports) == 0:
raise Exception("No MIDI output ports found")
for name in ports:
if name == target:
isobar.log("Found MIDI input (%s)", name)
self.midi = mido.open_input(name, callback=self.callback)
if self.midi is None:
isobar.log("Could not find MIDI source %s, using default", target)
self.midi = mido.open_input(callback=self.callback)
def __init__(self, input_midi_ports, output_midi_ports, texture_type,
passthrough=True, playback_channel=0, playback_offset=0.0):
self._texture_type = texture_type
self._passthrough = passthrough
self._playback_channel = playback_channel
self._playback_offset = playback_offset
# When `passthrough` is True, this is the set of open MIDI note pitches.
self._open_notes = set()
# This lock is used by the serialized decorator.
self._lock = threading.RLock()
# A dictionary mapping a compiled MidiSignal regex to a condition variable
# that will be notified when a matching messsage is received.
self._signals = {}
# A dictionary mapping a compiled MidiSignal regex to a list of functions
# that will be called with the triggering message in individual threads when
# a matching message is received.
self._callbacks = collections.defaultdict(list)
# A dictionary mapping integer control numbers to most recently-received
# integer value.
self._control_values = {}
# Threads actively being used to capture incoming messages.
self._captors = []
# Potentially active player threads.
self._players = []
self._metronome = None
# Open MIDI ports.
if input_midi_ports:
for port in input_midi_ports:
if isinstance(port, mido.ports.BaseInput):
inport = port
else:
virtual = port not in get_available_input_ports()
if virtual:
tf.logging.info(
"Opening '%s' as a virtual MIDI port for input.", port)
inport = mido.open_input(port, virtual=virtual)
# Start processing incoming messages.
inport.callback = self._timestamp_and_handle_message
else:
tf.logging.warn('No input port specified. Capture disabled.')
self._inport = None
outports = []
for port in output_midi_ports:
if isinstance(port, mido.ports.BaseInput):
outports.append(port)
else:
virtual = port not in get_available_output_ports()
if virtual:
tf.logging.info(
"Opening '%s' as a virtual MIDI port for output.", port)
outports.append(mido.open_output(port, virtual=virtual))
self._outport = mido.ports.MultiPort(outports)
def __init__(self, ac):
"""Register the midi device.
:param ac: The audio controller object
"""
self.log = logger()
if 'Teensy MIDI' not in mido.get_input_names():
self.log.error('Error connecting to Teensy foot controller.')
sys.exit(1)
self.input = mido.open_input(MidiController.DEVICE)
self.log.info('Device Registered.')
self.ac = ac
def _open_input(self, port): if self._in_port is None: try: self._in_port = mido.open_input(port) except IOError: print "Couldn't open input port '%s'. The following MIDI ports are available:" % port for p in mido.get_input_names(): print "'%s'" % p raise else: assert self._in_port.name == port return self._in_port
def log_listener():
try:
device_names = mido.get_input_names()
devices = [ mido.open_input(device_name) for device_name in device_names ]
devices = mido.ports.MultiPort(devices)
for msg in devices:
if hasattr(ns, 'midi_log_active'):
dsp.log(msg)
else:
continue
except IOError:
dsp.log('Could not open MIDI devices for logging %s' % str(device_names))
def lightsOff():
print("Sending cancel")
msg = mido.Message('sysex', data=[0, 74, 79, 72, 65, 83, 127])
outport.send(msg)
def lightsOnOne(light):
lightsOff()
msg = mido.Message('program_change', channel=11, program=light)
outport.send(msg)
pro = 0
with mido.open_input(organ) as inport:
print(inport)
for msg in inport:
print(msg)
if msg.type == 'note_on' and msg.note == 36 and msg.velocity != 0:
# See if something is already playing and kill it
if pro != 0:
os.killpg(os.getpgid(pro.pid), signal.SIGTERM)
outport.reset()
pro = 0
lightsOn(len(files))
# Wait for messages to pass
time.sleep(0.2) # Wait for messages to arrive
for msg in inport.iter_pending():
print(msg)
elif time.time() >= time_pedal_is_down + 2.50:
print(
'was held! adding note_queue to chord_progression.'
)
chord_progression.insert(0, note_queue)
note_queue = []
return
print('computer should not record.')
computer_should_record = False
time_since_pedal_released = time.time()
else:
pass
input_name = mido.get_input_names()[0]
input_port = mido.open_input(input_name, callback=handle_message)
output_name = mido.get_output_names()[0]
output_port = mido.open_output(output_name)
def main():
global note_queue
global input_port
global output_port
global computer_should_record
global init_time
global last_time
while not init:
time.sleep(0.1)
import board
import busio
i2c_1 = busio.I2C(board.SCL, board.SDA)
#i2c_2 = busio.I2C(24, 23)
dac_PITCH = adafruit_mcp4725.MCP4725(i2c_1, address=0x60)
dac_HOLD = adafruit_mcp4725.MCP4725(i2c_1, address=0x61)
#dac_MOD = adafruit_mcp4725.MCP4725(i2c_2, address= 0x60)
#dac_TRIG = adafruit_mcp4725.MCP4725(i2c_2, address= 0x61)
from midi_handler import *
from port_manager import *
p = PortManager()
m = MidiHandler()
try:
while True:
if not p.is_scanning:
with mido.open_input(p.input_name) as port:
while not port.closed:
for msg in port.iter_pending():
m.input_signal(msg)
if p.is_scanning:
port.close()
dac_PITCH.normalized_value = m.PITCH_V
except KeyboardInterrupt:
GPIO.cleanup()
print("\nExiting..")
mido.set_backend('mido.backends.rtmidi')
# system command to set up the midi thru port
# TODO would be nice to do this in python, but
# rtmidi has issues seeing ports it has created
#os.system(runCmd)
amidiProc = subprocess.Popen(['amidithru', name])
#print("launched amidithru with pid %s" % amidiProc.pid)
# regex to match on rtmidi port name convention
nameRegex = "(" + name + ":" + name + "\s+\d+:\d+)"
matcher = re.compile(nameRegex)
newList = list(filter(matcher.match, mido.get_input_names()))
input_name = newList[0]
inport = mido.open_input(input_name)
def uptime():
with open('/proc/uptime', 'r') as f:
uptime_seconds = float(f.readline().split()[0])
return uptime_seconds
# keep running and watch for midi cc
while True:
time.sleep(.01)
while inport.pending():
msg = inport.receive()
if msg.type == "control_change":
if msg.control in cc_cmds:
# this determines how much debugging information gets printed
debug = patch.getint('general', 'debug')
# this is only for debugging
print('------ INPUT ------')
for port in mido.get_input_names():
print(port)
print('------ OUTPUT ------')
for port in mido.get_output_names():
print(port)
print('-------------------------')
mididevice = patch.getstring('midi', 'device')
try:
inputport = mido.open_input(mididevice)
if debug > 0:
print("Connected to MIDI input")
except:
print("Error: cannot connect to MIDI input")
exit()
try:
outputport = mido.open_output(mididevice)
if debug > 0:
print("Connected to MIDI output")
except:
print("Error: cannot connect to MIDI output")
exit()
try:
#plt.ylim(0,5)
#plt.xlim(20,109)
#plt.show(block=False)
def update_plot(msg, time):
if msg.type == 'note_on':
print(msg)
if msg.velocity == 0:
return
x.append(time)
y.append(msg.note)
z.append(max(1, msg.velocity-40)*3)
sc.set_offsets(numpy.c_[y,x])
sc.set_sizes(z)
fig.canvas.draw_idle()
plt.ylim(time - 15, time+1)
plt.pause(0.01)
def print_diff(msg, time):
x.append(time)
print(x[-1] - x[-2])
#y.append(msg.note)
#z.append(max(1, msg.velocity-40)*3)
with mido.open_input(portname) as inport:
for msg in inport:
if msg.type == 'note_on' and msg.velocity !=0:
print_diff(msg, time.time() - start)
#update_plot(msg, time.time() - start)
class pyPOD:
midi_channel = 1
msg_bytes = []
manufacturer_id = ""
pod_version = ""
product_family = ""
product_family_member = ""
inport = mido.open_input()
outport = mido.open_output()
logger = logging.getLogger("pyPod")
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(funcName)s - %(message)s'
)
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)
def __init__(self, **kwargs):
if "loglevel" in kwargs.keys():
self.set_loglevel(kwargs["loglevel"])
self.logger.debug('init pyPOD')
self.inport.callback = self.monitor_input
self.load_config()
def set_loglevel(self, loglevel):
self.ch.setLevel(loglevel)
def load_config(self):
self.logger.debug('looking for config')
rcfile = "/.pypodrc"
homerc = os.environ['HOME'] + rcfile
pwdrc = os.environ['PWD'] + rcfile
rcfile = ""
config = ""
if os.path.isfile(homerc):
self.logger.debug(f"found {homerc}")
rcfile = homerc
elif os.path.isfile(pwdrc):
self.logger.debug(f"found {pwdrc}")
rcfile = pwdrc
else:
self.logger.info("no config file found")
if rcfile != "":
with open(rcfile, "r") as fd:
config = json.load(fd)
if 'MIDI_IN' in config.keys():
self.logger.debug(f"MIDI_IN: {config['MIDI_IN']}")
self.connect_input(config['MIDI_IN'])
if 'MIDI_OUT' in config.keys():
self.logger.debug(f"MIDI_OUT: {config['MIDI_OUT']}")
self.connect_output(config['MIDI_OUT'])
if 'MIDI_CHAN' in config.keys():
self.logger.debug(f"MIDI_CHAN: {config['MIDI_CHAN']}")
self.midi_channel = int(config['MIDI_CHAN'])
def connect_input(self, midi_in):
self.logger.info(f"connecting to input {midi_in}")
try:
self.inport = mido.open_input(midi_in)
except OSError:
# open default instead:
self.logger.warning("error opening input, using default")
self.inport = mido.open_input()
self.inport.callback = self.monitor_input
def connect_output(self, midi_out):
self.logger.info(f"connecting to output {midi_out}")
try:
self.outport = mido.open_output(midi_out)
except OSError:
self.logger.warning("error opening output, using default")
self.outport = mido.open_output()
def show_midiports(self):
# a little helper-function for the command line
# run this script with the -o parameter --show-midiports
# and put the name of the connected midi-port in the config
inports = mido.get_input_names()
outports = mido.get_output_names()
return inports, outports
def denib(self, highnibble, lownibble):
# from https://medias.audiofanzine.com/files/lin020-477344.pdf:
#POD sends and receives Program and Global dump data in High-Low Nibbilized format.
#ONE POD BYTE (8 bits):0: A7 A6 A5 A4 A3 A2 A1 A0
#TRANSMITTED and RECEIVED AS:
#0: 00 00 00 00 A7 A6 A5 A4
#1: 00 00 00 00 A3 A2 A1 A0
ret_byte = highnibble << 4
ret_byte = ret_byte | lownibble
return ret_byte
def nib(self, in_byte):
# reverse function of denib, for creating data to be sent to the pod
highnibble = in_byte >> 4
lownibble = in_byte & 0b1111
return highnibble, lownibble
def dump_editbuffer(self):
self.logger.info("dumping edit bufer")
msg = mido.Message('sysex', data=[0x00, 0x01, 0x0c, 0x01, 0x00, 0x01])
self.outport.send(msg)
def dump_program(self, program):
# dump a single program from the pod:
self.logger.info(f"Dumping program {program} from pod")
msg = mido.Message('sysex',
data=[
0x00, 0x01, 0x0c, 0x01, 0x00, 0x00,
line6.PROGRAMS.index(program)
])
self.outport.send(msg)
def upload_editbuffer(self):
self.logger.info("Upload to edit buffer")
msg = mido.Message('sysex', data=[0x00, 0x01, 0x0c, 0x01, 0x01, 0x01])
message = mido.Message('sysex')
for byte in self.msg_bytes:
message.data += self.nib(byte)
msg.data += message.data[1:]
#self.logger.debug(f"message length: {len(message.data)}")
#self.logger.debug(f"msg.data: {msg.data}")
#self.logger.debug(f"total length: {len(msg.data)}")
self.outport.send(msg)
def upload_program(self, program):
self.logger.info(f"Uploading to program {program}")
# uploads a single program to the pod:
msg = mido.Message('sysex',
data=[
0x00, 0x01, 0x0c, 0x01, 0x01, 0x00,
line6.PROGRAMS.index(program)
])
# somehow we have to cut the first element, I have no idea why
# found out because uploading did not work and compared data-dumps
# from jsynthlib with mine and found out I transmitted one extra byte...
message = mido.Message('sysex')
for byte in self.msg_bytes:
message.data += self.nib(byte)
msg.data += message.data[1:]
self.logger.debug(f"message length: {len(message.data)}")
self.logger.debug(f"msg.data: {msg.data}")
self.logger.debug(f"total length: {len(msg.data)}")
self.outport.send(msg)
def udq(self):
msg = mido.Message('sysex', data=[0x7e, self.midi_channel, 0x06, 0x01])
self.outport.send(msg)
def parse_progdump(self, message):
self.msg_bytes = []
offset = 1
if len(message) == 152:
offset = 7 # data starts after byte 9
for x in range(0, 72):
self.msg_bytes.append(
self.denib(message.bytes()[x * 2 + offset],
message.bytes()[x * 2 + offset + 1]))
return
def get_program_name(self):
return "".join(map(chr, self.msg_bytes[56:]))
def monitor_input(self, message):
# a single program dump is 152 bytes long (9 bytes header, 142 bytes data, &xF7 is the last byte)
if message.type == 'sysex' and len(message.bytes()) == 152:
self.logger.info(f"Received sysex (program dump)")
self.parse_progdump(message)
elif message.type == 'sysex' and len(message.bytes()) == 17:
self.pod_version = "".join(
[chr(x) for x in message.bytes()[12:16]])
self.manufacturer_id = "{:02X} {:02X} {:02X}".format(
message.bytes()[5],
message.bytes()[6],
message.bytes()[7])
self.product_family = "{:02X}{:02X}".format(
message.bytes()[9],
message.bytes()[8])
self.product_family_member = "{:02X}{:02X}".format(
message.bytes()[11],
message.bytes()[10])
self.logger.info("Received sysex (device info)")
elif message.type == 'sysex' and len(message.bytes()) == 151:
# the editbuffer-dump is one byte shorter than a regular program dump
dummymsg = mido.Message('sysex', data=[0])
message.data = dummymsg.data + message.data
self.parse_progdump(message)
self.logger.info("Received sysex (edit buffer)")
elif message.type == 'program_change' and len(message.bytes()) == 2:
prog = "Edit Buffer" if message.bytes(
)[1] == 0 else line6.PROGRAMS[message.bytes()[1] - 1]
self.logger.info(f"Received program_change message: {prog}")
else:
self.logger.warning(
f"Unknown message type {message.type}: {message.bytes()} ({len(message.bytes())}) bytes:"
)
def get_info(self):
# get infos about the device:
self.udq()
time.sleep(1)
print("POD Version: {}".format(self.pod_version))
print("Manufacturer ID: {}".format(self.manufacturer_id))
print("Product Family ID: {}".format(self.product_family))
print("Product Family Member: {}".format(self.product_family_member))
def dump_raw(self, **kwargs):
if 'filename' in kwargs:
# if filename is given, dump to syx file:
# update: create sysex-message so we don't have to manually add the
# first and last byte
message = []
for m in self.msg_bytes[:]:
h, l = self.nib(m)
message.append(h)
message.append(l)
msg = mido.Message('sysex', data=message)
mido.write_syx_file(kwargs['filename'], (msg, ))
else:
print(*self.msg_bytes)
def dump_hex(self):
# print values as hex
hexbytes = []
for b in self.msg_bytes[:]:
hexbytes.append("{:02X}".format(b))
print(*hexbytes)
def load_syx(self, filename):
messages = mido.read_syx_file(filename)
message = mido.Message('sysex', data=messages[0].data)
self.parse_progdump(message)
def change_name(self, new_name):
"""changes the name string of a patch"""
if len(new_name) > 16:
# the maximum length is 16 characters
new_name = new_name[:16]
if len(new_name) < 16:
# fill it up with spaces:
new_name = new_name + (" " * (16 - len(new_name)))
# create a list of ascii-values
self.logger.info(f"Changing Program name to {new_name}")
self.msg_bytes[56:] = list(map(ord, new_name))
def send_cc(self, control, value):
msg = mido.Message('control_change')
msg.control = control
msg.value = value
self.outport.send(msg)
def send_pc(self, program):
msg = mido.Message('program_change')
msg.program = program
self.outport.send(msg)
def get_midioutputs(self):
# helper function for the gui app
return mido.get_output_names()
def get_midiinputs(self):
# helper function for the gui app
return mido.get_input_names()
# }}}
# {{{ dump human readable
def dump(self, prog_name):
# TODO: Format the output so it can be used as a simple menu
# (enter a number to change certain parameters, save, load,...)
p_name = self.get_program_name()
print(f"Program: {prog_name}")
print(f"Program name: {p_name}")
if self.msg_bytes[1] > 0:
print("Distorton ON")
if self.msg_bytes[2] > 0:
print("Drive ENABLED")
if self.msg_bytes[3] > 0:
print("Presence ENABLED")
if self.msg_bytes[4] > 0:
print("Delay ENABLED")
if self.msg_bytes[5] > 0:
print("Tremolo/Chorus Flange ENABLED")
if self.msg_bytes[6] > 0:
print("Reverb ENABLED")
if self.msg_bytes[7] > 0:
print("Noise Gate ENABLED")
if self.msg_bytes[8] > 0:
print("Bright Switch ON")
print("Amp Type: {}".format(line6.amp_names[self.msg_bytes[9]]))
print("Cab Type: {}".format(line6.cab_names[self.msg_bytes[45]]))
print("AIR: {}".format(self.msg_bytes[46]))
print("Drive: {}".format(self.msg_bytes[10]))
print("Drive 2: {}".format(self.msg_bytes[11]))
print("Bass: {}".format(self.msg_bytes[12]))
print("Mid: {}".format(self.msg_bytes[13]))
print("Treble: {}".format(self.msg_bytes[14]))
print("Presence: {}".format(self.msg_bytes[15]))
print("Channel Volume: {}".format(self.msg_bytes[16] * 2))
print("Noise Gate Threshhold: {}".format(self.msg_bytes[17] * 2))
print("Noise Gate Decay Time: {}".format(self.msg_bytes[18] * 2))
#19-25: Wah and Volume Pedal - since I don't have either, I will keep this out for now
# FIXME: Since I added Wah info to the CC-Commands I will also add it here
# Max delay time is 3150ms, bytes 28,29,30 contain the value*6 but only 14 bits (instead of 24)
# so we divide by 6 and then multiply it with 0.192272 (that is 3150/0b11111111111111)
delay_time = int(
((((self.msg_bytes[28] << 8) | self.msg_bytes[29]) << 8)
| self.msg_bytes[30]) / 6)
delay_time = int(delay_time * 0.192272)
print("Delay Time: {}ms".format(delay_time))
print("Delay Feedback: {}".format(self.msg_bytes[35]))
print("Delay Level: {}".format(self.msg_bytes[37]))
r_type = "Hall" if self.msg_bytes[39] == 1 else "Spring"
print("Reverb Type: {}".format(r_type))
print("Reverb Decay: {}".format(self.msg_bytes[40] * 2))
print("Reverb Tone: {}".format(self.msg_bytes[41] * 2))
print("Reverb Diffusion: {}".format(self.msg_bytes[42] * 2))
print("Reverb Density: {}".format(self.msg_bytes[43] * 2))
print("Reverb Level: {}".format(self.msg_bytes[44] * 2))
print("FX: {}".format(line6.fx_names[self.msg_bytes[47]]))
print("FX Tweak: {}".format(self.msg_bytes[48] * 2))
comp = "OFF"
if self.msg_bytes[47] == 7 or self.msg_bytes[47] == 11:
if self.msg_bytes[49] == 1:
comp = "1.4:1"
if self.msg_bytes[49] == 2:
comp = "2:1"
if self.msg_bytes[49] == 3:
comp = "3:1"
if self.msg_bytes[49] == 4:
comp = "6:1"
if self.msg_bytes[49] == 5:
comp = "INF:1"
print("Compressor Ratio: {}".format(comp))
import mido
print(mido.get_output_names())
print(mido.get_input_names())
toFL = mido.open_output(name='loopMIDI Port 10', virtual=False)
fromFL = mido.open_input(name='loopMIDI Port 1 10')
while (1):
msg = fromFL.poll()
if (msg):
print(msg)
# SETUP MIDI IO, just pick the first port, what could go wrong?
import mido
import re
midi_ports = mido.get_output_names()
midi_port = midi_ports[0]
for port in midi_ports:
if re.match('IAC', port) or re.match('LoopBe', port):
midi_port = port
outport = mido.open_output(midi_port)
midi_ports = mido.get_input_names()
for port in midi_ports:
if re.match('IAC', port) or re.match('LoopBe', port):
midi_port = port
inport = mido.open_input(midi_port)
MIDI_CHANNEL = 11
MIDI_NOTE = 36
import threading
NOTE_LENGTH = 0.25
def note_off():
outport.send(mido.Message('note_off', note=MIDI_NOTE,
channel=MIDI_CHANNEL))
def note_on():
outport.send(mido.Message('note_on', note=MIDI_NOTE, channel=MIDI_CHANNEL))
def openInput(self, inputsArr, index):
if len(inputsArr) > 0:
return mido.open_input(inputsArr[index])
MINOR_SEVEN_CHORD = {}
for i, chord in enumerate(PITDH_LIST):
MINOR_SEVEN_CHORD["{}m7".format(chord)] = {"list": [(note + i) % 12 for note in C_MINOR_7],
"root_note": i,
"root": chord,
}
CHORD_FROM_3.update(MINOR_SEVEN_CHORD)
MAJOR_AND_MINOR_CHORD = MAJOR_CHORD
MAJOR_AND_MINOR_CHORD.update(MINOR_CHORD)
print(mido.get_input_names())
print(mido.get_output_names())
# inport = mido.open_input("loopMIDI Port 1")
inport = mido.open_input("Q49 0")
outport = mido.open_output("loopMIDI Port 2")
note_on_list = []
def note_to_pitch(note):
return PITDH_LIST[note % 12]
def convert_to_base_note(note_list):
base_note_list = []
for note in note_list:
base_note = note % 12
if base_note not in base_note_list:
base_note_list.append(base_note)
return base_note_list
&&&&& &&&&&& &&&&&& &&&&&& &&&&& &&&&& &&&&&&
&&&&& &&&&& &&&&& &&&&&& &&&&& &&&&& &&&&&& ,&&&&&
&&&&&&&&& &&&&& &&&&&& &&&&&&&&&& &&&&&& ,&&&&&
&&&&& &&&&& &&&&& &&&&&& &&&&& &&&&& &&&&&& ,&&&&&
&&&&& &&&&&& &&&&&. &&&&&& &&&&& &&&&&& &&&&&& #&&&&&
&&&&& %&&&&& &&&&&&&&&&& &&&&& &&&&&/ &&&&&&&&&&&&
"""
TIMESTAMP = datetime.now().strftime('%Y%m%d-%H%M')
A4_DATA_SIZE = 725
print (LOGO)
print(" --[ KORG A4 MIDI Dump ] --\n")
midi_in_port = mido.open_input('Studio 1810c')
print("[READY] Waiting for MIDI data from A4]")
midi_msg = midi_in_port.receive()
sysex_data = midi_msg.data
if len(sysex_data) == A4_DATA_SIZE:
print("[SUCCESS] Data Read Successful")
patch_data = [mido.Message('sysex', data=sysex_data)]
file_name_text = f"korg-a4-patches-{TIMESTAMP}.txt"
file_name_raw = f"korg-a4-patches-{TIMESTAMP}.sysex"
try:
mido.write_syx_file(file_name_text, patch_data, plaintext=True)
mido.write_syx_file(file_name_raw, patch_data, plaintext=False)
print (f"[SUCCESS] Data written to {file_name_text}, {file_name_raw}")
import mido
mido.get_input_names()
mido.get_output_names()
port2 = mido.open_output('loopMIDI Port 2 3')
channel = 2
channel_max = 3
try:
with mido.open_input('loopMIDI Port 0') as inport:
while True:
for msg in inport:
print(msg)
#print(dir(msg))
if msg.type == 'control_change' and msg.control == 1:
channel += 1
# channel = 0
if channel > channel_max:
channel = 2
else:
msg_copy = msg
msg_copy.channel = channel
# output = mido.Message(msg.type, note=msg.note, velocity=msg.velocity, channel=2)
port2.send(msg_copy)
print(msg_copy)
print('sent on channel {}'.format(channel))
except:
pass
def obs_start():
obs_ws.run_forever()
def scalemap(inp, ista, isto, osta, osto):
return osta + (osto - osta) * ((inp - ista) / (isto - ista))
if __name__ == "__main__":
print("MIDItoOBS made by github.com/lebaston100")
print("!!MAKE SURE OBS IS RUNNING OR THIS SCRIPT WILL CRASH!!")
print("Main program started")
result = db.search(Query().type.exists())
if result:
try:
port = mido.open_input(result[0]["value"], callback=midicallback)
except:
print(
"The midi device you setup is not connected or now under a different name."
)
print(
"Please plugin in the device or run setup.py again and restart this script."
)
time.sleep(8)
sys.exit()
obs_ws = websocket.WebSocketApp("ws://" + serverIP + ":" + serverPort,
on_message=obs_on_message,
on_error=obs_on_error,
on_close=obs_on_close)
obs_ws.on_open = obs_on_open
atexit.register(exitScript)
def openIn(deviceName):
inputPort = chooseDevice(mido.get_input_names(), deviceName)
if inputPort:
return mido.open_input(inputPort)
else:
return None
import mido
from mido import Message
outport = mido.open_output('Base2 MIDI 1')
inport = mido.open_input('Base2 MIDI 1')
for msg in inport:
msgout = msg
if hasattr(msg, 'note'):
msgout.note = msgout.note + 4
outport(msgout)
tapper_off = 20000
volume = 0.5 # range [0.0, 1.0]
fs = 44100 # sampling rate, Hz, must be integer
duration = 0.75 # in seconds, may be float
def play_note(note_value):
note_mapper = (2.0**((note_value - 69) / 12.0)) * 440.0
samples = np.sin(2 * np.pi * np.arange(fs * duration) * note_mapper /
fs).astype(np.float32)
for i in range(tapper_off):
samples[-i - 1] = samples[-i - 1] * i / float(tapper_off)
stream.write(volume * samples)
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paFloat32,
channels=1,
rate=fs,
input=True,
output=True)
index = 0
for msg in mido.open_input():
print(msg)
if msg.type == 'note_on':
play_note(msg.note)
content = [x for x in content if x[0] != '#']
content = [x.split('=') for x in content]
#convert config to dict
config = dict()
for element in content:
config[element[0]] = element[1]
if config['LCD'] == 'true':
lcd = LcdHandler(int(config['LCD_ROWS']), int(config['LCD_COLS']))
else:
lcd = None
try:
#midiin = rtmidi.MidiIn()
port = mido.open_input(callback=MidiInputHandler(lcd))
#port_name = midiin.open_virtual_port("MidiSniffer")
#midiin.ignore_types(sysex=False)
except (EOFError, KeyboardInterrupt):
sys.exit()
print("Attaching MIDI input callback handler.")
#midiin.set_callback(MidiInputHandler(port_name, lcd))
print("Entering main loop. Press Control-C to exit.")
try:
# Just wait for keyboard interrupt,
# everything else is handled via the input callback.
while True:
sleep(1)
except KeyboardInterrupt:
import mido
from mido import Message
msg = Message('note_on', note=60)
print(msg)
name = mido.get_input_names()
print(name)
inport = mido.open_input(name[0])
print(inport)
msg = inport.receive()
for msg in inport:
print(msg)
print(msg)
parser.add_argument('-c', '--clear', action='store_true', help='clear the display on exit')
args = parser.parse_args()
# Create NeoPixel object with appropriate configuration.
self.strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
# Initialize the library (must be called once before other functions).
self.strip.begin()
ledstrip = LedStrip()
ports = mido.get_input_names()
for port in ports:
if "Through" not in port and "RPi" not in port and "RtMidOut" not in port:
try:
inport = mido.open_input(port)
print("In-port set to "+port)
except:
print ("Failed to set "+port+" as in-port")
green = 120
red = 100
blue = 220
while True:
for msg in inport.iter_pending():
note = find_between(str(msg), "note=", " ")
original_note = note
note = int(note)
if "note_off" in str(msg):
velocity = 0
def __init__(self,
input_midi_ports,
output_midi_ports,
texture_type,
passthrough=True,
playback_offset=0.0):
self._texture_type = texture_type
self._passthrough = passthrough
self._playback_offset = playback_offset
# When `passthrough` is True, this is the set of open MIDI note
# pitches.
self._open_notes = set()
# This lock is used by the serialized decorator.
self._lock = threading.RLock()
# A dictionary mapping a compiled MidiSignal regex to a condition variable
# that will be notified when a matching messsage is received.
self._signals = {}
# A dictionary mapping a compiled MidiSignal regex to a list of functions
# that will be called with the triggering message in individual threads when
# a matching message is received.
self._callbacks = defaultdict(list)
# A dictionary mapping integer control numbers to most recently-received
# integer value.
self._control_values = {}
# Threads actively being used to capture incoming messages.
self._captors = []
# Potentially active player threads.
self._players = []
self._metronome = None
# Open MIDI ports.
if input_midi_ports:
for port in input_midi_ports:
if isinstance(port, ports.BaseInput):
inport = port
else:
virtual = port not in get_input_names()
if virtual:
logging.info(
"Opening '%s' as a virtual MIDI port for input.",
port)
inport = open_input(port, virtual=virtual)
# Start processing incoming messages.
inport.callback = self._timestamp_and_handle_message
# this is needed because otherwise inport will get
# garbage collected and stop receiving input events
self._inport = inport
else:
logging.warning('No input port specified. Capture disabled.')
self._inport = None
outports = []
for port in output_midi_ports:
if isinstance(port, ports.BaseInput):
outports.append(port)
else:
virtual = port not in get_output_names()
if virtual:
logging.info(
"Opening '%s' as a virtual MIDI port for output.",
port)
outports.append(open_output(port, virtual=virtual))
self._outport = ports.MultiPort(outports)
r = redis.StrictRedis(host=config.get('redis', 'hostname'),
port=config.getint('redis', 'port'),
db=0)
response = r.client_list()
except redis.ConnectionError:
print "Error: cannot connect to redis server"
exit()
# this is only for debugging
print('------ INPUT ------')
for port in mido.get_input_names():
print(port)
print('-------------------------')
try:
inputport = mido.open_input(config.get('midi', 'device'))
if debug > 0:
print "Connected to MIDI input"
except:
print "Error: cannot connect to MIDI input"
exit()
while True:
time.sleep(config.getfloat('general', 'delay'))
for msg in inputport.iter_pending():
if debug > 0:
print msg
if hasattr(msg, "control"):
def listen(self):
with mido.open_input(self.inputs[0]) as port:
start = time.time()
for msg in port:
if not self.pause:
self.queue.append((msg, time.time() - start))
system('say ' + text)
waiting = (len(text) / 7)
time.sleep(1 + waiting)
if restart:
system('./config.sh start')
# my_say(" First test")
# my_say(" This is my very first test. You should see config.sh appear later than before")
# my_say(" And now it should appear much faster")
pressed_notes = []
times_up = False
correct_answer = False
with mido.open_input(input1) as inport:
while (True):
thechord = choose_random_chord()
chord_name, parsed_chord = parse_chord(thechord)
print(parsed_chord)
print(chord_name)
say_chord(chord_name[0])
times_up = False
correct_answer = False
for msg in inport:
if 'note' not in dir(msg):
continue
if msg.is_meta:
except Exception as err:
print(err)
print("connect failed")
def wsSendWithTry(toSend):
global ws
try:
ws.send(toSend)
except:
traceback.print_exc()
while True:
with mido.open_input('IAC Driver IAC Bus 1') as inport:
# print inport
for msg in inport:
print(msg)
if msg.type == "note_on":
print(msg.note)
if msg.note == 0:
wsSendWithTry(
json.dumps({
'message': 'videoplay',
'url': '1912008_hauntedNight_HD_BG.mp4',
'looping': 'looping',
'instance': 'overlay',
'type': 'mp4'
}))
def monitor_midi(): #Monitor new midi messages
with mido.open_input('HDSPMx73554b MIDI 3') as port:
for message in port:
if message.type != 'quarter_frame':
last_time = message
print last_time
def main():
""" The main loop """
status_color = None
animations = []
leds = [(0, 0, 0)] * PIANO_KEYS
usb_device_name = detect_midi_device()
if usb_device_name:
print("Opening {0} port".format(usb_device_name))
midi_input = mido.open_input(usb_device_name)
else:
print("No MIDI device detected")
midi_input = None
print("Starting main loop...")
configuration['mode'] = 'demo'
configuration['gamma_correction'] = False
configuration['animation'] = 1
configuration['demo_delay'] = 60 * 5
configuration['demo_done'] = 60 * 60
configuration['status_brightness'] = 255
# Start in demo on startup
last_key_time = time.time() - configuration['demo_delay']
STRIP.begin()
STRIP.show()
# Used to detect the "secret chord" for controlling various aspects
chord = set()
#running_animation = animation.RunningAnimation(PIANO_KEYS)
#animations.append(running_animation)
practice_timer = timer.Timer()
animations.append(practice_timer)
#animations.append(animation.BeatAnimation(44, 80))
try:
while True:
idle_time = time.time() - last_key_time
if idle_time > configuration['demo_done']:
if configuration['mode'] != 'sleep':
configuration['mode'] = 'sleep'
status_color = 0x000000
STRIP.clear()
STRIP.show()
elif idle_time > configuration['demo_delay']:
if configuration['mode'] != 'demo':
configuration['mode'] = 'demo'
# Hide "forever" while in demo mode. TODO: Improve with special case.
practice_timer.hide(1000 * 60 * 60 * 24 * 365)
elif configuration['mode'] != 'midi':
configuration['mode'] = 'midi'
# Apply an optional filter (default is to black out LEDs).
# For now, directly clear the buffer.
leds = [(0, 0, 0)] * PIANO_KEYS
if set([0, 1]).issubset(chord):
print("Secret chord pressed")
if 2 in chord:
print("Red status lights")
status_color = 0xFF0000
if 3 in chord:
status_color = 0x00FF00
if 4 in chord:
status_color = 0x0000FF
if 5 in chord:
status_color = 0xFFFFFF
if 6 in chord:
status_color = 0xFFFC7F
if 7 in chord:
status_color = 0x000000
draw_status(status_color)
# 15 is the second C note from the left. Toggle brightness down.
if 15 in chord:
configuration['status_brightness'] -= 1
if configuration['status_brightness'] < 1:
configuration['status_brightness'] = 1
draw_status(status_color)
# 16 is the second D note from the left. Toggle brightness up.
if 17 in chord:
configuration['status_brightness'] += 1
if configuration['status_brightness'] > 255:
configuration['status_brightness'] = 255
draw_status(status_color)
if 14 in chord:
practice_timer.restart()
#for i, pixel in enumerate(leds):
# r, g, b = (pixel)
# leds[i] = (int(r/1.2), int(g/1.2), int(b/1.2))
for current_animation in animations:
new_frame = current_animation.get_frame()
for i, frame_pixel in enumerate(new_frame):
r, g, b = (frame_pixel)
if r > 0 or g > 0 or b > 0:
leds[i] = color_blend(leds[i], frame_pixel)
animations = [x for x in animations if not x.is_complete()]
for i, pixel in enumerate(leds):
r, g, b = (pixel)
if configuration['gamma_correction']:
r = GAMMA[r]
g = GAMMA[g]
b = GAMMA[b]
STRIP.setPixelColor(i, r, g, b)
STRIP.show()
# Experiment to see how long we need to sleep - it seems that this may cause problems
# if too short
time.sleep(0.01)
if midi_input is not None:
for message in midi_input.iter_pending():
print(message)
last_key_time = time.time()
practice_timer.hide(10 * 1000)
if message.type == 'note_on':
note = message.note - FIRST_MIDI_NOTE
chord.add(note)
#running_animation.key_pressed(message.velocity * 2)
animations.append(
animation.PressureKeyPressAnimation(
PIANO_KEYS, note, message.velocity * 2, 3000))
#animations.append(animation.ChristmasKeyPressAnimation(PIANO_KEYS, note, message.velocity * 2))
#animations.append(animation.RunLeftAnimation(note))
#animations.append(animation.LightUpAnimation(PIANO_KEYS, note))
if message.type == 'note_off':
note = message.note - FIRST_MIDI_NOTE
if note in chord:
chord.remove(note)
if configuration['mode'] == 'demo':
if randint(0, 15) == 0:
# Here we would get a key press
key_pressed = randint(0, PIANO_KEYS - 1)
animations.append(
animation.ChristmasKeyPressAnimation(
PIANO_KEYS, key_pressed, randint(1, 255), 1000))
#animations.append(animation.PressureKeyPressAnimation(PIANO_KEYS, key_pressed, randint(1, 255), 1000))
#animations.append(animation.KeyPressAnimation(PIANO_KEYS, key_pressed))
#animations.append(animation.RunLeftAnimation(key_pressed))
except KeyboardInterrupt:
print("Exiting...")
STRIP.clear()
STRIP.show()
STRIP.close()
if midi_input:
midi_input.close()
import mido
outport = mido.open_output('Springbeats vMIDI1 2')
with mido.open_input('Babyface Midi Port 1 0') as inport:
for msg in inport:
print(msg)
outport.send(msg) #just send the message right through
def open_device(self, device_name, callback):
self.inport = mido.open_input(device_name)
self.inport.callback = callback
import mido
from ConfigurationSetup import *
#configuration Setup
cfgFile="config.cfg"
config=parse_cfg(cfgFile)
#receive Data
with mido.open_input(config["inPort"]) as inputPort:
for msg in inputPort:
print (msg)
