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)
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))
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)