def __init__(self,
controller_out='Arturia KeyLab Essential 61 DAW Out',
controller_in='Arturia KeyLab Essential 61 DAW In',
midi_in='Arturia KeyLab Essential 61 MIDI In'):
self._dawin = rtmidi.MidiIn()
self._dawin.open_port(self._dawin.get_ports().index(controller_in))
self._midiin = rtmidi.MidiIn()
self._midiin.open_port(self._midiin.get_ports().index(midi_in))
self._dawout = rtmidi.MidiOut()
self._dawout.open_port(self._dawout.get_ports().index(controller_out))
self._dawout.send_message((240, 0, 32, 107, 127, 66, 2, 0, 64, 17, 127,
0, 247)) #Pose as Live
#self.controls = pickle.load(open("kle_lib/controlcache.p", 'rb'))
self.controls = kle_lib.buttondefs.getControls()
def __init__(self, manifest, overrides=None):
import supriya
if isinstance(manifest, dict):
manifest = copy.deepcopy(manifest)
if overrides:
manifest = supriya.system.YAMLLoader.merge(manifest, overrides)
self._device_manifest = manifest
else:
manifest = pathlib.Path(manifest)
if not manifest.suffix:
manifest = manifest.with_suffix(".yml")
if not manifest.is_absolute():
manifest = (pathlib.Path(supriya.__path__[0]) / "assets" /
"devices" / manifest)
manifest = supriya.system.YAMLLoader.load(str(manifest),
overrides=overrides)
self._device_manifest = manifest
self._lock = threading.RLock()
self._midi_in = rtmidi.MidiIn()
self._midi_out = rtmidi.MidiOut()
self._initialize_physical_controls()
if "logical_controls" in self._device_manifest["device"]:
self._initialize_logical_controls()
else:
self._initialize_default_logical_controls()
def init(self, api: ty.Optional[int] = None, port: int = 0) -> None:
if self._in:
self.shutdown()
if api is not None:
self._api = api
self._in = rtmidi.MidiIn(rtapi=self.api, name=self.name)
self.use_port(port)
def main():
# In- and output setup
midi_in = rtmidi.MidiIn()
midi_out = rtmidi.MidiOut()
# f_midi is the port opened by the Raspberry midi gadget.
for index, port in enumerate(midi_in.get_ports()):
if 'f_midi' in port:
midi_in.open_port(index)
print('MIDI in connected')
for index, port in enumerate(midi_out.get_ports()):
if 'f_midi' in port:
midi_out.open_port(index)
print('MIDI out connected')
instance = sequency.Sequency(midi_in, midi_out)
try:
while True:
# Just keep sleeping
time.sleep(1)
except KeyboardInterrupt:
print('')
finally:
instance.done = True
instance.kill()
instance.join()
del midi_in
del midi_out
def __init__(self, target=None):
self.midi = rtmidi.MidiIn()
#------------------------------------------------------------------------
# don't ignore MIDI clock messages (is on by default)
#------------------------------------------------------------------------
self.midi.ignore_types(timing=False)
self.clock_target = None
ports = self.midi.get_ports()
if len(ports) == 0:
raise Exception("No MIDI ports found")
port_index = 0
if target is not None:
for index, name in enumerate(ports):
if name == target:
log.info("Found MIDI source (%s)" % name)
port_index = index
if self.midi is None:
log.warn("Could not find MIDI source %s, using default" %
target)
self.midi.open_port(port_index)
def __init__(self, port=-1):
self.jsonFileName = os.path.join(os.path.dirname(os.path.realpath(__file__)), "colorConfig.json")
self.ConfigData_JSON = open(self.jsonFileName).read()
self.ConfigData = json.loads(self.ConfigData_JSON)
self.midiIn = rtmidi.MidiIn()
self.port = port
self.buttonMapInbound = {
0x30 : "flash",
0x31 : "pause",
0x32 : "choose",
0x33 : "go",
0x42 : "goback",
}
for i in range(len(self.ConfigData["map"])):
address = self.ConfigData["map"][i]["address"]
path = self.ConfigData["map"][i]["path"]
number = self.ConfigData["map"][i]["number"]
colorIndex = self.ConfigData["map"][i]["colorIndex"]
self.buttonMapInbound[int(self.ConfigData["map"][i]["address"])] = (self.ConfigData["map"][i]["path"], self.ConfigData["map"][i]["number"])
#print(self.buttonMapInbound)
if self.port != -1:
self.midiIn.open_port(self.port)
else:
self.midiIn.open_port(name='APC40 mkII')
self.midiIn.set_callback(self.callback)
def _rtmidi_virtual_ports_available():
'''Check whether rtimidi virtual ports are available.
These are not supported for some MIDI APIs (e.g. Windows or 'dummy').
'''
compiled_apis = [
rtmidi.get_api_name(api) for api in rtmidi.get_compiled_api()
]
env_api = rtmidi.get_api_name(rtmidi.midiutil.get_api_from_environment())
logging.info(
f"rtmidi compiled API: {compiled_apis}, API from env: {env_api}")
port_name = "vlcmidi virtual test"
try:
rtmidi.midiutil.open_midioutput(use_virtual=True,
interactive=False,
port_name=port_name)
except (rtmidi.InvalidPortError, rtmidi.NoDevicesError,
rtmidi.SystemError) as e:
logging.warning(
f"Virtual ports not available: couldn't open port ({e})")
return False
# make sure we can see the port
midi_in = rtmidi.MidiIn()
available_ports = midi_in.get_ports()
if len(available_ports) == 0 or not any(port_name in port
for port in available_ports):
logging.warning(
f"Virtual ports not available: port not in {available_ports}")
return False
return True
def main():
args = parse_command_line()
if args.list_ports:
# List available MIDI device ports.
midi = rtmidi.MidiIn()
midi_ports = midi.get_ports()
print('MIDI Ports:')
for index, port in enumerate(midi_ports):
print(' {:2d}: {}'.format(index, port))
sys.exit(0)
# Start the UART serial connection.
ser = serial.Serial(args.serial_port, baudrate=115200)
midi = MidiManager(ser, args.keyboard_midi_port, args.quneo_midi_port)
# Main loop.
while True:
try:
# Print received data from UART to stdout.
sys.stdout.write(ser.read().decode('utf-8'))
except KeyboardInterrupt:
print('Exiting.')
sys.exit(0)
except UnicodeDecodeError:
pass
def __init__(self):
try:
ConfigData_Filename = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "config.json")
ConfigData_JSON = open(ConfigData_Filename).read()
ConfigData = json.loads(ConfigData_JSON)
self.MSCCmdFormat = int(ConfigData['MSCCmdFormat'], 16)
self.MSCDeviceID = int(ConfigData['MSCDeviceID'])
self.expandedMode = ConfigData['expandedMode']
self.inPort = int(ConfigData['inPort'])
self.outPort = int(ConfigData['outPort'])
self.MAMSCMode = ConfigData['MAMSCMode']
self.MA = ConfigData['MA']
except Exception as e:
print(
"EXCEPTION: Cannot load and parse Config.JSON File. Loading Default settings."
)
print(e)
self.MSCCmdFormat = 0x01
self.MSCDeviceID = '1'
self.expandedMode = True
self.outPort = 0
self.inPort = 0
self.MA = False
self.MAMSCMode = 'Default'
ConfigData_Filename = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "config.json")
ConfigData = {}
ConfigData['MSCCmdFormat'] = hex(self.MSCCmdFormat)
ConfigData['MSCDeviceID'] = self.MSCDeviceID
ConfigData['expandedMode'] = self.expandedMode
ConfigData['inPort'] = self.inPort
ConfigData['outPort'] = self.outPort
ConfigData['MA'] = self.MA
ConfigData['MAMSCMode'] = self.MAMSCMode
ConfigData_JSON = open(ConfigData_Filename, 'w')
json.dump(ConfigData, ConfigData_JSON, indent=1)
self.cmdLookup = [
'', 'GO', 'Set Cuelist', 'OPEN', 'STOP', 'RESUME', 'CLOSE',
'ALL_OFF', 'GO_OFF'
]
self.currentCuelist = 0
#GrandMA2 Specific Functionality
self.MAExecPage = 0
self.MAModes = ['Default', 'Exec.Page', 'Exec Page']
self.stopRepeats = True
self.midiIn = rtmidi.MidiIn()
self.midiOut = rtmidi.MidiOut()
self.availableInPort = self.midiIn.get_ports()
self.availableOutPort = self.midiOut.get_ports()
try:
self.midiIn.open_port(self.inPort)
self.midiOut.open_port(self.outPort)
self.midiIn.set_callback(self.processMidiIn)
except:
pass
def __init__(self):
self.stopFlag = False
self.in_Midi_tool_screen_flag = False
self.in_out_device_selector_flag = 0 # 0, 1, -1
# Midi device search filter
self.sysMidiFilterRemoveLst = [
"Midi Through", "RtMidiIn Client", "RtMidiOut Client", "RtMidi",
"Through"
]
# self.sysMidiFilterRemoveLst = []
self.threads = []
# Current Mounted Device
self.currentInDevice = "Not Connected"
self.currentOutDevice = "Not Connected"
# Serial In out initialization
# self.serialport = serial.Serial('/dev/serial0', 38400, serial.EIGHTBITS, serial.PARITY_NONE, serial.STOPBITS_ONE) # /dev/ttyS0, ttyAMA0
self.ser = serial.Serial(port="/dev/serial0",
baudrate=38400,
timeout=0)
# Rtmidi USB Midi Initialization
self.usbOut = rtmidi.MidiOut()
self.usbIn = rtmidi.MidiIn()
self.semitone_MinMax = (-7, 7)
self.octave_MinMax = (-4, 4)
self.octave = 0
self.semiTone = 0
def prepare_midi(
board, midi_port
): # funkcja pozwalajaca na wprowadzanie planszy poczatkowej na kontrolerze midi
set_array_to_zero(board, len(board), len(board[0])) # zerujemy na poczatku
midiin = rtmidi.MidiIn()
ports = range(midiin.get_port_count())
if ports:
midiin.open_port(1) # tu sie otwieraja jakies porty
while True:
mess = midiin.get_message()
if mess != None and mess[0][
2] > 5: # sprawdzamy czy sygnal ktory wysylamy ma wartosci i czy wartosc nacisku byla wieksza niz 2
print(
mess
) # bez powyzszego warunku trzebaby wymyslec sposob na ignorowanie zwalniania przycisku
if mess[0][1] == 10 and mess[0][
2] > 5: # przyciskiem o wartosci 10 rozpoczynamy symulacje
midiin.close_port()
return board
else:
j = int(mess[0][1] % 10)
i = int((mess[0][1] - j) / 10)
if board[i][
j] == 0: # klikajac mozemy zapalac martwe komorki, lub usmiercac zywe
board[i][j] = 1
light_up(midi_port, i * 10 + j, 1)
else:
board[i][j] = 0
light_up(midi_port, i * 10 + j, 0)
def find_launchpad_in_port(self):
"""
Try and find the Launchpad midi input launchpad
:return:
"""
in_ports = rtmidi.MidiIn()
ports = in_ports.get_ports()
port_num = None
found = False
for (port_num, port) in enumerate(ports):
for pad_name in self.launchpads:
if pad_name in port:
found = True
break
if found:
break
if found:
self.in_port_num = port_num
else:
port_num = None
# Clean up as the Launchpad is going to need the midi port
del in_ports
return port_num
def __init__(self, manifest, logger=None, overrides=None):
import supriya
self._logger = logger or logging.getLogger(type(self).__name__)
if isinstance(manifest, dict):
manifest = copy.deepcopy(manifest)
if overrides:
manifest = supriya.system.YAMLLoader.merge(manifest, overrides)
self._device_manifest = manifest
else:
manifest = pathlib.Path(manifest)
if not manifest.suffix:
manifest = manifest.with_suffix('.yml')
if not manifest.is_absolute():
manifest = (
pathlib.Path(supriya.__path__[0]) /
'assets' /
'devices' /
manifest
)
manifest = supriya.system.YAMLLoader.load(
str(manifest),
overrides=overrides,
)
self._device_manifest = manifest
self._lock = threading.RLock()
self._midi_in = rtmidi.MidiIn()
self._midi_out = rtmidi.MidiOut()
self._initialize_physical_controls()
if 'logical_controls' in self._device_manifest['device']:
self._initialize_logical_controls()
else:
self._initialize_default_logical_controls()
def __init__(self):
super().__init__()
self.midiout = rtmidi.MidiOut()
if self.midiout.get_port_count() == 0:
raise IOError("No MIDI output devices found.")
launchpadFound = False
for lpid, name in enumerate(self.midiout.get_ports()):
if "Launchpad MK2" in name:
launchpadFound = True
break
if not launchpadFound:
raise IOError(
"Launchpad not plugged in. (Launchpad MK2 output device not found)"
)
self.midiout.open_port(lpid)
self.midiin = rtmidi.MidiIn()
if self.midiin.get_port_count() == 0:
raise IOError("No MIDI input devices found.")
launchpadFound = False
for lpid, name in enumerate(self.midiin.get_ports()):
if "Launchpad MK2" in name:
launchpadFound = True
break
if not launchpadFound:
raise IOError(
"Launchpad not plugged in????? (Launchpad MK2 input device not found?????) - Sanity check failed HARD."
) # This should never happen because the output was found if this part of the code was even reached. Of course, there may always be the microsecond perfect timing unplug
self.midiin.open_port(lpid)
def _open(self,
client_name=None,
virtual=False,
api=None,
callback=None,
**kwargs):
self.closed = True
self._callback_lock = threading.RLock()
self._queue = ParserQueue()
self._rt = rtmidi.MidiIn(name=client_name)
self.api = _api_to_name[self._rt.get_current_api()]
self._device_type = 'RtMidi/{}'.format(self.api)
self.name = _open_port(self._rt,
self.name,
client_name=client_name,
virtual=virtual,
api=self.api)
self._rt.ignore_types(False, False, True)
self.closed = False
# We need to do this last when everything is set up.
self.callback = callback
def addConfig(cls, props):
devicesList = obs.obs_properties_add_list(props, cls.Keys.port, "MIDI Device", obs.OBS_COMBO_TYPE_LIST, obs.OBS_COMBO_FORMAT_STRING)
availablePorts = rtmidi.MidiIn().get_ports()
obs.obs_property_list_add_string(devicesList, "None", "")
for port in availablePorts:
obs.obs_property_list_add_string(devicesList, port, port)
def createVirtualPort(devicename):
print devicename
midiin = rtmidi.MidiIn()
vp = midiin.open_virtual_port(devicename)
midiin.set_callback(
(lambda event, data: midiEventCallback(devicename, event, data)))
return vp
def open(self, callback):
self.midi_in = rtmidi.MidiIn()
ports = self.midi_in.get_ports()
if ports:
self.midi_in.open_port(0)
self.midi_in.set_callback(callback)
def __init__(self, port_id=0):
""" Class for listening for MIDI clock messages
from a midi device """
try:
self.device = rtmidi.MidiIn()
except NameError:
raise ImportError(_err)
self.available_ports = self.device.get_ports()
if not self.available_ports:
raise MIDIDeviceNotFound
else:
print("MidiIn: Connecting to " + self.available_ports[port_id])
self.device.open_port(port_id)
self.device.ignore_types(timing=False)
self.pulse = 0
self.delta = 0.0
self.bpm = 120.0
self.ppqn = 24
self.beat = 0
def run(self):
virtualMidiInput = rtmidi.MidiIn()
virtualMidiInput.set_client_name(self.name)
virtualMidiInput.open_virtual_port(self.name)
virtualMidiOutput = rtmidi.MidiOut()
virtualMidiOutput.set_client_name(self.name)
virtualMidiOutput.open_virtual_port(self.name)
found_device = True
while self.should_stop is False:
try:
serialMidi = None
try:
serialMidi = serial.Serial(self.device,
self.baud_rate,
timeout=1,
exclusive=True)
except serial.SerialException as e:
if found_device == True:
info("Could not find device ", self.device,
". Please connect it")
found_device = False
time.sleep(self.sleep_interval)
continue
except Exception as e:
logException(e)
serialMidi.close()
info("Opened device \"{}\" as \"{}\" with baud rate of {}".
format(self.device, self.name, self.baud_rate))
found_device = True
interrupt = threading.Event()
self._trigger_interrupt = lambda: interrupt.set()
virtualMidiInput.set_callback(
lambda midi_message, time: self.process_serial_output(
midi_message[0], serialMidi))
def on_serial_exception(exception):
logException(exception)
self._trigger_interrupt()
stop_serial = serial_set_callback(
serialMidi, lambda buf: self.process_serial_input(
buf, virtualMidiOutput), on_serial_exception)
interrupt.wait()
verbose("Interrupted main loop")
stop_serial()
serialMidi.close()
except Exception as e:
logException(e)
virtualMidiInput.close_port()
virtualMidiOutput.close_port()
verbose("Main loop exit")
def forward_messages(self, output, channel):
output.prepare_for_output()
self.input = rtmidi.MidiIn()
self.input.open_port(self.port)
self.input.set_callback(self.callback)
self.forwards.append((output, channel))
def __init__(self, listener):
self.listener = listener
self.intf = rtmidi.MidiIn()
available_ports = self.intf.get_ports()
print "Available MIDI ports: %d" % len(available_ports)
if available_ports:
self.intf.set_callback(self.callback)
self.intf.open_port(0)
def get_in_ports():
global IN_PORTS
midiin = rtm.MidiIn()
available_ports = midiin.get_ports()
IN_PORTS = StrSearchDict({i: p
for i, p in enumerate(available_ports)},
searchin='values',
findby='key')
def __init__(self, name, device=0x7F):
super().__init__('transport-control')
self.device = device
self.stop_event = Event()
self.midiin = rtmidi.MidiIn(rtapi=rtmidi.API_UNIX_JACK, name=name)
self.midiin.open_virtual_port('input')
self.set_shutdown_callback(self.shutdown)
self.midiin.set_callback(self.process)
def OpenInput(self, midi_id):
if self.devIn is None:
try:
self.devIn = rtmidi.MidiIn()
self.devIn.open_port(midi_id)
except:
self.devIn = None
return False
return True
def midi_open(port_number):
midiout = rtmidi.MidiOut()
midiin = rtmidi.MidiIn()
if midiout == None and midiin == None: return
midiin.ignore_types(sysex=False, timing=False, active_sense=True)
midiout.open_port(port_number)
midiin.open_port(port_number)
return (midiout, midiin)
def __init__(self, pref_device=SUPPORTED_DEVICES[0]):
self.input_name = None
self.preferred_device = pref_device
self._availables = None
self.midi_instance = rtmidi.MidiIn()
self.scanner_daemon = DaemonRoutine(ROUTINE_DELAY,
self._check_available_devices,
t_name="Scanner daemon")
self.is_scanning = True
def connect(self):
self._midi_in = self._get_midi_device(rtmidi.MidiIn())
self._midi_out = self._get_midi_device(rtmidi.MidiOut())
if self._midi_in is not None and self._midi_out is not None:
self._running = True
else:
self._running = False
print("*** No LPD8 Controller found ***")
Thread.__init__(self)
def open_input(self, name):
if self.midi_in.is_port_open():
self.midi_in.close_port()
self.midi_in = rtmidi.MidiIn()
self.midi_ports = self.midi_in.get_ports()
idx = self.midi_ports.index(name)
self.midi_in.open_port(idx)
self.midi_in.set_callback(self.midi_received)
def list_input_ports(api=rtmidi.API_UNSPECIFIED):
"""List available MIDI input ports.
Optionally the RtMidi API can be passed with the ``api`` argument. If not
it will be determined via the ``get_api_from_environment`` function.
"""
midiin = rtmidi.MidiIn(get_api_from_environment(api))
list_available_ports(midiio=midiin)
