def repeater(): dest = MIDIDestination("repeater input") source = MIDISource("repeater output") frames = [] last_frame_time = time() while True: midi_in = dest.recv() if midi_in: #source.send(midi_in) frames.append((last_frame_time + DELAY, midi_in)) while frames: midi_out = frames[0] if midi_out[0] < last_frame_time: source.send(midi_out[1]) frames.pop(0) else: break now = time() wait_time = -1 while wait_time <= 0: last_frame_time = last_frame_time + LOOP_WAIT wait_time = last_frame_time - now sleep(wait_time)
def ports(cls): print >> sys.stderr, "Available sources:" print >> sys.stderr, " " + "\n ".join([s.name for s in MIDISource.list()]) print >> sys.stderr, "" print >> sys.stderr, "Available destinations:" print >> sys.stderr, " " + "\n ".join([d.name for d in MIDIDestination.list()]) return 1
def ports(cls): print >> sys.stderr, "Available sources:" print >> sys.stderr, " " + "\n ".join( [s.name for s in MIDISource.list()]) print >> sys.stderr, "" print >> sys.stderr, "Available destinations:" print >> sys.stderr, " " + "\n ".join( [d.name for d in MIDIDestination.list()]) return 1
def emitter(): source = MIDISource("random note emitter") sleep(4) frames = [] frame_time = time() heappush_all(frames, gen_all_off(frame_time)) while True: heappush_all(frames, maybe_gen_notes(frame_time)) while frames and (frames[0][0] < frame_time): midi_out = heappop(frames) print "emit {}".format(midi_out[1]) source.send(midi_out[1]) now = time() wait_time = -1 while wait_time <= 0: frame_time = frame_time + LOOP_WAIT wait_time = frame_time - now sleep(wait_time)
def find_endpoints(self, source_substring, destination_substring): sources = [s for s in MIDISource.list() if s.name.find(source_substring) != -1] if sources: self.source = sources[0] logger.info("Using \"%s\" as the midi source" % self.source.name) else: raise EndpointError("Unable to find a source with a substring of %s" % source_substring) destinations = [s for s in MIDIDestination.list() if s.name.find(destination_substring) != -1] if destinations: self.destination = destinations[0] logger.info("Using \"%s\" as the midi destination" % self.destination.name) else: raise EndpointError("Unable to find a destination with a substring of %s" % destination_substring)
def __init__(self): # TODO: get rid of current_step attribute in favor of querying seq self._manta = Manta() self._midi_source = MIDISource("MantaSeq") self._seq = Seq() self._manta.set_led_enable(PAD_AND_BUTTON, True) self.step_duration = 0.125 # the first step should get executed on the first process() call self.next_step_timestamp = time.time() self.current_step = 0 self.note_offs = {} self.running = False self.start_stop_button = 0 self.shift_button = 1 self._state = MantaSeqIdleState(self) self.pad_leds = [MantaSeqPadLED(i, self._manta) for i in range(48)] self._global_cc1 = 0 self._global_cc2 = 0 # store the notenum and value of the last selected note, which will # be assigned to new steps self._selected_note = None self._selected_cc1 = None self._selected_cc2 = None
def find_endpoints(self, source_substring, destination_substring): sources = [ s for s in MIDISource.list() if s.name.find(source_substring) != -1 ] if sources: self.source = sources[0] logger.info("Using \"%s\" as the midi source" % self.source.name) else: raise EndpointError( "Unable to find a source with a substring of %s" % source_substring) destinations = [ s for s in MIDIDestination.list() if s.name.find(destination_substring) != -1 ] if destinations: self.destination = destinations[0] logger.info("Using \"%s\" as the midi destination" % self.destination.name) else: raise EndpointError( "Unable to find a destination with a substring of %s" % destination_substring)
import os.path import sys __dir__ = os.path.dirname(__file__) sys.path.append(os.path.join(__dir__, '..')) from simplecoremidi import MIDIDestination, MIDISource, NoteOnMessage, NoteOffMessage from time import sleep NOTE_ON = 0x90 channel = 1 MIDDLE_C = 60 for d in MIDIDestination.list(): print("send message to %s" % d.name) d.send(NoteOnMessage(channel, MIDDLE_C, 127)) sleep(1) d.send(NoteOffMessage(channel, MIDDLE_C).asNoteOn()) while (True): for s in MIDISource.list(): message = s.receive(timeout=2) if message == None: sys.stdout.write('.') else: print (s.name, str(message))
import os.path import sys __dir__ = os.path.dirname(__file__) sys.path.append(os.path.join(__dir__, '..')) from simplecoremidi import MIDIDestination, MIDISource, NoteOnMessage, NoteOffMessage from time import sleep NOTE_ON = 0x90 channel = 1 MIDDLE_C = 60 for d in MIDIDestination.list(): print("send message to %s" % d.name) d.send(NoteOnMessage(channel, MIDDLE_C, 127)) sleep(1) d.send(NoteOffMessage(channel, MIDDLE_C).asNoteOn()) while (True): for s in MIDISource.list(): message = s.receive(timeout=2) if message == None: sys.stdout.write('.') else: print(s.name, str(message))
class MantaSeq(object): def __init__(self): # TODO: get rid of current_step attribute in favor of querying seq self._manta = Manta() self._midi_source = MIDISource("MantaSeq") self._seq = Seq() self._manta.set_led_enable(PAD_AND_BUTTON, True) self.step_duration = 0.125 # the first step should get executed on the first process() call self.next_step_timestamp = time.time() self.current_step = 0 self.note_offs = {} self.running = False self.start_stop_button = 0 self.shift_button = 1 self._state = MantaSeqIdleState(self) self.pad_leds = [MantaSeqPadLED(i, self._manta) for i in range(48)] self._global_cc1 = 0 self._global_cc2 = 0 # store the notenum and value of the last selected note, which will # be assigned to new steps self._selected_note = None self._selected_cc1 = None self._selected_cc2 = None def cleanup(self): self._manta.set_led_enable(PAD_AND_BUTTON, False) def start(self): self.running = True self.next_step_timestamp = time.time() def stop(self): self.running = False def _get_step_color(self, step_num): if step_num == self.current_step: return RED elif self._seq.steps[step_num].velocity > 0: return AMBER else: return OFF def _send_midi_cc(self, cc_num, value): self._midi_source.send(make_cc(cc_num, value)) def _send_midi_note(self, note_num, velocity): # remove from note_offs dict if present self.note_offs.pop(note_num, None) midi_note = make_note(note_num, velocity) self._midi_source.send(midi_note) def _schedule_note_off(self, note_num, timestamp): self.note_offs[note_num] = timestamp def set_pad_highlight(self, pad_num, highlight): self.pad_leds[pad_num].highlight(highlight) def set_pad_active(self, pad_num, active): self.pad_leds[pad_num].active(active) def set_pad_intensity(self, pad_num, intensity): self.pad_leds[pad_num].intensity(intensity) def process(self): now = time.time() events = self._manta.process() for event in events: if isinstance(event, PadVelocityEvent): self._process_pad_velocity_event(event) if isinstance(event, ButtonVelocityEvent): self._process_button_velocity_event(event) elif isinstance(event, PadValueEvent): self._process_pad_value_event(event) elif isinstance(event, SliderValueEvent): self._process_slider_value_event(event) # send any pending note_offs for note_num, timestamp in self.note_offs.items(): if now >= timestamp: # send_midi_note will take care of removing the note # from the list self._send_midi_note(note_num, 0) self.set_pad_intensity(pad_from_note(note_num), 0) # if it's time for another step, do it if self.running and now >= self.next_step_timestamp: last_step = self.current_step self.current_step = self._seq.current_step_index step_obj = self._seq.step() if step_obj.velocity > 0: self._send_midi_note(step_obj.note, step_obj.velocity) note_off_timestamp = self.next_step_timestamp + (step_obj.duration * self.step_duration) self._schedule_note_off(step_obj.note, note_off_timestamp) self.set_pad_intensity(pad_from_note(step_obj.note), step_obj.velocity) self._send_midi_cc(1, self._combine_cc(self._global_cc1, step_obj.cc1)) self._send_midi_cc(2, self._combine_cc(self._global_cc2, step_obj.cc2)) # update the step LEDs (previous and current) self.set_pad_highlight(last_step, False) self.set_pad_highlight(self.current_step, True) # remember which step we turned on so we can turn it off next time # around self.next_step_timestamp += self.step_duration def _combine_cc(self, glob, step): """ combines the global cc (glob) with the per-step cc (step) """ return int(glob + step / 127.0 * (127 - glob)) # most of the events get deferred to the state, as they're state-dependent def _process_pad_velocity_event(self, event): if row_from_pad(event.pad_num) < 2: if event.velocity > 0: self._state.process_step_press(event.pad_num) else: self._state.process_step_release(event.pad_num) else: self._state.process_note_velocity(event.pad_num, event.velocity) def _process_button_velocity_event(self, event): if event.button_num == self.start_stop_button: if event.velocity > 0: self.stop() if self.running else self.start() elif event.button_num == self.shift_button: if event.velocity > 0: self._state.process_shift_press() else: self._state.process_shift_release() def _process_pad_value_event(self, event): # pad value messages are ignored for step selection pads if event.pad_num > 15: self._state.process_note_value(event.pad_num, event.value) def _process_slider_value_event(self, event): if event.touched: self._state.process_slider_value(event.slider_num, event.value) else: self._state.process_slider_release(event.slider_num)