Ejemplo n.º 1
0
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)
Ejemplo n.º 2
0
 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
Ejemplo n.º 3
0
 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
Ejemplo n.º 4
0
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)
Ejemplo n.º 5
0
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)
Ejemplo n.º 6
0
    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)
Ejemplo n.º 7
0
 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
Ejemplo n.º 8
0
    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)
Ejemplo n.º 9
0
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))
Ejemplo n.º 10
0
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))
Ejemplo n.º 11
0
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)