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