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)