def main(args=None):
try:
midiin, inport_name = open_midiport('Nord Piano 2 MIDI Output', "input");
midiout, outport_name = open_midiport('Nord Piano 2 MIDI Input', "output");
except IOError as exc:
print(exc);
return 1;
except (EOFError, KeyboardInterrupt):
return 0;
dispatcher = MidiDispatcher(midiin, midiout);
print("Entering main loop. Press Control-C to exit.")
try:
dispatcher.start();
while True:
time.sleep(1);
except KeyboardInterrupt:
dispatcher.stop();
dispatcher.join();
print('');
finally:
print("Exit.");
midiin.close_port();
midiout.close_port();
del midiin;
del midiout;
return 0
def init(self, midi_device_name):
self.conn = None
self.midiin = None
self.midiout = None
try:
self.conn = socket.create_connection((self.host, self.port))
except (ConnectionRefusedError, KeyboardInterrupt):
print("Could not connect to voctocore")
sys.exit()
@atexit.register
def close_conn():
self.conn and self.conn.close()
try:
self.midiin, self.midi_portname = open_midiport(midi_device_name)
except (EOFError, KeyboardInterrupt):
print("Opening midi port failed")
sys.exit()
@atexit.register
def close_midi():
self.midiin and self.midiin.close_port()
self.midiin.set_callback(self.midiin_callback)
if self.feedback_mode:
try:
self.midiout, _ = open_midiport(midi_device_name,
type_='output')
except (EOFError, KeyboardInterrupt):
print("Opening midi output port failed")
sys.exit()
def main(args=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('-m', '--mpresstocc', action="store_true",
help='Map mono pressure (channel aftertouch) to CC')
parser.add_argument('-r', '--mapccrange', action="store_true",
help='Map controller value range to min/max value range')
parser.add_argument('-t', '--transpose', action="store_true",
help='Transpose note on/off event note values')
parser.add_argument('-i', '--inport',
help='MIDI input port number (default: ask)')
parser.add_argument('-o', '--outport',
help='MIDI output port number (default: ask)')
parser.add_argument('-v', '--verbose', action="store_true",
help='verbose output')
parser.add_argument('filter-args', nargs="*", type=int,
help='MIDI filter argument(s)')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.WARNING,)
try:
midiin, inport_name = open_midiport(args.inport, "input")
midiout, outport_name = open_midiport(args.outport, "input")
except IOError as exc:
print(exc)
return 1
except (EOFError, KeyboardInterrupt):
return 0
filters = []
if args.transpose:
filters.append(Transpose(transpose=args.filter_args[0]))
if args.mpresstocc:
MonoPressureToCC(cc=args.filter_args[0]))
if args.mapccrange:
filters.append(MapControllerValue(*args.filter_args))
dispatcher = MidiDispatcher(midiin, midiout, *filters)
print("Entering main loop. Press Control-C to exit.")
try:
dispatcher.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
dispatcher.stop()
dispatcher.join()
print('')
finally:
print("Exit.")
midiin.close_port()
midiout.close_port()
del midiin
del midiout
return 0
def reinitialize_midiinputs(self):
# If the ports are already open, close them before reopening them
if self.midiport_guitarWing_available:
self.midiin_guitarWing.close_port()
# del self.midiin_guitarWing
if self.midiport_audioItf_available:
self.midiout_audioItf.close_port()
# del self.midiout_audioItf
self.midiport_guitarWing_available = False
self.midiport_audioItf_available = False
global MIDI_BUS_CONFIGURATION_EMERGENCY_CONTROL
global MIDI_BUS_CONFIGURATION_GUITAR_WING
global MIDI_BUS_CONFIGURATION_ABLETON_IN_VOICE_FX
global MIDI_BUS_CONFIGURATION_ABLETON_OUT
global MIDI_BUS_CONFIGURATION_ABLETON_IN_GTR
global MIDI_BUS_CONFIGURATION_AUDIO_INTERFACE_OUT
#Try to initialize the MIDI ports which might not be available all the time
try:
self.midiin_guitarWing, self.port_name_guitarWing = open_midiport(MIDI_BUS_CONFIGURATION_GUITAR_WING, type_ = "input", interactive=False)
self.midiport_guitarWing_available = True
except (ValueError):
log.info("Input Guitar Wing MIDI port unavailable")
if self.midiport_abletonInGtr_available == False:
try:
self.midiin_abletonInGtr, self.port_name_abletonInGtr = open_midiport(MIDI_BUS_CONFIGURATION_ABLETON_IN_GTR, type_ = "input", interactive=False)
self.midiport_abletonInGtr_available = True
except (ValueError):
log.info("Input Ableton Gtr MIDI port unavailable")
try:
self.midiout_audioItf, self.port_name_audioItf = open_midiport(MIDI_BUS_CONFIGURATION_AUDIO_INTERFACE_OUT, type_ = "output", interactive=False)
self.midiport_audioItf_available = True
except (ValueError):
log.info("Output Audio interface MIDI port unavailable")
if self.midiport_guitarWing_available:
self.midiin_guitarWing.set_callback(MidiInputHandler_guitarWing(self.midiin_guitarWing, self.midiout_abletonOut))
log.info(" *** Guitar Wing callback is attached")
else:
log.info(" ###### Unable to attach the Guitar Wing callback, send a MIDI reinit command once the Guitar Wing is connected")
if self.midiport_abletonInGtr_available and self.midiport_audioItf_available:
self.midiin_abletonInGtr.set_callback(MidiInputHandler_abletonGtr(self.midiin_abletonInGtr, self.midiout_audioItf))
log.info(" *** Guitar Amp control callback is attached")
else:
log.info(" ###### Unable to attach the Guitar Amp control callback, send a MIDI reinit command once the Audio interface is connected")
def _open_midi(self):
try:
port_names = rtmidi.MidiIn().get_ports()
port_number = port_names.index(self._port_name)
except (ValueError, IOError) as e:
log.debug("_open_midi, port_names=%s, e=%s", port_names, e)
return False
try:
if self._midi_in is None:
self._midi_in, _ = open_midiport(port_number, "input", use_virtual=False, interactive=False)
if self._midi_out is None:
self._midi_out, _ = open_midiport(port_number, "output", use_virtual=False, interactive=False)
except IOError as e:
log.debug("_open_midi, port_number=%s, in=%s, out=%s, IOError=%s", self._port_number, self._midi_in is not None, self._midi_out is not None, e)
return False
return True
def _connect(self):
if not open_midiport:
self.logger.warning(
'rtmidi library not available MidiInput cannot connect.')
return
try:
self.midiin, self.port_name = open_midiport(self.port)
except IOError as err:
print("Failed to initialize MIDI interface:", err)
self.midiin = None
self.port_name = None
self.connected = False
return
except EOFError as err:
print("Failed to initialize MIDI interface")
self.midiin = None
self.port_name = None
self.connected = False
return
except:
print("Failed to initialize MIDI interface")
self.midiin = None
self.port_name = None
self.connected = False
return
print("Midi input initialized on port: " + self.port_name)
self.connected = True
def _test():
import sys
logging.basicConfig(level=logging.DEBUG, format="%(message)s")
try:
midiout, port = open_midiport(
sys.argv[1] if len(sys.argv) > 1 else None,
"output",
client_name="RtMidi Sequencer")
time.sleep(1)
except (IOError, ValueError) as exc:
return "Could not open MIDI input: %s" % exc
except (EOFError, KeyboardInterrupt):
return
seq = StepSequencer(midiout, bpm=200, ppqn=10, loop=False, cols=4)
seq.add(0, 0)
# seq.add(1, 1)
seq.add(2, 2)
seq.add(3, 2)
try:
seq.start()
seq.join()
finally:
seq.stop()
midiout.close_port()
del midiout
def __init__(self, out_rule=None):
if out_rule:
midiout = rtmidi.MidiOut()
label, index = out_rule
matches = [
x for x in enumerate(midiout.get_ports()) if label in x[1]
]
device = matches[index]
self.midi_out = midiout.open_port(device[0], name=device[1])
else:
self.midi_out, port = open_midiport(None,
"LaunchpadSequencer",
use_virtual=True)
time.sleep(1)
self.seq = StepSequencer(self.midi_out,
bpm=200,
loop=True,
cols=16,
pages=16,
column_callback=self.set_column)
self.lp = instruments.MultiLaunchpad(
number=2, modes=[LaunchpadStepSequencerMode(sequencer=self.seq)])
self.seq.run()
self.seq.join()
def main():
log = logging.getLogger('test_midiin_callback')
logging.basicConfig(level=logging.DEBUG)
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiin, port_name = open_midiport(port)
except (EOFError, KeyboardInterrupt):
sys.exit()
print("Attaching MIDI input callback handler.")
midiin.set_callback(MidiInputHandler(port_name))
print("Entering main loop. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(1)
parser = optparse.OptionParser()
parser.add_option("-d", "--debug", action="store_true", dest="debug")
global options
##############
options, args = parser.parse_args(sys.argv)
dbus.mainloop.qt.DBusQtMainLoop(set_as_default=True)
app=QtGui.QApplication(args)
qpaeq_main=QPaeq()
qpaeq_main.show()
sys.exit(app.exec_())
except KeyboardInterrupt:
print('')
finally:
print("Exit.")
midiin.close_port()
del midiin
def _open_port(self, interface_type, midi_port, is_virtual=False):
"""
Opens the specified MIDI port for the entered midi_callback
Parameters:
* interface_type: which interface to open: 'input' or 'output'
* midi_port: MIDI port used to open the MIDI interface
* is_virtual: whether or not the port is virtual
Returns:
* In case of opening a virtual port, it will return a MIDI interface
"""
if not is_virtual:
self.__log.debug("Opening MIDI port: %s", PrettyFormat(midi_port))
port_name = None
client_name = None
else:
self.__log.debug("Opening Virtual MIDI port")
port_name = midi_port
midi_port = None
client_name = VIRTUAL_PREFFIX[:-1]
try:
midi_interface = open_midiport(port=midi_port,
type_=interface_type,
use_virtual=is_virtual,
interactive=False,
client_name=client_name,
port_name=port_name)[0]
except:
error = traceback.format_exc()
self.__log.info(error)
self._free_midi()
sys.exit()
return midi_interface
def __init__(self, output_controller, command=None, channel=None, midi_port=None, calibrate=False):
self._output_controller = output_controller
self._tracked_command = command
self._tracked_channel = channel
self._calibrate = calibrate
self._midi_in, port_name = open_midiport(midi_port, "input")
self._midi_in.set_callback(self._callback)
def __init__(self, port_number, service_queue):
"""Initialize a midi output from a port number.
Hold onto a reference to the queue that will service this input during
main thread control processing.
"""
self._message_buffer = message_buffer = deque()
self._controllers = set()
port, name = open_midiport(port_number)
self.name = name
self._port = port
# pass weak references to message handler to avoid accidentally keeping
# this input alive
handler_ref = weakref.ref(self)
def parse(event, _):
"""Callback called by the thread handling midi receipt.
Parse the message into a more useful type, and queue up the message
as well as the input to be serviced.
"""
(b0, b1, b2), _ = event
event_type, channel = b0 >> 4, b0 & 15
message = (event_type_to_mapping[event_type](channel, b1), b2)
# put the message into the buffer to be handled by this input
message_buffer.appendleft(message)
# queue this input up for servicing
service_queue.put(handler_ref)
port.set_callback(parse)
def new_midi(port, serial):
try:
midi_in, midi_port = open_midiport(port)
except (EOFError, KeyboardInterrupt):
exit()
def cb(event, data=None):
msg, dt = event
status = msg[0]
data = msg[1:]
channel = status & 0x0f
cmd = status & 0xf0
if cmd == 144: # note on
serial.write(chr(channel))
note = data[0]
speriod = micro_periods[note] / (40 * 2)
serial.write(chr(speriod >> 8))
serial.write(chr(speriod & 0xff))
if cmd == 128: # note off
serial.write(chr(channel))
serial.write("\x00\x00")
# print("[%s] ch:%d cmd:%d %r" % (midi_port, channel, cmd, data))
print("Attaching MIDI input callback handler.")
midi_in.set_callback(cb)
return midi_in
def __init__(self):
print('bsp init')
self.midiout, self.port_out_name = open_midiport(
-1,
'output',
client_name='bsp',
port_name='bsp output_port'
)
def main(args=None):
"""Main program function.
Parses command line (parsed via ``args`` or from ``sys.argv``), detects
and optionally lists MIDI input ports, opens given MIDI input port,
and attaches MIDI input handler object.
"""
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument('-b',
'--backend',
choices=sorted(BACKEND_MAP),
help='MIDI backend API (default: OS dependant)')
parser.add_argument(
'-p',
'--port',
help='MIDI input port name or number (default: open virtual input)')
parser.add_argument('-v',
'--verbose',
action="store_true",
help='verbose output')
parser.add_argument(dest='config',
metavar="CONFIG",
help='Configuration file in YAML syntax.')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(
format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.WARNING)
try:
midiin, port_name = open_midiport(args.port,
use_virtual=True,
api=BACKEND_MAP.get(
args.backend,
rtmidi.API_UNSPECIFIED),
client_name='midi2command',
port_name='MIDI input')
except (IOError, ValueError) as exc:
return "Could not open MIDI input: %s" % exc
except (EOFError, KeyboardInterrupt):
return
log.debug("Attaching MIDI input callback handler.")
midiin.set_callback(MidiInputHandler(port_name, args.config))
log.info("Entering main loop. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(1)
except KeyboardInterrupt:
print('')
finally:
midiin.close_port()
del midiin
def __init__(self):
"""
コンストラクタ
"""
self.midi_out, self.port = open_midiport(None,
"output",
client_name='sender')
self.events = [] # 送信したMIDIイベントの情報
self.index = 0 # 次に送るMIDIイベントのインデックス
def __init__(self):
super().__init__()
try:
self.midiout, self.port_name = open_midiport(None, "output", api=rtmidi.API_UNIX_JACK,
client_name="PuyoMusic", port_name="MIDI Out", use_virtual=True)
except (EOFError, KeyboardInterrupt):
sys.exit()
subprocess.call("./linuxsampler.sh", shell=True)
time.sleep(6)
def main(args=None):
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.DEBUG)
try:
input_ports = []
for ip in mconfig.inputs:
midiin, inport_name = open_midiport(ip["name"], "input")
input_ports.append(InputPort(midiin, ip["number"], ip["mono"]))
midiout, outport_name = open_midiport(mconfig.output, "output")
except IOError as exc:
print(exc)
return 1
except (EOFError, KeyboardInterrupt):
return 0
dispatcher = MidiDispatcher(input_ports, midiout)
clock = ClockTimer()
print("Entering main loop. Press Control-C to exit.")
try:
dispatcher.start()
clock.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
clock.stop()
clock.join()
dispatcher.stop()
dispatcher.join()
print('')
finally:
print("Exit.")
for ip in input_ports:
ip.midiin.close_port()
del ip.midiin
midiout.close_port()
del midiout
return 0
def setup_midi(self):
log.info('setting up midi')
self.midiin, self.port_in_name = open_midiport(
self.port_in,
'input',
client_name='euclid',
port_name='euclid input port'
)
log.info('set midi in port: {0}'.format(self.port_in_name))
self.midiin.ignore_types(timing=False)
log.info('listening for clock on midi in')
self.midiout, self.port_out_name = open_midiport(
self.port_out,
'output',
client_name='euclid',
port_name='euclid output_port'
)
log.info('set midi out port: {0}'.format(self.port_out_name))
self.midiin.set_callback(self.on_midi_in)
log.info('set midi in callback')
self._wallclock = time.time()
def main(args=None):
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
ap.add_argument('-b', '--bpm', type=float, default=100,
help="Beats per minute (BPM) (default: %(default)s)")
ap.add_argument('-c', '--channel', type=int, default=10, metavar='CH',
help="MIDI channel (default: %(default)s)")
ap.add_argument('-p', '--port',
help="MIDI output port number (default: ask)")
ap.add_argument('-k', '--kit', type=int, metavar='KIT',
help="Drum kit MIDI program number (default: none)")
ap.add_argument('--bank-msb', type=int, metavar='MSB',
help="MIDI bank select MSB (CC#00) number (default: none)")
ap.add_argument('--bank-lsb', type=int, metavar='MSB',
help="MIDI bank select LSB (CC#32) number (default: none)")
ap.add_argument('-H', '--humanize', type=float, default=0.0, metavar='VAL',
help="Random velocity variation (float, default: 0, try ~0.03)")
ap.add_argument('pattern', nargs='?', type=argparse.FileType(),
help="Drum pattern file (default: use built-in pattern)")
args = ap.parse_args(args if args is not None else sys.argv[1:])
if args.pattern:
pattern = args.pattern.read()
else:
pattern = FUNKYDRUMMER
kit = (args.bank_msb, args.bank_lsb, args.kit)
pattern = Drumpattern(pattern, kit=kit, humanize=args.humanize)
try:
midiout, port_name = open_midiport(args.port, "output",
api=rtmidi.API_UNIX_JACK,
client_name="drumseq", port_name="MIDI Out")
except (EOFError, KeyboardInterrupt):
return
seq = Sequencer(midiout, pattern, args.bpm, args.channel - 1)
print("Playing drum loop at %.1f BPM, press Control-C to quit." % seq.bpm)
try:
while True:
sleep(1)
except KeyboardInterrupt:
print('')
finally:
seq.done = True # And kill it.
seq.join()
del midiout
print("Done")
def setport(self, port):
for n in range(
10
): # wait up to 10 seconds for app to launch and the port be available
try:
self.midiout, self.port_name = open_midiport(port[0],
port[1],
interactive=False)
break
except (EOFError, KeyboardInterrupt):
sys.exit()
except ValueError as err:
print('count: {} Error: {}'.format(n, err.args))
sleep(1)
def __init__(self, octoeuclid=None, gate_len=0.01):
"""
"""
self.midiin, self.port_in_name = open_midiport(
-1,
'input',
client_name='euclid',
port_name='euclid input_port'
)
self.midiin.ignore_types(timing=False)
self.midiout, self.port_out_name = open_midiport(
-1,
'output',
client_name='euclid',
port_name='euclid output_port'
)
self.midiin.set_callback(self.on_midi_in)
self.octoeuclid = octoeuclid
self.gate_len = gate_len
self.ppqn = 24
self._ppqn_count = 0
def init(self, midi_device_name):
self.conn = None
self.midiin = None
self.midiout = None
try:
self.conn = socket.create_connection((self.host, self.port))
except (ConnectionRefusedError, KeyboardInterrupt):
print("Could not connect to voctocore")
sys.exit()
@atexit.register
def close_conn():
self.conn and self.conn.close()
try:
self.midiin, self.midi_portname = open_midiport(midi_device_name)
except (EOFError, KeyboardInterrupt):
print("Opening midi port failed")
sys.exit()
@atexit.register
def close_midi():
self.midiin and self.midiin.close_port()
self.midiin.set_callback(self.midiin_callback)
if self.feedback_mode:
try:
self.midiout, _ = open_midiport(
midi_device_name,
type_='output'
)
except (EOFError, KeyboardInterrupt):
print("Opening midi output port failed")
sys.exit()
def main(args=None):
"""Save revceived sysex message to directory given on command line."""
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument(
'-o',
'--outdir',
default=os.getcwd(),
help="Output directory (default: current working directory).")
parser.add_argument('-p',
'--port',
help='MIDI output port number (default: ask)')
parser.add_argument('-v',
'--verbose',
action="store_true",
help='verbose output')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.INFO)
try:
midiin, port = open_midiport(args.port)
except IOError as exc:
log.error(exc)
return 1
except (EOFError, KeyboardInterrupt):
return 0
ss = SysexSaver(port, args.outdir, args.verbose)
log.debug("Attaching MIDI input callback handler.")
midiin.set_callback(ss)
log.debug("Enabling reception of sysex messages.")
midiin.ignore_types(sysex=False)
log.info("Waiting for sysex reception. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(1)
except KeyboardInterrupt:
print('')
finally:
log.debug("Exit.")
midiin.close_port()
del midiin
return 0
def __init__(self):
# Make this thread a daemon so it ends when the main thread exits
super(NoteActor, self).__init__(use_daemon_thread=True)
self.midi_out, self.midi_out_name = midiutil.open_midiport(
port='IAC',
type_='output')
self.seq = [{'i': 0, 'r': euclidean_rhythm(0,0), 'n': 60},
{'i': 1, 'r': euclidean_rhythm(0,0), 'n': 61},
{'i': 2, 'r': euclidean_rhythm(0,0), 'n': 62},
{'i': 3, 'r': euclidean_rhythm(0,0), 'n': 63},
{'i': 4, 'r': euclidean_rhythm(0,0), 'n': 64},
{'i': 5, 'r': euclidean_rhythm(0,0), 'n': 65}]
self.mutes = [False]*len(self.seq)
def _test():
import sys
from rtmidi.midiconstants import NOTE_ON, NOTE_OFF
from rtmidi.midiutil import open_midiport
logging.basicConfig(level=logging.DEBUG, format="%(message)s")
try:
midiout, port = open_midiport(
sys.argv[1] if len(sys.argv) > 1 else None,
"output",
client_name="RtMidi Sequencer")
except (IOError, ValueError) as exc:
return "Could not open MIDI input: %s" % exc
except (EOFError, KeyboardInterrupt):
return
seq = SequencerThread(midiout, bpm=100, ppqn=240)
def add_quarter(tick, note, vel=100):
seq.add((NOTE_ON, note, vel), tick)
seq.add((NOTE_OFF, note, 0), tick=tick + seq.ppqn)
t = 0
p = seq.ppqn
add_quarter(t, 60)
add_quarter(t + p, 64)
add_quarter(t + p * 2, 67)
add_quarter(t + p * 3, 72)
t = p * 5
add_quarter(t, 60)
add_quarter(t + p, 64)
add_quarter(t + p * 2, 67)
add_quarter(t + p * 3, 72)
try:
seq.start()
time.sleep(60. / seq.bpm * 4)
seq.bpm = 150
time.sleep(60. / seq.bpm * 6)
finally:
seq.stop()
midiout.close_port()
del midiout
def main(args=None):
"""Main program function.
Parses command line (parsed via ``args`` or from ``sys.argv``), detects
and optionally lists MIDI input ports, opens given MIDI input port,
and attaches MIDI input handler object.
"""
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument('-b', '--backend',
choices=sorted(BACKEND_MAP),
help='MIDI backend API (default: OS dependant)')
parser.add_argument('-p', '--port',
help='MIDI input port name or number (default: open virtual input)')
parser.add_argument('-v', '--verbose',
action="store_true", help='verbose output')
parser.add_argument(dest='config', metavar="CONFIG",
help='Configuration file in YAML syntax.')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.WARNING)
try:
midiin, port_name = open_midiport(args.port, use_virtual=True,
api=BACKEND_MAP.get(args.backend, rtmidi.API_UNSPECIFIED),
client_name='midi2command', port_name='MIDI input')
except (IOError, ValueError) as exc:
return "Could not open MIDI input: %s" % exc
except (EOFError, KeyboardInterrupt):
return
log.debug("Attaching MIDI input callback handler.")
midiin.set_callback(MidiInputHandler(port_name, args.config))
log.info("Entering main loop. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(1)
except KeyboardInterrupt:
print('')
finally:
midiin.close_port()
del midiin
def _test():
import sys
from rtmidi.midiconstants import NOTE_ON, NOTE_OFF
from rtmidi.midiutil import open_midiport
logging.basicConfig(level=logging.DEBUG, format="%(message)s")
try:
midiout, port = open_midiport(
sys.argv[1] if len(sys.argv) > 1 else None,
"output",
client_name="RtMidi Sequencer")
except (IOError, ValueError) as exc:
return "Could not open MIDI input: %s" % exc
except (EOFError, KeyboardInterrupt):
return
seq = SequencerThread(midiout, bpm=100, ppqn=240)
def add_quarter(tick, note, vel=100):
seq.add((NOTE_ON, note, vel), tick)
seq.add((NOTE_OFF, note, 0), tick=tick + seq.ppqn)
t = 0
p = seq.ppqn
add_quarter(t, 60)
add_quarter(t + p, 64)
add_quarter(t + p * 2, 67)
add_quarter(t + p * 3, 72)
t = p * 5
add_quarter(t, 60)
add_quarter(t + p, 64)
add_quarter(t + p * 2, 67)
add_quarter(t + p * 3, 72)
try:
seq.start()
time.sleep(60. / seq.bpm * 4)
seq.bpm = 150
time.sleep(60. / seq.bpm * 6)
finally:
seq.stop()
midiout.close_port()
def main(args=None):
"""Save revceived sysex message to directory given on command line."""
parser = argparse.ArgumentParser(description=__doc__)
padd = parser.add_argument
padd('-o', '--outdir', default=os.getcwd(),
help="Output directory (default: current working directory).")
padd('-p', '--port',
help='MIDI output port number (default: ask)')
padd('-v', '--verbose', action="store_true",
help='verbose output')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.INFO)
try:
midiin, port = open_midiport(args.port)
except IOError as exc:
log.error(exc)
return 1
except (EOFError, KeyboardInterrupt):
return 0
ss = SysexSaver(port, args.outdir, args.verbose)
log.debug("Attaching MIDI input callback handler.")
midiin.set_callback(ss)
log.debug("Enabling reception of sysex messages.")
midiin.ignore_types(sysex=False)
log.info("Waiting for sysex reception. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(1)
except KeyboardInterrupt:
print('')
finally:
log.debug("Exit.")
midiin.close_port()
del midiin
return 0
def open_port_by_name(name, inout):
if inout == "input":
# noinspection PyUnresolvedReferences,PyUnresolvedReferences
ports = rtmidi.MidiIn(get_api_from_environment(rtmidi.API_UNSPECIFIED)).get_ports()
elif inout == "output":
# noinspection PyUnresolvedReferences,PyUnresolvedReferences
ports = rtmidi.MidiOut(get_api_from_environment(rtmidi.API_UNSPECIFIED)).get_ports()
else:
eprint("Call with either input or output as inout argument")
raise PortNotFoundError
if ports:
for portno, pname in enumerate(ports):
if name.lower() in pname.lower():
return open_midiport(portno, inout)
raise PortNotFoundError
else:
print("No MIDI {} ports found.".format(inout))
raise PortNotFoundError
def open_midiout(cls, device):
if device.get("virtual", False):
midiout, port = open_midiport(
None,
device["device_match"],
use_virtual=True,
client_name=device["device_match"],
port_name=device["device_match"],
)
else:
mo = rtmidi.MidiOut()
matches = [
x for x in enumerate(mo.get_ports())
if device["device_match"] in x[1]
]
d = matches[0]
print("opening device", d)
midiout = mo.open_port(d[0], name=d[1])
return midiout
def bootstrap_midi_device():
port = sys.argv[1] if len(sys.argv) > 1 else 0
try:
midiin, port_name = open_midiport(port)
except (EOFError, KeyboardInterrupt):
sys.exit()
print("Attaching Teensy/arduino MIDI input callback handler. port_name: " +
port_name)
midiin.set_callback(MidiInputHandler(port_name))
# TODO: kill thread ...
print("Entering main loop. Press Control-C to exit.")
while True:
time.sleep(0.05)
update()
print("Exit.")
channel = None
data1 = data2 = None
num_bytes = len(event)
if num_bytes >= 2:
data1 = event[1]
if num_bytes >= 3:
data2 = event[2]
if status == 0x90: # note on
cosmic_ray_events.append((time.time(), self.powerlevel))
# todo: if status is a particular CC, update powerlevel
try:
midiin, port_name = open_midiport("USB Uno MIDI Interface",
use_virtual=True)
print "Attaching MIDI input callback handler."
midiin.set_callback(MidiInputHandler(port_name))
except (IOError, EOFError, KeyboardInterrupt):
print "WARNING: No MIDI input ports detected."
#-------------------------------------------------------------------------------
# Create OSC listener for timeline/effects control
if osc_support:
def default_handler(path, tags, args, source):
return
def effect_opacity_handler(path, tags, args, source):
addr = path.split("/")
current_page = page_num
global_view.display_page(page_num)
for sm in get_current_seq_page():
sm.display()
def toggle_randomize():
global randomize
randomize = not randomize
global_view.display_randomize(randomize)
# Open an output midiport whose name contains the drum out port name string.
# Use this port to send all notes generated by the sequencers
drum_out, drum_out_name = midiutil.open_midiport(
port=constants.DRUM_OUT_PORT_NAME,
type_='output')
print('Opening port \'{0}\' for output'.format(drum_out_name))
# Create note thread for sending notes generated by the sequencers
# to prevent timing errors
note_queue = Queue()
def send_note(queue):
while True:
midi_message = queue.get()
drum_out.send_message(midi_message)
note_thread = Thread(target=send_note, args=(note_queue,))
note_thread.daemon = True
note_thread.start()
def __init__(self, port):
self.port = port
self._wallclock = time.time()
def __call__(self, event, data=None):
global g_toggle
message, deltatime = event
self._wallclock += deltatime
midiSolver(message)
#print("@%0.6f %r" % (deltatime, message))
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiin, port_name = open_midiport(port,
use_virtual=True,
client_name=client_name,
port_name="in")
except (EOFError, KeyboardInterrupt):
sys.exit()
print("Attaching MIDI input callback handler.")
midiin.set_callback(MidiInputHandler(port_name))
print("Entering main loop. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
testAll()
while True:
time.sleep(1)
except KeyboardInterrupt:
def set_midiout(port):
global midiout
midiout = None
midiout = rtmidi.MidiOut()
if port != "None":
midiout, portname = open_midiport(port=port, type_="output")
def set_midiin(port):
global midiin
midiin = None
midiin = rtmidi.MidiIn()
if port != "None":
midiin, portname = open_midiport(port=port, type_="input")
status = event[0]
channel = None
data1 = data2 = None
num_bytes = len(event)
if num_bytes >= 2:
data1 = event[1]
if num_bytes >= 3:
data2 = event[2]
if status == 0x90: # note on
events.append( (channel, data1, data2, time.time()) )
try:
midiin, port_name = open_midiport("USB Uno MIDI Interface", use_virtual=True)
except (EOFError, KeyboardInterrupt):
print "Error opening MIDI port"
sys.exit()
print "Attaching MIDI input callback handler."
midiin.set_callback(MidiInputHandler(port_name))
#-------------------------------------------------------------------------------
# parse layout file
print
print ' parsing layout file'
print
import sys, os, time, logging
PACKAGE_PARENT = '..'
SCRIPT_DIR = os.path.dirname(
os.path.realpath(os.path.join(os.getcwd(), os.path.expanduser(__file__))))
sys.path.append(os.path.normpath(os.path.join(SCRIPT_DIR, PACKAGE_PARENT)))
logging.basicConfig(level=logging.DEBUG, format="%(message)s")
# Set up midi.
from rtmidi.midiutil import open_midiport
try:
midiout, port = open_midiport(4, "output", client_name="RtMidi Sequencer")
except (IOError, ValueError) as exc:
print("Could not open MIDI input: %s" % exc)
except (EOFError, KeyboardInterrupt):
print("Other error")
# Set up pysician.
from pysician.components.sequence import Sequence
from pysician.components.progression import ChordProgression, DrumProgression
from pysician.sequencer import Sequencer
from pysician.components.arpeggiator import arpeggiate
# Arpeggio
sequence_1 = Sequence(channel=0x00, bars=4)
progression_1 = ChordProgression('Cm Ab Bb Gm', bars=4)
arpeggiated_1 = [
arpeggiate(notes, 1, i, mode='up')
for i, notes in enumerate(progression_1.to_notes())
]
from Queue import Queue
import rtmidi.midiutil as midiutil
from threading import Thread
import notestates
import sequencermodel
# Get outputs that contain the string 'Launchpad'
lp_midi_out, midi_out_name = midiutil.open_midiport(port='Launchpad', type_='output')
print('Opening port \'{0}\' for output'.format(midi_out_name))
# Create note thread for sending notes generated by the sequencers
# to prevent timing errors
note_queue = Queue()
def send_note(queue):
while True:
midi_message = queue.get()
lp_midi_out.send_message(midi_message)
note_thread = Thread(target=send_note, args=(note_queue,))
note_thread.daemon = True
note_thread.start()
class GlobalLpView(object):
def __init__(self, input_velocity):
self.display_velocity(input_velocity)
self.display_page(0)
def display_velocity(self, velocity):
# Use the up and down arrow buttons to indicate velocity
vel_bit_1_button_cc = 104
[176, 2],
[176, 3],
[176, 4],
[177, 1],
[177, 2],
[177, 3],
[177, 4],
]
log = logging.getLogger('test_midiin_poll')
logging.basicConfig(level=logging.DEBUG)
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiin, port_name = open_midiport(port)
except (EOFError, KeyboardInterrupt):
sys.exit()
s = serial.Serial("/dev/ttyACM0", baudrate=9600)
print("Entering main loop. Press Control-C to exit.")
try:
changed_knobs = {}
last_serial_update = 0
while True:
now = time.time()
msg = midiin.get_message()
# process midi package
if msg:
def main(args=None):
def button3EventHandler(pin):
screen.addstr(1,0, "-> KAOSS!!!")
mc.channel = -1
kaoss.enabled = True
kaoss.reverse = False if kaoss.reverse else True
screen.addstr(3,14, "rev: %4s " % (kaoss.reverse,))
def button4EventHandler(pin):
screen.addstr(3,24, "scale: %4s " % (kaoss.remap_scale,))
kaoss.remap_scale = False if kaoss.remap_scale else True
parser = argparse.ArgumentParser(prog='midifilter', description=__doc__)
padd = parser.add_argument
padd('-m', '--mpresstocc', action="store_true",
help='Map mono pressure (channel aftertouch) to CC')
padd('-r', '--mapccrange', action="store_true",
help='Map controller value range to min/max value range')
padd('-t', '--transpose', action="store_true",
help='Transpose note on/off event note values')
padd('-i', '--inport',
help='MIDI input port number (default: ask)')
padd('-o', '--outport',
help='MIDI output port number (default: ask)')
padd('-v', '--verbose', action="store_true",
help='verbose output')
padd('filterargs', nargs="*", type=int,
help='MIDI filter argument(s)')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.INFO)
try:
midiin, inport_name = open_midiport(args.inport, "input")
midiout, outport_name = open_midiport(args.outport, "output")
except IOError as exc:
print(exc)
return 1
except (EOFError, KeyboardInterrupt):
return 0
screen = curses.initscr()
screen.clear()
#curses.noecho()
curses.curs_set(0)
screen.keypad(1)
#curses.nodelay()
screen.addstr(0,0, "Main loop")
screen.addstr(1,0, "-> 0")
filters = []
#filters = [CCToBankChange(cc=99, channel=15, msb=0, lsb=1, program=99)]
mc = MapChannel()
kaoss = NoteToKaos(screen=screen)
filters = [mc, kaoss]
if args.transpose:
filters.append(Transpose(transpose=args.filterargs[0]))
if args.mpresstocc:
filters.append(MonoPressureToCC(cc=args.filterargs[0]))
if args.mapccrange:
filters.append(MapControllerValue(*args.filterargs))
dispatcher = MidiDispatcher(midiin, midiout, *filters)
pitft.Button3Interrupt(callback = button3EventHandler)
pitft.Button4Interrupt(callback = button4EventHandler)
try:
dispatcher.start()
while True:
if pitft.Button1:
screen.addstr(1,0, "-> 0")
mc.channel = 0
kaoss.enabled = False
if pitft.Button2:
screen.addstr(1,0, "-> 1")
mc.channel = 1
kaoss.enabled = False
#if pitft.Button3:
# screen.addstr(1,0, "-> KAOSS!!!")
# mc.channel = -1
# kaoss.enabled = True
# #kaoss.reverse = False if kaoss.reverse else True
if kaoss.enabled:
screen.addstr(5,0, ' '.join(kaoss.sequence) )
screen.refresh()
time.sleep(0.1)
except KeyboardInterrupt:
dispatcher.stop()
dispatcher.join()
print('')
finally:
curses.endwin()
print("Exit.")
midiin.close_port()
midiout.close_port()
del midiin
del midiout
return 0
log = logging.getLogger('test_midiout')
logging.basicConfig(level=logging.DEBUG)
midiNotes = [[0.0, [159, 52, 100]], [0.20660499999999998, [143, 52, 0]],
[0.13863999999999999, [159, 53, 100]],
[0.22694699999999998, [143, 53, 0]], [0.178113, [159, 55, 100]],
[2, [143, 55, 0]], [3, [159, 57, 100]], [0.197328, [143, 57, 0]],
[0.12386599999999999, [159, 55, 100]], [0.162526, [143, 55, 0]],
[0.11900799999999999, [159, 53, 100]], [0.172646, [143, 53, 0]],
[0.178134, [159, 52, 100]], [0.167618, [143, 52, 0]]]
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiout, port_name = open_midiport(port, type_="output", use_virtual=True)
except (EOFError, KeyboardInterrupt):
sys.exit()
note_on = [NOTE_ON, 60, 112] # channel 1, middle C, velocity 112
note_off = [NOTE_OFF, 60, 0]
#time.sleep(5)
print("Sending NoteOn event.")
for i in range(len(midiNotes)):
time.sleep(midiNotes[i][0])
print(midiNotes[i][1])
#midiout.send_message(note_on)
#time.sleep(1)
#print("Sending NoteOff event.")
#midiout.send_message(note_off)
def open_output(self):
self._output, self.portname = open_midiport(self.port, "output", interactive=False, client_name=self.name)
def set_midiout(port):
global midiout
midiout = None
midiout = rtmidi.MidiOut()
if port != "None":
midiout, portname = open_midiport(port=port, type_="output")
print("REC button pushed")
os.kill(os.getpid(), 34)
#print("@%0.6f %r" % (deltatime, message))
#play = [148, 36, 100]
#rec = [148, 37, 100]
play = [144, 86, 100]
rec = [144, 94, 100]
playdioda = [148, 50]
recdioda = [148, 49]
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiout, port_name_out = open_midiport(port,
type_="output",
use_virtual=True,
client_name='midiplay',
port_name='out')
midiin, port_name_in = open_midiport(port,
use_virtual=True,
client_name='midiplay',
port_name='in')
midicall, port_name_call = open_midiport(port,
use_virtual=True,
client_name='midiplay',
port_name='callback')
except (EOFError, KeyboardInterrupt):
sys.exit()
#pjesma = midiplay.file2list('midiNotes.txt')
def __init__(self, _id=None, _kind=None):
self.port, self.port_name = open_midiport(_id, _kind)
def main(args=None):
"""
Main program function.
No argument is to be passed to the program, and no user input is expected
The program must be autonomous, and is executed at Minimouk's startup
"""
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.DEBUG)
midiport_emergencyControl_available = False
midiport_abletonInVoiceFx_available = False
midiport_abletonOut_available = False
try:
midiin_emergencyControl, port_name_emergencyControl = open_midiport(MIDI_BUS_CONFIGURATION_EMERGENCY_CONTROL, type_ = "input", interactive=False)
midiport_emergencyControl_available = True
except (ValueError):
log.info("Emergency Control MIDI port unavailable")
try:
midiin_abletonInVoiceFx, port_name_abletonInVoiceFx = open_midiport(MIDI_BUS_CONFIGURATION_ABLETON_IN_VOICE_FX, type_ = "input", interactive=False)
midiport_abletonInVoiceFx_available = True
except (ValueError):
log.info("Ableton Voice FX MIDI port unavailable")
try:
midiout_abletonOut, port_name_abletonOut = open_midiport(MIDI_BUS_CONFIGURATION_ABLETON_OUT, type_ = "output", interactive=False)
midiport_abletonOut_available = True
except (ValueError):
log.info("MIDI back to Ableton MIDI port unavailable")
handler_emergencyControl_Strobot = None
handler_emergencyControl_MIDI = None
handler_abletonVoiceFx = None
# These three callbacks should always be available - if not, the computer is not configured properly
log.debug("Attaching available MIDI input callback handlers.")
if midiport_emergencyControl_available:
handler_emergencyControl_Strobot = MidiInputHandler_emergencyControl_Strobot(midiin_emergencyControl)
midiin_emergencyControl.set_callback(handler_emergencyControl_Strobot)
log.info(" *** Emergency control (Strobot) callback is attached")
if midiport_emergencyControl_available:
handler_emergencyControl_MIDI = MidiInputHandler_emergencyControl_MIDI(midiin_emergencyControl, midiout_abletonOut)
midiin_emergencyControl.set_callback(handler_emergencyControl_MIDI)
log.info(" *** Emergency control (MIDI) callback is attached")
if midiport_abletonInVoiceFx_available and midiport_abletonOut_available:
handler_abletonVoiceFx = MidiInputHandler_abletonVoiceFx(midiin_abletonInVoiceFx, midiout_abletonOut)
midiin_abletonInVoiceFx.set_callback(handler_abletonVoiceFx)
log.info(" *** Ableton VoiceFX callback is attached")
try:
# If requested, recreate the MIDI emergency control object
global REINIT_CALL
while True:
if REINIT_CALL:
if midiport_emergencyControl_available:
handler_emergencyControl_MIDI.close()
handler_emergencyControl_Strobot.close()
handler_abletonVoiceFx.close()
midiout_abletonOut.close_port()
try:
midiout_abletonOut, port_name_abletonOut = open_midiport(MIDI_BUS_CONFIGURATION_ABLETON_OUT, type_ = "output", interactive=False)
midiport_abletonOut_available = True
except (ValueError):
log.info("MIDI back to Ableton MIDI port unavailable")
if midiport_emergencyControl_available:
handler_emergencyControl_Strobot = MidiInputHandler_emergencyControl_Strobot(midiin_emergencyControl)
midiin_emergencyControl.set_callback(handler_emergencyControl_Strobot)
log.info(" *** Emergency control (Strobot) callback is attached")
if midiport_abletonInVoiceFx_available and midiport_abletonOut_available:
handler_abletonVoiceFx = MidiInputHandler_abletonVoiceFx(midiin_abletonInVoiceFx, midiout_abletonOut)
midiin_abletonInVoiceFx.set_callback(handler_abletonVoiceFx)
log.info(" *** Ableton VoiceFX callback is attached")
if midiport_emergencyControl_available and midiport_abletonOut_available:
handler_emergencyControl_MIDI = MidiInputHandler_emergencyControl_MIDI(midiin_emergencyControl, midiout_abletonOut)
midiin_emergencyControl.set_callback(handler_emergencyControl_MIDI)
log.info(" *** Emergency control (MIDI) callback is attached")
REINIT_CALL = False
time.sleep(1)
except KeyboardInterrupt:
log.debug('Shutting down program')
finally:
if handler_emergencyControl_MIDI != None:
handler_emergencyControl_MIDI.close()
midiin_emergencyControl.close_port()
midiin_abletonInVoiceFx.close_port()
midiout_abletonOut.close_port()
del midiin_emergencyControl
del midiin_abletonInVoiceFx
del midiout_abletonOut
on = False
if note in MIDI_MAPPING:
router = MIDI_MAPPING[note]["router"]
gpio = MIDI_MAPPING[note]["gpio"]
# TODO: modulo!
if router >= 0 and router < len(ROUTERS):
ROUTERS[router].switch_light(gpio, on)
else:
logging.debug("Router {} not connected".format(router))
else:
logging.debug("Note {} not in mapping".format(note))
try:
midiin, port_name = open_midiport(None)
except (EOFError, KeyboardInterrupt):
sys.exit()
print("Attaching MIDI input callback handler.")
midiin.set_callback(MidiInputHandler(port_name))
print("Entering main loop. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(1)
except KeyboardInterrupt:
print('')
finally:
print("Exit.")
def __init__(self, port):
self.port = port
self._wallclock = time.time()
def __call__(self, event, data=None):
message, deltatime = event
self._wallclock += deltatime
#print na STDOUT
#print("@%0.6f %r" % (deltatime, message))
#float is not limited but could be to 6 zero points or less if problems will accure.
midiNotes.append([deltatime, message])
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiin, port_name = open_midiport(port, use_virtual = True)
except (EOFError, KeyboardInterrupt):
sys.exit()
print("Attaching MIDI input callback handler.")
midiin.set_callback(MidiInputHandler(port_name))
print("Entering main loop. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(3)
#print (midiNotes)
except KeyboardInterrupt:
print('')
finally:
"""Shows how to open an output port and send MIDI events."""
import logging
import sys
import time
from rtmidi.midiutil import open_midiport
from rtmidi.midiconstants import NOTE_OFF, NOTE_ON
log = logging.getLogger('test_midiout')
logging.basicConfig(level=logging.DEBUG)
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiout, port_name = open_midiport(port, "output")
except (EOFError, KeyboardInterrupt):
sys.exit()
note_on = [NOTE_ON, 60, 112] # channel 1, middle C, velocity 112
note_off = [NOTE_OFF, 60, 0]
print("Sending NoteOn event.")
midiout.send_message(note_on)
time.sleep(1)
print("Sending NoteOff event.")
midiout.send_message(note_off)
del midiout
print("Exit.")
try:
conn = socket.create_connection((host, port))
except (ConnectionRefusedError, KeyboardInterrupt):
print("Could not connect to voctocore")
sys.exit()
@atexit.register
def close_conn():
global conn
conn and conn.close()
try:
midiin, port_name = open_midiport(device)
except (EOFError, KeyboardInterrupt):
print("Opening midi port failed")
sys.exit()
@atexit.register
def close_midi():
global midiin
midiin and midiin.close_port()
del midiin
midiin.set_callback(MidiInputHandler(port_name))
print("Entering main loop. Press Control-C to exit.")
class MidiInputHandler(object):
def __init__(self, port):
self.port = port
self._wallclock = time.time()
def __call__(self, event, data=None):
message, deltatime = event
self._wallclock += deltatime
print("[%s] @%0.6f %r" % (self.port, self._wallclock, message))
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiin, port_name = open_midiport(port)
except (EOFError, KeyboardInterrupt):
sys.exit()
print("Attaching MIDI input callback handler.")
midiin.set_callback(MidiInputHandler(port_name))
print("Entering main loop. Press Control-C to exit.")
try:
# just wait for keyboard interrupt in main thread
while True:
time.sleep(1)
except KeyboardInterrupt:
print('')
finally:
print("Exit.")
def __call__(self, event, data=None):
message, deltatime = event
self._wallclock += deltatime
#print na STDOUT
if set(message) == set(play):
print ("PLAY button pushed")
os.kill(os.getpid(), 64)
elif set(message) == set(rec):
print ("REC button pushed")
os.kill(os.getpid(), 34)
#print("@%0.6f %r" % (deltatime, message))
#play = [148, 36, 100]
#rec = [148, 37, 100]
play = [144, 86, 100]
rec = [144, 94, 100]
playdioda = [148, 50]
recdioda = [148, 49]
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiout, port_name_out = open_midiport(port, type_ = "output", use_virtual=True, client_name='midiplay', port_name='out')
midiin, port_name_in = open_midiport(port, use_virtual=True, client_name='midiplay', port_name='in')
midicall, port_name_call = open_midiport(port, use_virtual = True, client_name='midiplay', port_name='callback')
except (EOFError, KeyboardInterrupt):
sys.exit()
#pjesma = midiplay.file2list('midiNotes.txt')
midicall.set_callback(MidiInputHandler(port_name_call))
def set_midiin(port):
global midiin
midiin = None
midiin = rtmidi.MidiIn()
if port != "None":
midiin, portname = open_midiport(port=port, type_="input")
import logging
import sys
import time
import rtmidi
from rtmidi.midiutil import open_midiport
from rtmidi.midiconstants import *
log = logging.getLogger('test_midiout')
logging.basicConfig(level=logging.DEBUG)
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiout, port_name = open_midiport(port, "output")
except (EOFError, KeyboardInterrupt):
sys.exit()
note_on = [NOTE_ON, 60, 112] # channel 1, middle C, velocity 112
note_off = [NOTE_OFF, 60, 0]
print("Sending NoteOn event.")
midiout.send_message(note_on)
time.sleep(1)
print("Sending NoteOff event.")
midiout.send_message(note_off)
del midiout
print("Exit.")
def main(args=None):
parser = argparse.ArgumentParser(prog='midifilter', description=__doc__)
padd = parser.add_argument
padd('-m',
'--mpresstocc',
action="store_true",
help='Map mono pressure (channel aftertouch) to CC')
padd('-r',
'--mapccrange',
action="store_true",
help='Map controller value range to min/max value range')
padd('-t',
'--transpose',
action="store_true",
help='Transpose note on/off event note values')
padd('-i', '--inport', help='MIDI input port number (default: ask)')
padd('-o', '--outport', help='MIDI output port number (default: ask)')
padd('-v', '--verbose', action="store_true", help='verbose output')
padd('filterargs', nargs="*", type=int, help='MIDI filter argument(s)')
args = parser.parse_args(args if args is not None else sys.argv[1:])
logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s",
level=logging.DEBUG if args.verbose else logging.INFO)
try:
midiin, inport_name = open_midiport(args.inport, "input")
midiout, outport_name = open_midiport(args.outport, "output")
except IOError as exc:
print(exc)
return 1
except (EOFError, KeyboardInterrupt):
return 0
filters = []
#filters = [CCToBankChange(cc=99, channel=15, msb=0, lsb=1, program=99)]
if args.transpose:
filters.append(Transpose(transpose=args.filterargs[0]))
if args.mpresstocc:
filters.append(MonoPressureToCC(cc=args.filterargs[0]))
if args.mapccrange:
filters.append(MapControllerValue(*args.filterargs))
dispatcher = MidiDispatcher(midiin, midiout, *filters)
print("Entering main loop. Press Control-C to exit.")
try:
dispatcher.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
dispatcher.stop()
dispatcher.join()
print('')
finally:
print("Exit.")
midiin.close_port()
midiout.close_port()
del midiin
del midiout
return 0
[0.22694699999999998, [143, 53, 0]],
[0.178113, [159, 55, 100]],
[2, [143, 55, 0]],
[3, [159, 57, 100]],
[0.197328, [143, 57, 0]],
[0.12386599999999999, [159, 55, 100]],
[0.162526, [143, 55, 0]],
[0.11900799999999999, [159, 53, 100]],
[0.172646, [143, 53, 0]],
[0.178134, [159, 52, 100]],
[0.167618, [143, 52, 0]]
]
port = sys.argv[1] if len(sys.argv) > 1 else None
try:
midiout, port_name = open_midiport(port, type_ = "output", use_virtual=True)
except (EOFError, KeyboardInterrupt):
sys.exit()
note_on = [NOTE_ON, 60, 112] # channel 1, middle C, velocity 112
note_off = [NOTE_OFF, 60, 0]
#time.sleep(5)
print("Sending NoteOn event.")
for i in range(len(midiNotes)):
time.sleep(midiNotes[i][0])
print (midiNotes[i][1])
#midiout.send_message(note_on)
#time.sleep(1)
#print("Sending NoteOff event.")
#midiout.send_message(note_off)
