def __init__(self,in_port,out_port): print("Initialize MIDI CONTROL") global input_dict self.input_port = in_port self.midiin, self.portname_in = open_midiinput(self.input_port) self.Handler = MidiInputHandler(self.portname_in) self.midiin.set_callback(self.Handler) self.output_port = out_port self.midiout, self.portname_out = open_midioutput(self.output_port) self.color = 0x01 self.cc0 = CONTROL_CHANGE | 0x00 self.cc1 = CONTROL_CHANGE | 0x01 self.cc2 = CONTROL_CHANGE | 0x02 self.cc3 = CONTROL_CHANGE | 0x03 self.cc4 = CONTROL_CHANGE | 0x04 self.cc5 = CONTROL_CHANGE | 0x05 self.cc6 = CONTROL_CHANGE | 0x06 self.cc8 = CONTROL_CHANGE | 0x08 self.makeRingBlink(0x00) self.makeRingBlink(0x04) self.makeRingBlink(0x08) self.makeRingBlink(0x0B) self.makeRainbow(0x01) self.makeLedBlink(0x05) self.stopBlink(0x0B)
def main() -> None: for path in evdev.list_devices(): try: touchpad = TouchpadInputDevice(path) except InvalidTouchpadDevice: continue else: break else: print("Can't find a touchpad") sys.exit(1) finger = FingerState(x=0, touching=False) midiout, port_name = open_midioutput( api=API_UNIX_JACK, use_virtual=True, client_name="touchpadmidi", port_name="touchpad", ) asyncio.ensure_future(handle_touchpad_events(touchpad, finger, midiout)) asyncio.ensure_future(recenter_pitch_bend(touchpad, finger, midiout)) loop = asyncio.get_event_loop() loop.run_forever()
def main(args=None): ap = argparse.ArgumentParser() ap.add_argument("-p", "--port", help="MIDI output port") ap.add_argument("-l", "--length", type=int, help="Maximum SysEx message length in bytes per file.") ap.add_argument("sysex-file", nargs="+", help="SysEx input file(s)") args = ap.parse_args() midiout, name = open_midioutput(args.port) print("Opened port '%s'." % name) for filename in getattr(args, "sysex-file"): with open(filename, 'rb') as syx: data = syx.read() assert data[0] == 0xF0 and data[-1] == 0xF7 if args.length: data = bytearray(data[:args.length]) data[-1] = 0xF7 print("Sending %d bytes from '%s'..." % (len(data), filename)) midiout.send_message(data) time.sleep(0.5) midiout.close_port() del midiout
def main(): logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.INFO) midiout_name = "Python MIDI" midiout, port_name = open_midioutput(1) # Init FootController footcontroller = FootController(midiout_name, midiout) log.info("Entering main loop. Press Control-C to exit.") try: while True: footcontroller.sustainbtn.when_pressed = lambda: footcontroller.controllerChange( 4) # When pressed activate the CC footcontroller.sustainbtn.when_released = lambda: footcontroller.controllerChange( 4) # When released deactivate the CC # This needs to be simpler, something like: # footcontroller.holdButton(GPIO_PIN) # Hold = ON, Release = OFF # footcontroller.toggleButton(GPIO_PIN) # Press = ON, Press again = OFF except KeyboardInterrupt: print('') finally: del footcontroller del midiout
def open_midiout(port): """ Return a MIDI out port instance for the given port. :param port: Port to be opened, 0-n. :return: """ midiout, name = open_midioutput(port=port) return midiout
def set_midiout(self, context): global midi_out_pt port = midi_out_pt if g_vars.midiout.is_port_open(): g_vars.midiout.close_port() g_vars.midiout.delete() g_vars.midiout = rtmidi.MidiOut() if port != "None": if port != "Virtual Port": g_vars.midiout, portname = open_midioutput( port=port, interactive=False, client_name="Blender Out") else: g_vars.midiout, portname = open_midioutput( use_virtual=True, interactive=False, client_name="Blender Virtual Out") print("MIDI Output: " + portname)
def __init__(self, polyphony=16, base_note=36, midi_port=2): self.polyphony = polyphony self.workers = [] self.base_note = base_note self.midiout, port_name = open_midioutput( midi_port, client_name="GamePad Step Sequencer", port_name="MIDI Out") self._initWorkers(polyphony)
def main(): logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.INFO) midiout, port_name = open_midioutput(1) # Init FootController footcontroller = FootController(midiout) # A status indicator, will light up after the FootController is initialized, # to let you know that now it's able to send midi signals statusLed = LED(18) statusLed.on() log.info("Entering main loop. Press Control-C to exit.") try: while True: # Hold behaviour (Press=ON, Release=OFF) # footcontroller.btn4.when_pressed = lambda : footcontroller.sendMIDI(type=CONTROLLER_CHANGE, channel=0x40, value=64) # footcontroller.btn4.when_released = lambda : footcontroller.sendMIDI(type=CONTROLLER_CHANGE, channel=0x40, value=0) footcontroller.btn5.when_pressed = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x50, value=100) footcontroller.btn5.when_released = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x50, value=0) footcontroller.btn6.when_pressed = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x51, value=100) footcontroller.btn6.when_released = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x51, value=0) footcontroller.btn13.when_pressed = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x52, value=100) footcontroller.btn13.when_released = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x52, value=0) footcontroller.btn19.when_pressed = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x53, value=100) footcontroller.btn19.when_released = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x53, value=0) footcontroller.btn26.when_pressed = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x30, value=100) footcontroller.btn26.when_released = lambda: footcontroller.sendMIDI( type=CONTROLLER_CHANGE, channel=0x30, value=0) # Toggle behaviour (Press=ON, Press again=OFF) # footcontroller.btn5.when_pressed = lambda : footcontroller.sendMIDI(type=CONTROLLER_CHANGE, channel=0x50) # Usually free MIDI Channels: # 0x50, 0x51, 0x52, 0x53, 0x55, 0X56, 0X57, 0X59, 0X5A, # 0X66, 0X67, 0X68, 0X69, 0X6A, 0X6B, 0X6C, 0X6D, 0X6E, # 0X6F, 0X70, 0X71, 0X72, 0X73, 0X74, 0X75, 0X76, 0X77 except KeyboardInterrupt: print('') finally: del footcontroller del midiout
def open_midi_device(): out_port = sys.argv[1] if len(sys.argv) > 1 else None in_port = sys.argv[2] if len(sys.argv) > 2 else None try: midiout, port_name = open_midioutput(out_port) midiin, _ = open_midiinput(in_port) except (EOFError, KeyboardInterrupt): sys.exit() return midiout, midiin, port_name
def set_midiout(port): global midiout if port != "None": midiout.close_port() #midiout, portname = open_midiport(port=port, type_="output") midiout, portname = open_midioutput(port=port) print("Output: " + portname) if port == "None": midiout.close_port()
def _open_output(self) -> rtmidi.MidiOut: """ open_output opens a midi port for output. """ if not self.port_id: err_text = "Cannot open output without port selected." log.error(err_text) raise RuntimeError(err_text) midiout, _ = open_midioutput(self.port_id) return midiout
def main(args=None): ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) aadd = ap.add_argument aadd('-b', '--bpm', type=float, default=100, help="Beats per minute (BPM) (default: %(default)s)") aadd('-c', '--channel', type=int, default=10, metavar='CH', help="MIDI channel (default: %(default)s)") aadd('-p', '--port', help="MIDI output port number (default: ask)") aadd('-k', '--kit', type=int, metavar='KIT', help="Drum kit MIDI program number (default: none)") aadd('--bank-msb', type=int, metavar='MSB', help="MIDI bank select MSB (CC#00) number (default: none)") aadd('--bank-lsb', type=int, metavar='MSB', help="MIDI bank select LSB (CC#32) number (default: none)") aadd('-H', '--humanize', type=float, default=0.0, metavar='VAL', help="Random velocity variation (float, default: 0, try ~0.03)") aadd('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_midioutput( args.port, 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 setup_output(self): api_out = MidiOut() port_out = self.get_mixer_port(api_out) try: midi_out, port_name = open_midioutput(port_out, interactive=False) except InvalidPortError: return except NoDevicesError: return self.api_out = api_out self.output = midi_out return port_name
def connect(self, inport, outport): try: self.midiin, self.inport_name = open_midiinput(inport) self.midiout, self.outport_name = open_midioutput(outport) return True except OSError: print("there is no midi device") sys.exit() return False except (EOFError, KeyboardInterrupt): sys.exit() return False
def main(args=None): ap = argparse.ArgumentParser() ap.add_argument("-p", "--port", help="MIDI output port") ap.add_argument("sysex-byte", nargs="+", help="SysEx bytes as hexadecimal") args = ap.parse_args() midiout, name = open_midioutput(args.port) print("Opened port '%s'." % name) data = bytearray.fromhex("".join(getattr(args, "sysex-byte"))) assert data[0] == 0xF0 and data[-1] == 0xF7 print("Sending %d bytes" % len(data)) midiout.send_message(data) time.sleep(0.5) midiout.close_port() del midiout
def __init__(self, name="Unnamed Port", interactive=False, auto_start=True): self.name = name if interactive: self.output, self.outname = open_midioutput(select_port("output")) self.input, self.inname = open_midiinput(select_port("input")) # The port's main_loop is supposed to run in its own thread. It is only started if # the object is constructed with auto_start = True or if the start method is called self.thread = Thread(target=self.main_loop, daemon=True) # Listeners to this Device register Queue objects to be informed of Events self.listener_qs = set() if auto_start: if not (self.input and self.output): print("Could not start the Device thread without any input or output configured") else: self.start()
def midiSetup(self): # Prompts user for MIDI input port, unless a valid port number or name # is given as the first argument on the command line. # API backend defaults to ALSA on Linux. # print("input value: ") port = sys.argv[1] if len(sys.argv) > 1 else None try: midiin, port_name = open_midiinput(port) except (EOFError, KeyboardInterrupt): sys.exit() try: midiout, port_name = open_midioutput(port) except (EOFError, KeyboardInterrupt): sys.exit() return midiin, midiout
def _test(): ROSANNA = """ # Rosanna Shuffle # about 124 bpm (for a real tempo of 93 bpm) # 1..|..|..|..2..|..|..|.. 36 x....m...x.....m..s..... Bassdrum 40 .+-.+-m+-.+-.+-.+-m+-.++ Snare 2 42 x-sx-sx-sx-sx-sx-sx-sx-s Closed Hi-hat """ midi, _ = open_midioutput(sys.argv[1] if len(sys.argv) > 1 else None, client_name="drumseq", port_name="MIDI Out") midi = MidiOut(RtMidiOut(midi)) seq = Sequencer(midi, bpm=124) try: seq.play(Pattern(ROSANNA), kit=2) except KeyboardInterrupt: # all notes off midi.control_change(123, 0)
def open(self): # Initialize MidiIn if self.in_port: try: self.midiin, self.in_port = open_midiinput(in_port) except (EOFError, KeyboardInterrupt): self.midiin = rtmidi.MidiIn() self.midiin.open_virtual_port("Octopy Virtual Input") else: self.midiin = rtmidi.MidiIn() available_ports = self.midiin.get_ports() print available_ports if available_ports: self.midiin.open_port(1) self.in_port = 1 else: self.midiin.open_virtual_port("Octopy Virtual Input") self.in_port = "Octopy Virtual Input" # Initialize MidiOut if self.out_port: try: self.midiout, port_name = open_midioutput(out_port, "output") except (EOFError, KeyboardInterrupt): self.midiout = rtmidi.MidiOut() self.midiout.open_virtual_port("Octopy Virtual Output") else: self.midiout = rtmidi.MidiOut() available_ports = self.midiout.get_ports() print available_ports if available_ports: self.midiout.open_port(1) else: self.midiout.open_virtual_port("Octopy Virtual Output") # Register MidiIn Callback self.midiin.set_callback( OctoMidiHandler(self.in_port, self.channel, self.callback))
def main(): sys.settrace # Command line parsing parser = argparse.ArgumentParser() parser.add_argument( "--log", "-l", nargs='+', help="Provide logging level. Example --log debug'", default="info", choices=['debug', 'info', 'warning', 'error', 'critical']) parser.add_argument("--host", nargs='+', help="Plugin host to use. Example --host mod'", default=['mod'], choices=['mod', 'generic', 'test']) args = parser.parse_args() # Handle Log Level level_config = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL } log = args.log[0] log_level = level_config[log] if log in level_config else None if log_level: print("Log level now set to: %s" % logging.getLevelName(log_level)) logging.basicConfig(level=log_level) # Current Working Dir cwd = os.path.dirname(os.path.realpath(__file__)) # Audio Card Config - doing this early so audio passes ASAP audiocard = Audiocard.Audiocard() audiocard.restore() # MIDI initialization # Prompts user for MIDI input port, unless a valid port number or name # is given as the first argument on the command line. # API backend defaults to ALSA on Linux. # TODO discover and use the thru port (seems to be 14:0 on my system) # shouldn't need to aconnect, just send msgs directly to the thru port port = 0 # TODO get this (the Midi Through port) programmatically #port = sys.argv[1] if len(sys.argv) > 1 else None try: midiout, port_name = open_midioutput(port) except (EOFError, KeyboardInterrupt): sys.exit() # Hardware and handler objects hw = None handler = None if args.host[0] == 'mod': # Create singleton Mod handler handler = Mod.Mod(audiocard, cwd) # Initialize hardware (Footswitches, Encoders, Analog inputs, etc.) factory = Hardwarefactory.Hardwarefactory() hw = factory.create(handler, midiout) handler.add_hardware(hw) # Load all pedalboard info from the lilv ttl file handler.load_pedalboards() # Load the current pedalboard as "current" current_pedal_board_bundle = handler.get_current_pedalboard_bundle_path( ) if not current_pedal_board_bundle: # Apparently, no pedalboard is currently loaded so just load the first one current_pedal_board_bundle = list(handler.pedalboards.keys())[0] handler.set_current_pedalboard( handler.pedalboards[current_pedal_board_bundle]) # Load system info. This can take a few seconds handler.system_info_load() elif args.host[0] == 'generic': # No specific plugin host specified, so use a generic handler # Encoders and LCD not mapped without specific purpose # Just initialize the control hardware (footswitches, analog controls, etc.) for use as MIDI controls handler = Generichost.Generichost(homedir=cwd) factory = Hardwarefactory.Hardwarefactory() hw = factory.create(handler, midiout) handler.add_hardware(hw) elif args.host[0] == 'test': handler = Testhost.Testhost(audiocard, homedir=cwd) try: factory = Hardwarefactory.Hardwarefactory() hw = factory.create(handler, midiout) handler.add_hardware(hw) except: handler.cleanup() raise logging.info("Entering main loop. Press Control-C to exit.") period = 0 try: while True: handler.poll_controls() time.sleep( 0.01 ) # lower to increase responsiveness, but can cause conflict with LCD if too low # For less frequent events period += 1 if period > 100: handler.poll_modui_changes() period = 0 except KeyboardInterrupt: logging.info('keyboard interrupt') finally: handler.cleanup() logging.info("Exit.") midiout.close_port() if handler.lcd is not None: handler.lcd.cleanup() GPIO.cleanup() del handler logging.info("Completed cleanup")
#!/usr/bin/env python import padkontrol as pk import rtmidi from rtmidi.midiutil import open_midioutput, open_midiinput # should be named 'padKONTROL 1 CTRL' or similar. OUTPUT_MIDI_PORT = 2 # should be named 'padKONTROL 1 PORT A' or similar INPUT_MIDI_PORT = 1 midi_out, _ = open_midioutput(OUTPUT_MIDI_PORT, client_name="padkontrol", port_name="MIDI Out") def send_sysex(sysex): midi_out.send_message(sysex) class PadKontrolPrint(pk.PadKontrolInput): def on_pad_down(self, pad, velocity): print('pad #%d down, velocity %d/127' % (pad, velocity)) def on_pad_up(self, pad): print('pad #%d up' % pad) def on_button_down(self, button): if button == pk.BUTTON_FLAM: print('flam button down') else:
def selectMidiOut(self, index): midiout, port_name = open_midioutput(index) msg = "Selected MIDI destination %s" % (port_name) print(msg) self.midiin.set_callback(MidiInputHandler(port_name))
def main(args=None): ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) aadd = ap.add_argument aadd('-b', '--bpm', type=float, default=100, help="Beats per minute (BPM) (default: %(default)s)") aadd('-c', '--channel', type=int, default=10, metavar='CH', help="MIDI channel (default: %(default)s)") aadd('-p', '--port', help="MIDI output port number (default: ask)") aadd('-k', '--kit', type=int, metavar='KIT', help="Drum kit MIDI program number (default: none)") aadd('--bank-msb', type=int, metavar='MSB', help="MIDI bank select MSB (CC#00) number (default: none)") aadd('--bank-lsb', type=int, metavar='MSB', help="MIDI bank select LSB (CC#32) number (default: none)") aadd('-H', '--humanize', type=float, default=0.0, metavar='VAL', help="Random velocity variation (float, default: 0, try ~0.03)") aadd('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_midioutput(args.port, 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 callback(msg, data): # print(msg, data) midi_msg, offset = msg midiout.send_message(midi_msg) def error_callback(*args, **kwargs): print(f"{args} - {kwargs}") if __name__ == "__main__": midiout, port = open_midioutput( port=None, use_virtual=True, client_name="relay_out", port_name="relay_out", ) midiin, port = open_midiinput( port=None, use_virtual=True, client_name="relay_in", port_name="relay_in", ) midiin.set_callback(callback) midiin.set_error_callback(error_callback) print(f"Opened relay") while True:
def main(args=None): ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) ap.add_argument( "-c", "--channel", type=int, default=1, help="MIDI channel to send program change(s) to (default: %(default)s)", ) ap.add_argument( "-d", "--device", type=int, default=1, help= "MIDI SysEx device number to send patch request for (default: %(default)s).", ) ap.add_argument( "-i", "--input-port", metavar="PORT", nargs="?", default="reface DX", const=None, help= "MIDI input port. May be a port number or port name sub-string or the option value " "may be omitted, then the input port can be selected interactively " "(default: '%(default)s').", ) ap.add_argument( "-o", "--output-port", metavar="PORT", nargs="?", default="reface DX", const=None, help= "MIDI output port. May be a port number or port name sub-string or the option value " "may be omitted, then the output port can be selected interactively " "(default: '%(default)s').", ) ap.add_argument( "-f", "--output-path", metavar="PATH", default="{name}.syx", help= "Path of output file to write SysEx data to (default: '%(default)s')", ) ap.add_argument( "-q", "--quiet", action="store_true", help="Do not print messages except errors.", ) ap.add_argument( "-r", "--replace", action="store_true", help="Replace existing output file(s) (default: no).", ) ap.add_argument( "patches", nargs="*", help= "Patches to request. Each argument can be a program number (1 to 32) or a program " "number range (e.g. '9-16'). If no positional arguments are given, the patch in the " "current edit buffer is requested.", ) args = ap.parse_args(args if args is not None else sys.argv[1:]) logging.basicConfig( level=logging.WARN if args.quiet else logging.INFO, format="%(levelname)s - %(message)s", ) try: midiin, midiin_name = open_midiinput(args.input_port) midiout, midiout_name = open_midioutput(args.output_port) except (EOFError, KeyboardInterrupt): return 1 channel = max(1, min(16, args.channel)) reface = RefaceDX(midiin, midiout, channel=channel - 1) if args.patches: patches = set() for patchspec in args.patches: try: if "-" in patchspec: lo, hi = [int(i) for i in patchspec.split("-", 1)] patches.update(range(lo, hi + 1)) else: patches.add(int(patchspec)) except (TypeError, ValueError): log.error("Invalid argument: %s", patchspec) args.patches = sorted(list(patches)) for patchno in args.patches or [None]: if patchno is not None: if 32 >= patchno >= 1: log.info("Sending program change #%i on channel %i...", patchno - 1, channel) reface.send_program_change(patchno - 1) time.sleep(0.1) else: log.error( "Skipping patch number %i, which is out of range (1..32).", patchno) continue try: log.info("Sending patch dump request ...") patch = reface.patch_request(args.device) except TimeoutError: log.error("Did not receive patch dump within timeout.") else: now = datetime.now() data = {name: getattr(now, name) for name in DATE_KEYS} data["name"] = get_patch_name(patch) if patchno is not None: data["program"] = patchno data["slot"] = "{}-{}".format((patchno - 1) // 8 + 1, (patchno - 1) % 8 + 1) output_path = build_path(args.output_path, **data) log.info("Output path (after substitution): %s", output_path) if not splitext(output_path)[1]: output_path += ".syx" if exists(output_path): if args.replace: log.warn("Existing output file '%s' will be overwritten.", output_path) else: log.warn( "Existing output file '%s' will not be overwritten.", output_path, ) continue with open(output_path, "wb") as sysex: log.info("Writing patch '%s' to file '%s'...", data["name"], output_path) sysex.write(patch)
from time import sleep from rtmidi.midiutil import open_midioutput from rtmidi.midiconstants import NOTE_ON import Tonnetz outport = open_midioutput() channel = max(1, min(int(input("channel ?")), 16)) def play(): c = Tonnetz.makeChord() wait = 1.7 mute = False stack = False running = True while running == True: line = input('Wat u want> ') for i in list(line): if i == 'q': print('k bye') running = False elif i == "(": mute = True print("MUTED: ") elif i == ")": mute = False print(" ") elif i == "<": stack = True print("STACKED:") elif i == ">":
from tkinter import * import time from rtmidi.midiutil import open_midioutput from rtmidi.midiconstants import NOTE_OFF, NOTE_ON, ALL_SOUND_OFF, CONTROL_CHANGE, RESET_ALL_CONTROLLERS import logging log = logging.getLogger('midiout') logging.basicConfig(level=logging.DEBUG) midiout, port_name = open_midioutput(1) root = Tk() variable = DoubleVar() root.title("ratchetseq") root.geometry('275x90') def playnote(thenote, sus, amount): for each in range(int(amount)): root.after(sus, midiout.send_message([0x90, thenote, 127]), midiout.send_message([0x80, thenote, 127])) def checkratchetleng(current): current = int(current) beat = bpmrate.get() sustain = (60 / int(beat) / current) * 1000 print(f'{round(sustain)}ms, {current} retriggers, {bpmrate.get()} bpm') return round(sustain) def updatevars(step1, step2, step3, step4, step5, step6, step7, step8):
log = logging.getLogger('midiout') logging.basicConfig(level=logging.DEBUG) channel_voice_message = 0x9F colour_code = 0x40 #0x40 is green start_note_basic = 0x24 start_note_inControl = 0x60 midi_message = [channel_voice_message, start_note_basic, colour_code] port = 0 #should connect to Launchkey MIDI 2 try: midiout, port_name = open_midioutput(port=2, interactive=False, port_name="output") except (EOFError, KeyboardInterrupt): sys.exit() print("Sleeping ..., make the connection please") time.sleep(1) #for x in range(128): # message=[channel_voice_message, x, colour_code] # print(message) # midiout.send_message(message) #message=[0x90,12,127] #enter in control mode #enable in control mode
try: #Open a MIDI IN and OUT ports. Let's say you have two ports: Port01 and #Port02. For testing, first start this script and set the following: #* Input port: Port01 #* Output port: Port02 #Then start an application that sends and receives MIDI messages, ie: Bome #SendSX, there set the ports as follows: #* Input port: Port02 #* Output port: Port01 #Finally start sending MIDI messages from your MIDI application. You should #see the same messages in the MIDI IN and OUT. In the console there should #be some debug messages midi_in, out_port = open_midiinput(interactive = True) print("") midi_out, out_port = open_midioutput(interactive = True) validated = False while not validated: midi_channel = input("\nMIDI IN channel used by controller [1-16] " "(Control-C to exit): ") try: midi_channel = int(midi_channel) validated = True except: pass if (validated) and (1 <= midi_channel) and (midi_channel <= 16): validated = True else: validated = False
def main(args=None): """Main program function. Parses command line (parsed via ``args`` or from ``sys.argv``), detects and optionally lists MIDI output ports, opens given MIDI output port, assembles list of SysEx files and calls ``send_sysex_file`` on each of them. """ ap = argparse.ArgumentParser(description=__doc__) ap.add_argument('-i', '--input', dest="input_dir", help='directory containing .syx files to be sent') ap.add_argument('-l', '--list-ports', action="store_true", help='list available MIDI output ports') ap.add_argument('-p', '--port', dest='port', help='MIDI output port number (default: open virtual port)') ap.add_argument('-d', '--delay', default="50", metavar="MS", type=int, help='delay between sending each Sysex message in milliseconds. Use for pacing. ' 'Default: %(default)s ms') ap.add_argument('-v', '--verbose', action="store_true", help='verbose logging output (debug)') args = ap.parse_args(args) logging.basicConfig(format="%(name)s: %(levelname)s - %(message)s", level=logging.DEBUG if args.verbose else logging.INFO) if args.list_ports: try: list_output_ports() except rtmidi.RtMidiError as exc: log.error(exc) return 1 return 0 files = [] files.extend(sorted([join(args.input_dir, fn) for fn in os.listdir(args.input_dir) if fn.lower().endswith('.syx')])) if not files: log.error("No SysEx (.syx) files found in given directory.") return 1 if args.verbose: log.debug("List of .syx files to be sent") for filename in files: log.debug(filename) try: midiout, portname = open_midioutput(args.port, interactive=False, use_virtual=True) except rtmidi.InvalidPortError: log.error("Invalid MIDI port number or name.") log.error("Use '-l' option to list MIDI ports.") return 2 except rtmidi.RtMidiError as exc: log.error(exc) return 1 except (EOFError, KeyboardInterrupt): return 0 # Ask user to start bulk receive at PCR-800 print("Put the PCR-800 into bulk receive mode for one or all control maps") try: yn = input("Press ENTER to begin sending, CTRL-C to cancel and exit...\n") except KeyboardInterrupt: log.info("Canceled") return 0 try: for filename in files: try: send_sysex_file(filename, midiout, portname, args.delay) except StopIteration: break except Exception as exc: log.error("Error while sending file '%s': %s", (filename, exc)) finally: midiout.close_port() del midiout return 0
def get_midiout(port, api="UNSPECIFIED"): api = getattr(rtmidi, 'API_' + api) midiout, name = open_midioutput(port, api=api, interactive=False, use_virtual=False) return MidiOutWrapper(midiout, name)
#!/usr/bin/env python import padkontrol as pk import rtmidi from rtmidi.midiutil import open_midioutput, open_midiinput # should be named 'padKONTROL 1 CTRL' or similar. OUTPUT_MIDI_PORT = 2 # should be named 'padKONTROL 1 PORT A' or similar INPUT_MIDI_PORT = 1 midi_out, _ = open_midioutput( OUTPUT_MIDI_PORT, api=rtmidi.API_UNIX_JACK, client_name="padkontrol", port_name="MIDI Out") def send_sysex(sysex): midi_out.send_message(sysex) class PadKontrolPrint(pk.PadKontrolInput): def on_pad_down(self, pad, velocity): print 'pad #%d down, velocity %d/127' % (pad, velocity) def on_pad_up(self, pad): print 'pad #%d up' % pad def on_button_down(self, button):