def pad_fine(x, y): global PAGE global FINE_PARAM global FINE_PARAM_TYPE k, v = fine_page(x, y) if k == '*': params[FINE_PARAM] = v cc = CC_MAP[FINE_PARAM] midi.send(ControlChange(cc, v)) print(f"{FINE_PARAM} ({cc}) --> {v}") elif k == 'param_type': FINE_PARAM_TYPE = 'mix' if FINE_PARAM_TYPE == v else v if FINE_PARAM_TYPE == 'mix': FINE_PARAM = 'mix' else: FINE_PARAM = FINE_PARAM_TYPE + '_modify' elif k == 'param': if FINE_PARAM_TYPE != 'mix': v = v.split('/') FINE_PARAM = [e for e in v if FINE_PARAM_TYPE in e][0] else: PAGE = v print(f"page --> {v}")
def pad_exp(x, y): global PAGE k, v = exp_page(x, y) if k == '*': params['exp'] = v cc = CC_MAP['exp'] midi.send(ControlChange(cc, v)) print(f"exp ({cc}) --> {v}") elif k == 'tbd': print('tbd ...') else: PAGE = v print(f"page --> {v}")
def pad(x, y): if PAGE == 'main': k, v = main_page(x, y) if k == 'page': # PAGE = v print(f"page -> {v}") elif k == 'pset': params[k] = v # TODO: do the update preset thing print(f"OUT (pc) -- " f"C: {out_channel + 1}\t" f"p: {v} (pset)\t") else: cc = CC_MAP[k] midi.send(ControlChange(cc, v)) print(f"OUT (cc) -- " f"C: {out_channel + 1}\t" f"#: {cc} ({k})\t" f"v: {v}\t")
def pad_main(x, y): global PAGE k, v = main_page(x, y) if k == 'page': PAGE = v print(f"page --> {v}") elif k == 'pset': params[k] = v midi.send(ProgramChange(v)) print(f"pset (pc) --> {v}\n") print(params) else: k_trios = ['drip', 'loop', 'routing'] if (k in k_trios) and (v == params[k]): v = 2 params[k] = v cc = CC_MAP[k] midi.send(ControlChange(cc, v)) print(f"{k} ({cc}) --> {v}")
mode = True while True: if touch1.value: # CC mode pixels[0] = 0xBB0000 pixels[1] = 0x0 mode = False if touch2.value: # pitch bend mode pixels[0] = 0x0 pixels[1] = 0x0000FF mode = True if mode: prox_cc = int(map_range(apds.proximity, 0, 255, 0, 127)) if last_prox_cc is not prox_cc: midi.send(ControlChange(CC_NUM, prox_cc)) print("CC is", prox_cc) last_prox_cc = prox_cc else: prox_pitch = int(map_range(apds.proximity, 0, 255, 8192, 16383)) if last_prox_pitch is not prox_pitch: midi.send(PitchBend(prox_pitch)) print("Pitch bend is", prox_pitch) last_prox_pitch = prox_pitch prox_bright = map_range(apds.proximity, 0, 255, 0.01, 1.0) pixels.brightness = prox_bright
return int(r * 255), int(g * 255), int(b * 255) hue_a = 0 sat_a = 255 val_a = 255 color_a = hsv2rgb(hue_a, sat_a, val_a) hue_b = 127 sat_b = 255 val_b = 255 color_b = hsv2rgb(hue_a, sat_a, val_a) pixels[0] = color_a pixels[1] = color_b pixels.show() while True: cc_val = slider.value // 512 # make 0-127 range for MIDI CC if abs(cc_val - last_cc_val) > 2: print(cc_val) last_cc_val = cc_val mod_wheel = ControlChange(1, cc_val) midi.send(mod_wheel) color_a = hsv2rgb(cc_val, sat_a, val_a) pixels[0] = color_a color_b = hsv2rgb(cc_val, sat_b, val_b) pixels[1] = color_b time.sleep(0.001)
while BLE.connected: if clue.button_a: if not debouncer.hot(BUTTONS["MODE"]): clue_display.next_screen() ACCEL_DATA = clue.acceleration PROX_DATA = clue.proximity ACCEL_X = ACCEL_DATA[0] if clue_display.current_screen == 0: midi_data = [] # Remap analog readings to cc range cc_x = int(simpleio.map_range(ACCEL_X, -9, 9, 0, 127)) cc_x = remap(cc_x, START_RANGE, 127, 0, 127) midi_data.append( ControlChange(clue_display.starting_patch + 4, cc_x)) # It's easier to map it inverted for a shoe mount... # CC_Y = int(simpleio.map_range(ACCEL_Y, -9, 9, 0, 127)) if clue.white_leds and debouncer.hot(BUTTONS["PROXY"], check=True): clue.white_leds = False CC_PROX = int(simpleio.map_range(clue.proximity, 0, 255, 0, 127)) CC_PROX_SWITCH = 127 if CC_PROX > 4 else 0 if CC_PROX_SWITCH != 0 and not debouncer.hot(BUTTONS["PROXY"]): clue.white_leds = True midi_data.append( ControlChange(clue_display.starting_patch + 3, CC_PROX_SWITCH)) if clue.touch_0: if not debouncer.hot(BUTTONS["CC_0"]): print("Touch 0") midi_cc = ControlChange(clue_display.starting_patch, 0)
while ble.connected: # Clue sensor readings to CC accel_data = clue.acceleration # get accelerometer reading accel_x = accel_data[0] accel_y = accel_data[1] prox_data = clue.proximity # Remap analog readings to cc range cc_x = int(simpleio.map_range(accel_x, -9, 9, 0, 127)) cc_y = int(simpleio.map_range(accel_y, 0, 9, 0, 127)) cc_prox = int(simpleio.map_range(prox_data, 0, 255, 0, 127)) # send all the midi messages in a list if cc_send_toggle: midi.send([ ControlChange(cc_x_num, cc_x), ControlChange(cc_y_num, cc_y), ControlChange(cc_prox_num, cc_prox), ]) cc_x_label.text = str(cc_x) cc_y_label.text = str(cc_y) cc_prox_label.text = str(cc_prox) # If you want to send NoteOn or Pitch Bend, here are examples: # midi.send(NoteOn(44, 1column_a)) # G sharp 2nd octave # a_pitch_bend = PitchBend(random.randint(0, 16383)) # midi.send(a_pitch_bend) if clue.button_a: if cc_num_pick_toggle == 0: cc_x_num = cc_x_num - 1
cc_y = int(simpleio.map_range(accel_y, 1, -9, 0, 127)) cc_thumb = get_flex_cc(analog_in_thumb, 49000, 35000, 127, 0) cc_index = get_flex_cc(analog_in_index, 50000, 35000, 0, 127) cc_middle = get_flex_cc(analog_in_middle, 55000, 40000, 0, 127) cc_ring = get_flex_cc(analog_in_ring, 55000, 42000, 0, 127) ''' print( "CC_X:{} CC_Y:{} CC_Thumb:{} CC_Index:{} CC_Middle:{} CC_Ring:{}".format( cc_x, cc_y, cc_thumb, cc_index, cc_middle, cc_ring ) )''' # send all the midi messages in a list midi.send([ ControlChange(cc_x_num, cc_x), ControlChange(cc_y_num, cc_y), ControlChange(cc_thumb_num, cc_thumb), ControlChange(cc_index_num, cc_index), ControlChange(cc_middle_num, cc_middle), ControlChange(cc_ring_num, cc_ring), ]) # If you want to send NoteOn or Pitch Bend, here are examples: # midi.send(NoteOn(44, 120)) # G sharp 2nd octave # a_pitch_bend = PitchBend(random.randint(0, 16383)) # midi.send(a_pitch_bend) print("Disconnected") print() ble.start_advertising(advertisement)
# pitchbend range is 0 to 16383 with 8192 centered or no pitchbend mod_val1 = round(simpleio.map_range(val(mod_pot), 0, 65535, 0, 127)) pitchDown_val1 = round( simpleio.map_range(val(pitchDown_pot), 0, 65535, 0, 8192)) pitchUp_val1 = round( simpleio.map_range(val(pitchUp_pot), 0, 65535, 8192, 16383)) sus_val1 = round(simpleio.map_range(val(sus_pot), 0, 65535, 0, 127)) # if modulation value is updated... if abs(mod_val1 - mod_val2) > 2: # update mod_val2 mod_val2 = mod_val1 # create integer modulation = int(mod_val2) # create CC message modWheel = ControlChange(1, modulation) # send CC message midi.send(modWheel) # pitchbend down value is updated... if abs(pitchDown_val1 - pitchDown_val2) > 75: # update pitchDown_val2 pitchDown_val2 = pitchDown_val1 # create PitchBend message pitchDown = PitchBend(int(pitchDown_val2)) # send PitchBend message midi.send(pitchDown) # pitchbend up value is updated... if abs(pitchUp_val1 - pitchUp_val2) > 75: # updated pitchUp_val2
# 6 options for beat division beat_val1 = round(simpleio.map_range(val(beat_pot), 0, 65535, 0, 5)) # 12 options for key selection key_val1 = round(simpleio.map_range(val(key_pot), 0, 65535, 0, 11)) # 6 options for mode selection mode_val1 = round(simpleio.map_range(val(mode_pot), 0, 65535, 0, 5)) # sending MIDI modulation if abs(mod_val1 - mod_val2) > 2: # updates previous value to hold current value mod_val2 = mod_val1 # MIDI data has to be sent as an integer # this converts the pot data into an int modulation = int(mod_val2) # int is stored as a CC message modWheel = ControlChange(1, modulation) # CC message is sent midi.send(modWheel) print(modWheel) # delay to settle MIDI data time.sleep(0.001) # sets beat division if abs(beat_val1 - beat_val2) > 0: # updates previous value to hold current value beat_val2 = beat_val1 print("beat div is", beat_val2) # updates display beat_text_area.text = "Div:%s" % beat_division_name[beat_val2] # sets random beat division state if beat_val2 == 5:
return idx, offset def sign(x): # determine the sign of x if x >= 0: return 1 else: return -1 while True: # read all the knob values for i in range(knob_count): cc_value[i] = range_index( knob[i].value, (cc_range[i][1] - cc_range[i][0] + 1), cc_value[i][0], cc_value[i][1], ) if cc_value[i] != last_cc_value[i]: # only send if it changed # Form a MIDI CC message and send it: usb_midi.send( ControlChange(cc_number[i], cc_value[i][0] + cc_range[i][0])) classic_midi.send( ControlChange(cc_number[i], cc_value[i][0] + cc_range[i][0])) last_cc_value[i] = cc_value[i] led.value = True time.sleep(0.01) led.value = False
def map_to_midi(input_val): if (input_val < 0): return 0 result = round((input_val - state.input_min) / (state.input_max - state.input_min) * (midi_max - midi_min) + midi_min) if (result < 0): result = 0 if (result > 127): result = 127 return result state = State() while True: button.update() state.update() if (state.mode == 0): # Expession CC controller mode intensity = map_to_midi(analog_in.value) if (intensity != prev_value): midi.send(ControlChange(midi_expr_ctrl, intensity)) prev_value = intensity elif (state.mode == 1): # Breath CC controller mode intensity = map_to_midi(analog_in.value) if (intensity != prev_value): midi.send(ControlChange(midi_breath_ctrl, intensity)) prev_value = intensity
btnLeds[index[1]].value = not int(msg.value / maxVal) #elif(index[0]==2):#Fader elif (index[0] == 4): #Logo if index[1] == 0: ledR.duty_cycle = int((msg.value) * 65535 / maxVal) elif index[1] == 1: ledG.duty_cycle = int((msg.value) * 65535 / maxVal) elif index[1] == 2: ledB.duty_cycle = int((msg.value) * 65535 / maxVal) for idx, touchpad in enumerate(touchpads): if touchpad.value != keydownTouch[idx]: keydownTouch[idx] = touchpad.value if keydownTouch[idx]: #print(touchpad.raw_value) midi.send(ControlChange(midiControls[0][idx], maxVal)) else: midi.send(ControlChange(midiControls[0][idx], 0)) # Using note on 0 for off for idx, btn in enumerate(btns): if btn.value != keydownBtn[idx]: keydownBtn[idx] = btn.value if not keydownBtn[idx]: midi.send(ControlChange(midiControls[1][idx], maxVal)) else: midi.send(ControlChange(midiControls[1][idx], 0)) # Using note on 0 for off for idx, fader in enumerate(faders): faderVal = int(fader.value / 512)
def sendMidiMsg(_msg): nFields = len(_msg) if nFields > 0: if _msg[0] == 0: if nFields >= 3: midi.send(ControlChange(_msg[1], _msg[2]))
else: midi.send(NoteOn(note, 0)) # Using note on 0 for off noteLED(pixels, note, 0) # Perform rate limited checks on the accelerometer # if switch is to left now_t = time.monotonic() if switch_left.value and now_t - acc_read_t > acc_read_period: acc_read_t = time.monotonic() ax, ay, az = acc.acceleration # scale from 0 to 127 (maximum cc 7bit value) new_mod_wheel = abs(scale_acc(ay, acc_nullzone, acc_range, 127)) if (abs(new_mod_wheel - mod_wheel) > min_mod_change or (new_mod_wheel == 0 and mod_wheel != 0)): midi.send(ControlChange(midi_cc_modwheel, new_mod_wheel)) mod_wheel = new_mod_wheel # scale from 0 to +/- 8191 (almost maximum signed 14bit values) new_pitch_bend_value = ( pb_midpoint - scale_acc(ax, acc_nullzone, acc_range, pb_midpoint - 1)) if (abs(new_pitch_bend_value - pitch_bend_value) > min_pb_change or (new_pitch_bend_value == pb_midpoint and pitch_bend_value != pb_midpoint)): midi.send(PitchBend(new_pitch_bend_value)) pitch_bend_value = new_pitch_bend_value # left button increase octave / semitones shift based on switch # does not currently clear playing notes (buglet) if button_left.value:
midi_channel = min(midi_channel + 1, 15) elif i == chan_down_index: print('chan down!') midi_channel = max(midi_channel - 1, 0) elif i == pitch_up_index: print('pitch up!') pitchbend_val = 8192 + 4096 midi.send(PitchBend(pitchbend_val), channel=midi_channel) elif i == pitch_down_index: print('pitch down!') pitchbend_val = 8192 - 4096 midi.send(PitchBend(pitchbend_val), channel=midi_channel) elif i == mod_up_index: print('mod up!') modwheel_val = 127 midi.send(ControlChange(midi_cc_num, modwheel_val), channel=midi_channel) elif i == mod_down_index: print('mod down!') modwheel_val = 0 midi.send(ControlChange(midi_cc_num, modwheel_val), channel=midi_channel) else: midi.send(PitchBend(8192), channel=midi_channel) midi.send(NoteOn(midi_base_note + i, midi_velocity), channel=midi_channel) if touch.fell: led.value = False print("release", i) if i == chan_up_index: pass
note_states[i] = True if buttons.value and note_states[ i] is True: # if the button is released... midi.send(NoteOff(midi_notes[i], 120, channel=5)) note_states[i] = False #read knob values cc_value = range_index(sAxis.value, 128, cc_value[0], cc_value[1]) cc_list.append(cc_value[0]) cc_list.pop(0) avgcc_val = round(sum(cc_list) / 30) if avgcc_val != last_cc_value[ 0]: # only send if it changed Form a MIDI CC message and send it: midi.send(ControlChange(1, avgcc_val)) last_cc_value = cc_value x_offset = filter_joystick_deadzone(xAxis.value) * -1 y_offset = filter_joystick_deadzone(yAxis.value) * -1 #Invert axis if x_offset > 6: if xswitch == 1 or midi_range > 3: continue for y in range(16): midi.send(NoteOff(midi_notes[y], 120)) note_states[y] = False midi_notes = [x + 16 for x in midi_notes] midi_range += 1 ledx_number += 1 led.color = (ledcolor[ledx_number][0], ledcolor[ledx_number][1],
if not mod_select.value: # if it is, then get modulation MIDI data from LIS3DH # positive and negative values for LIS3DH depending on # orientation of the guitar neck # when the guitar is held "normally" aka horizontal # then the modulation value is neutral aka 0 # compares previous LIS3DH value to current value if abs(acc_pos_val1 - acc_pos_val2) < 50: # updates previous value to hold current value acc_pos_val2 = acc_pos_val1 # MIDI data has to be sent as an integer # this converts the LIS3DH data into an int accelerator_pos = int(acc_pos_val2) # int is stored as a CC message accWheel_pos = ControlChange(1, accelerator_pos) # CC message is sent midi.send(accWheel_pos) # delay to settle MIDI data time.sleep(0.001) # same code but for negative values elif abs(acc_neg_val1 - acc_neg_val2) < 50: acc_neg_val2 = acc_neg_val1 accelerator_neg = int(acc_neg_val2) accWheel_neg = ControlChange(1, accelerator_neg) midi.send(accWheel_neg) time.sleep(0.001) # if it isn't then get modulation MIDI data from pot else:
from adafruit_midi.timing_clock import TimingClock from adafruit_midi.channel_pressure import ChannelPressure from adafruit_midi.control_change import ControlChange from adafruit_midi.note_off import NoteOff from adafruit_midi.note_on import NoteOn from adafruit_midi.pitch_bend import PitchBend from adafruit_midi.polyphonic_key_pressure import PolyphonicKeyPressure from adafruit_midi.program_change import ProgramChange from adafruit_midi.start import Start from adafruit_midi.stop import Stop from adafruit_midi.system_exclusive import SystemExclusive from adafruit_midi.midi_message import MIDIUnknownEvent import usb_midi midi = adafruit_midi.MIDI(midi_in=usb_midi.ports[0], midi_out=usb_midi.ports[1], in_channel=0, out_channel=0, debug=True) # UART = busio.UART(board.TX, board.RX, baudrate=31250, timeout=0.001) # midi = adafruit_midi.MIDI(midi_in=UART, midi_out=UART, in_channel=0, out_channel=0, debug=True) while True: print("-----") midi.send(Stop()) midi.send(NoteOn(60, 100)) midi.send(ControlChange(25, 127)) midi.send(ProgramChange(33)) time.sleep(1)
last_encoder_val = encoder.position ring_pos = (ring_pos + diff) % len(ring) # position on LED ring hue = colorwheel(encoder.position * 4 % 255) # fun hue change based on pos if not button.value: # button pressed cc_mult = cc_mult_coarse for i in range(len(ring)): # spin the rainbow while held pixel_index = (i * 256 // len(ring)) + rainbow_pos ring[i] = colorwheel(pixel_index & 255) ring.show() rainbow_pos = (rainbow_pos + 1) % 256 else: cc_mult = cc_mult_fine ring.fill([int(i / 4) for i in hue]) # make it 1/4 dimmer ring[ring_pos] = (255, 255, 255) ring[(ring_pos - 1) % len(ring)] = (67, 67, 67) ring[(ring_pos + 1) % len(ring)] = (67, 67, 67) ring.show() if diff != 0: # only send if there's a change print("sending") cc_val = cc_val - (diff * cc_mult) cc_val = max(min(127, cc_val), 0) # clamp to 0-127 #cc_val = 0 if n < 0 else 127 if n > 127 else cc_val # clamp to 0-127 midi.send([ControlChange(44, cc_val)]) print(encoder.position, diff, button.value, ring_pos, cc_val) time.sleep(0.05)
def sendCC(program, value): midi.send(ControlChange(program, value))
print("Unknown MIDI event status ", msg_in.status) elif msg_in is not None: midi.send(msg_in) key_event = macropad.keys.events.get() # check for keypad events if not key_event: # Event is None; no keypad event happened, do other stuff position = macropad.encoder # store encoder position state cc_position = int(constrain((position + CC_OFFSET), 0, 127)) # lock to cc range if last_position is None or position != last_position: if position < last_position: midi.send(ControlChange(LIVE_CC_NUMBER, cc_position)) print("CC", cc_position) cc_val_text_area.text = str(cc_position) elif position > last_position: midi.send(ControlChange(LIVE_CC_NUMBER, cc_position)) print("CC", cc_position) cc_val_text_area.text = str(cc_position) last_position = position macropad.encoder_switch_debounced.update( ) # check the encoder switch w debouncer if macropad.encoder_switch_debounced.pressed: print("Mod") push_text_area.text = "[.]" modifier = True
# simple_test import time import random import usb_midi import adafruit_midi from adafruit_midi.control_change import ControlChange from adafruit_midi.note_off import NoteOff from adafruit_midi.note_on import NoteOn from adafruit_midi.pitch_bend import PitchBend midi = adafruit_midi.MIDI(midi_out=usb_midi.ports[1], out_channel=0) print("Midi test") # Convert channel numbers at the presentation layer to the ones musicians use print("Default output channel:", midi.out_channel + 1) print("Listening on input channel:", midi.in_channel + 1 if midi.in_channel is not None else None) while True: midi.send(NoteOn(44, 120)) # G sharp 2nd octave time.sleep(0.25) a_pitch_bend = PitchBend(random.randint(0, 16383)) midi.send(a_pitch_bend) time.sleep(0.25) # note how a list of messages can be used midi.send([NoteOff("G#2", 120), ControlChange(3, 44)]) time.sleep(0.5)
midi = adafruit_midi.MIDI( midi_in=uart, midi_out=uart, in_channel=(midi_in_channel - 1), out_channel=(midi_out_channel - 1), debug=False, ) note_hold = 0.85 rest = note_hold / 5 print("MIDI Out demo") print("Default output channel:", midi.out_channel + 1) while True: # midi.send(ControlChange(64, 0)) # sustain CC midi.send(ControlChange(1, 0)) # modulation CC midi.send(NoteOn(48, 20)) # play note time.sleep(note_hold) # hold note midi.send(NoteOff(48, 0)) # release note time.sleep(rest) # rest midi.send(NoteOn(55, 40)) time.sleep(note_hold) midi.send(NoteOff(55, 0)) time.sleep(rest) midi.send(NoteOn(51, 60)) time.sleep(note_hold) midi.send(NoteOff(51, 0)) time.sleep(rest)