def cb_clip(self, x, y):
page_num = (4 * y) + x
if page_num + 1 > len(self.pages):
return
self.selected_next_page_num = page_num
lcd.flash("Next page {}".format(page_num))
return
def cb_edit_page(self, x, y):
if self.edit_page is not None:
self.edit_page = None
lcd.flash("Edit mode disabled")
else:
self.edit_page = self.curr_page_num
# lcd.flash(f"Editing page {self.edit_page}")
return
def cycle_key(self, up_down):
'''Find current key in master list, move on to prev/next key, set in all instruments'''
curr_key = KEYS.index(self.key)
new_key = (curr_key + up_down) % len(KEYS)
self.key = KEYS[new_key]
for i in self.instruments:
i.set_key(self.key)
c.logging.info(i.type)
# c.logging.info(f"Scale {self.key}")
lcd.flash("Key {}".format(self.key))
return
def cycle_scale(self, up_down):
'''Find current scale in master list, move on to prev/next scale, set in all instruments'''
curr_scale = list(SCALE_INTERVALS.keys()).index(self.scale)
new_scale = (curr_scale + up_down) % len(SCALE_INTERVALS.keys())
self.scale = list(SCALE_INTERVALS.keys())[new_scale]
for i in self.instruments:
i.set_scale(self.scale)
c.logging.info(i.type)
# c.logging.info(f"Scale {self.scale}")
lcd.flash("Scale {}".format(self.scale))
return
def set(self, value):
if value > self.height:
return # Not possible
self.value = value
cc = self.get_cc()
c.logging.info("CC{} = {}, {}".format(self.cc_num, self.value, cc))
lcd.flash("CC{} = {}, {}".format(self.cc_num, self.value, cc))
msg = mido.Message('control_change',
value=cc,
control=self.cc_num,
channel=0)
return msg
def add_page(self, pos=True):
'''Add or insert a new blank page into the list of pages'''
if len(self.pages) == 16:
lcd.flash("Max pages reached")
return False
if pos:
self.pages.insert(self.curr_page_num + 1,
Note_Grid(self.bars, self.height))
else:
self.pages.append(Note_Grid(self.bars, self.height))
lcd.flash("Added page")
return True
def set_key(self, key):
# c.logging.info(f"set key {key}")
if self.is_drum:
c.logging.info(self.is_drum)
self.is_drum = (True, self.scale, key, self.octave)
c.logging.info(self.is_drum)
return
self.key = key # Converter is a cached lookup, we need to regenerate it
self.output(self.old_notes, [])
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
lcd.flash("Key {}".format(key))
return True
def set_scale(self, scale):
# c.logging.info(f"set scale {scale}")
if self.is_drum:
c.logging.info(self.is_drum)
self.is_drum = (True, scale, self.key, self.octave)
c.logging.info(self.is_drum)
return
self.scale = scale # Converter is a cached lookup, we need to regenerate it
self.output(self.old_notes, [])
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
lcd.flash("Scale {}".format(scale))
return True
def cb_reset(self, x, y):
self.beat_position = 0
for i in self.instruments:
i.local_beat_position = 0
try:
i.curr_page_num = 0
i.curr_rept_num = 0
except Exception as e:
str(e)
pass
if i.type == 'Droplets':
i.droplet_positions = [d for d in i.droplet_starts]
self.current_state = 'play'
lcd.flash("Reset all")
return
def cb_instrument_type(self, x, y):
if self.get_total_instrument_num() >= 16:
return
ins = instrument_lookup(y + 1) # +1 because base class isn't playable
new_ins = ins.start(ins_num=self.get_total_instrument_num(),
**self.instrument_ctx()).proxy()
self.instruments.append(new_ins)
lcd.flash("Added {}".format(self.instruments[~0].type))
try:
OLED_Screens = proxy_registry('OLED_Screens')
OLED_Screens.text(0, [str(new_ins.type.get())])
OLED_Screens.text(1, [str(y + 1)])
OLED_Screens.text(2, [str(ins)])
except Exception as e:
c.debug(str(e))
def cb_copy_page(self, x, y):
page = y
if y >= len(self.pages):
c.logging.info(self.curr_page_num)
c.logging.info(str(len(self.pages)))
self.add_page(pos=False)
self.pages[self.curr_page_num + 1].note_grid = deepcopy(
self.pages[self.curr_page_num].note_grid)
c.logging.info(self.curr_page_num)
c.logging.info(str(len(self.pages)))
return
page_num = (4 * y) + x
self.selected_next_page_num = page_num
lcd.flash("Copied page {}".format(page))
return
def cb_drum(self, x, y):
if self.is_drum:
c.logging.info(self.is_drum)
self.scale = self.is_drum[1]
self.key = self.is_drum[2]
self.octave = self.is_drum[3]
self.is_drum = False
# c.logging.info(f"Reverting to {self.scale}, {self.key}, {self.octave}")
# lcd.flash(f"Reverting to {self.scale}")
else:
self.is_drum = (True, self.scale, self.key, self.octave)
c.logging.info("Drum mode")
c.logging.info(self.is_drum)
self.scale = 'chromatic'
self.key = 'c'
self.octave = 1
lcd.flash("Drum mode")
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
return
def cb_page(self, x, y):
page = y
if y >= len(self.pages):
self.add_page(pos=False)
lcd.flash("Added page")
return
if x == 0:
if self.pages[y].repeats == 1:
self.pages[y].repeats = 0
lcd.flash("Page {} rpt 0".format(page + 1))
else:
self.pages[y].repeats = 1
lcd.flash("Page {} rpt 1".format(page + 1))
return
else:
self.pages[y].repeats = x + 1
lcd.flash("Page {} rpt {}".format(page + 1, self.pages[y].repeats))
return
def cb_sustain(self, x, y):
self.sustain = not self.sustain
lcd.flash("Sustain {}".format(self.sustain))
return
def cb_octave(self, x, y):
self.octave = x
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
lcd.flash("Octave {}".format(self.octave))
return
def cb_instrument_sel(self, x, y):
if int(y) < self.get_total_instrument_num():
self.set_curr_instrument(int(y))
self.current_state = 'play'
lcd.flash("Selected {}".format(self.get_curr_instrument().type))
return
def cb_fill(self, x, y):
self.fill = False if self.fill else True
lcd.flash("Fill {}".format(self.fill))
return
def cb_save(self, x, y):
self.current_state = 'save'
lcd.flash("Select save file")
return
def cb_load(self, x, y):
self.current_state = 'load'
lcd.flash("Select load")
return
def cb_random_pages(self, x, y):
self.random_pages = not self.random_pages
lcd.flash("Random {}".format(self.random_pages))
return
def __init__(self, button_bus, led_bus, i2c_bus):
Thread.__init__(self, name='Display')
# super(Display, self).__init__()
self.button_bus = button_bus
self.led_bus = led_bus
debug("Creating i2c bus")
lcd.flash("Creating i2c bus")
# i2c_bus = busio.I2C(SCL, SDA)
lcd.setup_hw(i2c_bus)
debug("i2c bus created")
lcd.flash("i2c bus created")
debug("Creating Trelli")
lcd.flash("Creating Trelli")
trelli = [[], [], [], []]
# addrs = trellis_addresses
# Create trelli sequentially with a slight pause between each
for x, slice in enumerate(trellis_addresses):
for y, addr in enumerate(slice):
t = NeoTrellis(i2c_bus, False, addr=addr)
t.pixels.auto_write = False
trelli[x].append(t)
sleep(0.1)
debug("Linking Trelli")
lcd.flash("Linking Trelli")
self.trellis = MultiTrellis(trelli)
debug("Trelli linked")
lcd.flash("Trelli linked")
self.grid_h = H
self.grid_w = W
self.state = 'play'
self.led_matrix = [[(0, 0, 0) for x in range(w)] for y in range(h)]
self.old_led_matrix = [[(0, 0, 0) for x in range(w)] for y in range(h)]
button_cb = self.make_cb()
debug("Initializing Trelli inputs")
lcd.flash("Initializing Trelli inputs")
for y in range(self.grid_h):
for x in range(self.grid_w):
sleep(0.01)
self.trellis.activate_key(x, y, NeoTrellis.EDGE_RISING)
sleep(0.01)
self.trellis.activate_key(x, y, NeoTrellis.EDGE_FALLING)
self.trellis.set_callback(x, y, button_cb)
self.ins_button = digitalio.DigitalInOut(D13)
self.gbl_button = digitalio.DigitalInOut(D6)
debug("Inputs initialized")
lcd.flash("Inputs initialized")
self.col_scheme = select_scheme('default')
return
def cb_speed(self, x, y):
self.speed = x
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
lcd.flash("Speed {}".format(self.speed))
return