def get_keys_for_scale(row_scale, starting_note, rotate, length, scale, key,
b_w):
keys = []
scale_notes = n.create_cell_to_midi_note_lookup(scale, -1, key,
62).values()
scale = n.SCALE_INTERVALS[row_scale]
for interval in scale:
keys.append(1)
for _gap in range(interval - 1):
keys.append(0)
if rotate:
keys = keys[rotate:] + keys[:rotate]
while (len(keys) < length):
keys.extend(keys)
for i, k in enumerate(keys):
if k == 1:
keys[i] = i + starting_note + 1
for i, k in enumerate(keys):
if k in scale_notes:
keys[i] = Key(k, c.KEY_SCALE)
elif k == 0:
keys[i] = Key(0, c.LED_BLANK)
else:
keys[i] = Key(k, c.KEY_WHITE if b_w == 'w' else c.KEY_BLACK)
return keys[:length]
def __init__(self, ins_num, mport, key, scale, octave=1, speed=1):
# super(Instrument, self).__init__()
# Thread.__init__(self, name="Ins: " + str(ins_num))
super().__init__()
self.daemon = True
self.instrument_cmd_bus = Queue()
self.type = "Generic Instrument"
self.ins_num = ins_num # Number of instrument in the sequencer - corresponds to midi channel
self.mport = mport
self.height = 16
self.width = 16
self.bars = 4
self.prev_loc_beat = 0
self.local_beat_position = 0
self.speed = speed # Relative speed of this instrument compared to global clock
self.key = key
self.scale = scale
self.octave = octave # Starting octave
self.is_drum = False
self.old_notes = [
] # Keep track of currently playing notes so we can off them next step
self.note_converter = create_cell_to_midi_note_lookup(
scale, octave, key, self.height)
self.selected_next_page_num = None
self.edit_page = None # Track which page we want to show and edit while playback continues
self.droplet_starts = []
self.pages = []
self.chaos = 0
self.sustain = False
self.OLED_Screens = proxy_registry('OLED_Screens')
def create_scalar_grid(scale, key):
keys = []
scale_notes = list(
n.create_cell_to_midi_note_lookup(scale, -1, key, 62).values())
root_notes = list(scale_notes)[::(5 if 'penta' in scale else 7)]
for octave, _y in enumerate(range(7)):
keys.append(
list(
n.create_cell_to_midi_note_lookup(scale, octave, key,
c.W).values()))
grid = []
for _x in range(5):
grid.append([Key(0, c.LED_BLANK) for i in range(c.W)])
for row in keys[::-1]:
grid.append([
Key(k, c.KEY_ROOT if (n in root_notes) else c.KEY_SCALE)
for i, k in enumerate(row)
])
for _x in range(4):
grid.append([Key(0, c.LED_BLANK) for i in range(c.W)])
return grid
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 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 __init__(self, ins_num, mport, key, scale, octave=1, speed=1):
super(Euclidean, self).__init__(ins_num, mport, key, scale, octave,
speed)
self.type = "Euclidean"
self.densities = [0 for x in range(8)]
self.offsets = [0 for x in range(8)]
self.lengths = [16 for x in range(8)]
self.curr_notes_pos = [0 for x in range(8)]
self.fill = True
self.scale = 'chromatic'
self.octave = 1
self.key = 'c'
self.is_drum = (True, scale, key, octave)
for i in range(8):
self.regen(i)
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
def create_guitar_grid(scale, key):
scale_notes = n.create_cell_to_midi_note_lookup(scale, -1, key,
62).values()
root_notes = list(scale_notes)[::(5 if 'penta' in scale else 7)]
start = 21 + n.KEYS.index(key)
grid = []
for _i, _r in enumerate(range(c.H - 2)):
row = []
for x in range(c.W):
note = start + x
sprite = c.KEY_SCALE if note in scale_notes else c.KEY_WHITE
if note in root_notes:
sprite = c.KEY_ROOT
row.append(Key(note, sprite))
start += 5
grid.append(row)
grid.append([Key(0, c.LED_BLANK) for i in range(c.W)])
grid.append([Key(0, c.LED_BLANK) for i in range(c.W)])
return grid[::-1]
def __init__(self, ins_num, mport, key, scale, octave=1, speed=1):
super(DrumMachine, self).__init__(ins_num, mport, key, scale, octave,
speed)
self.type = "Drum Machine"
self.is_drum = True
self.bars = 4
self.curr_page_num = 0
self.curr_rept_num = 0
self.prev_loc_beat = 0
self.local_beat_position = 0
self.random_pages = False # Pick page at random
self.sustain = False # Don't retrigger notes if this is True
self.pages = [Note_Grid(self.bars, self.height)]
self.key = 'c' # TODO find which starting note corresponds to pad 0
self.scale = 'chromatic'
self.octave = 1 # Starting octave
self.old_notes = [
] # Keep track of currently playing notes so we can off them next step
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
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 change_octave(self, up_down):
self.octave = up_down # TODO handle up and down as well as octave number
self.output(self.old_notes, [])
self.note_converter = create_cell_to_midi_note_lookup(
self.scale, self.octave, self.key, self.height)
return True
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_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
