def run(self):
debug("RGB")
while True:
# Check interrupt of all 4 encoders
# If interrupt, read encoder/button state
sleep(1)
return
def __init__(self, i2c_bus):
super().__init__()
self.led_matrix = [[BLANK for x in range(W)] for y in range(H)]
self.old_led_matrix = [[BLANK for x in range(W)] for y in range(H)]
self.trelli = [[] for i in range(int(H/4))] # [[],[]]
print("Creating Trelli")
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
self.trelli[x].append(t)
sleep(0.1)
pass
print("Linking Trelli")
self.trellis = MultiTrellis(self.trelli)
print("Trelli linked")
button_cb = self.make_button_cb()
print("Initializing Trelli inputs")
for y in range(H):
for x in range(W):
pass
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)
debug("Inputs initialized")
self.blank_screen()
def apply_control(self, x, y):
if y >= 8: # Control touch, but save it in the page, it's easier that way
y -= 8
if x < 8:
self.densities[y] = x
c.debug("calling regen...")
self.regen(x, y)
def touch_encoder(self, id, action):
c.debug("Encoder {id} {action}".format(id=id, action=action))
scroll_dir = {"+": "up", "-": "down"}.get(action, None)
if scroll_dir:
self.OLED_Screens.menu_scroll(id, scroll_dir)
if action == "button":
c.debug(self.OLED_Screens.touch(id).get())
return
def _process_incoming_midi(message):
'''Check for incoming midi messages and categorize so we can do something with them'''
if message.type == "clock":
self.count += 1
self.count %= 24
debug(self.count)
tick = self.process_midi_tick()
self.midi_in_bus.put(tick)
def run(self):
debug("MidiOut starting")
while self.keep_running:
msgs = self.midi_out_bus.get()
for msg in msgs:
self.mportout.send(msg)
# debug(msg)
return
def __init__(self, inp):
Thread.__init__(self, name='Clock')
self.daemon = True
self.input = inp
debug("Clock input is " + str(inp))
self.ticker_bus = bus_registry.get('ticker_bus')
self.midi_in_bus = bus_registry.get('midi_in_bus')
self.clock_bus = bus_registry.get('clock_bus')
self.keep_running = True
def set_input(self, inp):
# TODO maybe delete this, no need to change inputs mid-set
if inp == self.input:
return
debug("Changing clock input to " + inp)
self.input = inp
self.midi_in_bus.queue.clear()
self.ticker_bus.queue.clear()
return
def run(self):
self.mportin.callback = self.process_incoming_midi()
debug("MidiInListener starting")
while self.keep_running:
# beat = randint(110,120)
# debug("midi still running")
sleep(1)
# self.midi_in_bus.put("x")
return
def run(self):
debug("Clock started")
while self.keep_running:
if self.input == "midi":
x = self.midi_in_bus.get()
self.clock_bus.put(x)
else:
x = self.ticker_bus.get()
self.clock_bus.put(x)
return
def import_yaml(self, yaml):
self.brightness = yaml['brightness']
self.gradient_from = Color(yaml['gradient']['from'])
self.gradient_to = Color(yaml['gradient']['to'])
c.debug(yaml['pallette'])
for p in c.pallette_lookup.keys():
c.debug(p)
self.pallette[p] = yaml['pallette'][c.pallette_lookup[p]]
self
return
def add_instrument(self, type):
if len(self.instruments) == 16:
return
ins_type = instrument_lookup(type)
c.debug(ins_type)
new_ins = ins_type.start(ins_num=len(self.instruments),
**self.instrument_ctx()).proxy()
c.debug(new_ins)
self.instruments.append(new_ins)
return
def run(self):
c.debug("Display thread started")
while self.keep_running:
sleep(0.01)
m = self.get_cmds()
if m.get('cmd') != None:
c.debug(m)
self.button_grid_bus.put(m)
if not self.LED_grid_bus.empty():
status, led_grid, oled_data = self.LED_grid_bus.get()
self.draw_all(status, led_grid, oled_data)
def __init__(self, initial_bpm):
Thread.__init__(self, name='SelfTicker')
self.daemon = True
self.bpm = initial_bpm
if initial_bpm:
debug("ticker's bpm is " + str(initial_bpm))
self.ticker_bus = bus_registry.get('ticker_bus')
self.beat_clock_count = 0
self.midi_clock_divider = 32
self.midi_out_bus = bus_registry.get('midi_out_bus')
self.keep_running = True
def regen(self, amt, note):
'''A randomize menu bar has been clicked, regen that bar's notes'''
c.debug("regen")
gen_notes = [self.calc_chance(amt) for x in range(16)]
page = self.get_curr_page()
gen_notes = [{
True: c.NOTE_ON,
False: c.NOTE_OFF
}[note] for note in gen_notes]
for i, beat in enumerate(page.note_grid):
beat[note] = gen_notes[i]
return
def process_midi_tick(self):
'''Perform midi tick subdivision so ticks only happen on beats'''
# self.beat_count += 1
# if self.beat_count >= self.midi_beat_divider:
self.clock_count += 1
if self.clock_count >= self.midi_clock_divider:
self.clock_count %= self.midi_clock_divider
debug("----------------------")
return BEAT
debug("---")
return TICK
def run(self):
if not self.bpm:
debug("Not using self ticker")
return
debug("SelfTicker started")
sleep_period = 60/self.bpm
while self.keep_running:
sleep(sleep_period)
tick = self.process_midi_tick()
self.ticker_bus.put(tick)
if self.midi_out_bus:
self.midi_out_bus.put([Message('clock')])
return
def run(self):
debug("Display thread started")
while True:
sleep(0.01)
m = self.get_cmds()
if m.get('cmd') != None:
debug(m)
self.button_bus.put(m)
if not self.led_bus.empty():
status, led_grid = self.led_bus.get()
self.draw_all(status, led_grid)
return
def run(self):
debug("Supervisor running...")
self.draw()
while self.keep_running:
if not self.button_grid_bus.empty():
# debug("button pressed")
m = self.button_grid_bus.get()
self.process_cmds(m)
self.draw()
if not self.clock_bus.empty():
clock_tick = self.clock_bus.get()
self.conductor.step_beat(clock_tick)
self.draw()
sleep(0.01)
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 output(self, notes_off, notes_on):
"""Return all note-ons from the current beat, and all note-offs from the last"""
notes_off = [n for n in notes_off if n < 128 and n > 0]
notes_on = [n for n in notes_on if n < 128 and n > 0]
off_msgs = [
mido.Message('note_off', note=n, channel=self.ins_num)
for n in notes_off
]
on_msgs = [
mido.Message('note_on', note=n, channel=self.ins_num)
for n in notes_on
]
msgs = off_msgs + on_msgs
if len(msgs) > 0:
c.debug(msgs)
midi_out_bus.put(msgs)
def run(self):
debug(f"{self.name} started")
while True:
# sleep(0.01)
msg = self.inbox.get()
debug(f"{self.name} received '{msg}'")
if len(msg) < 2:
debug(f"{self.name} stopping")
break
debug('..')
self.send(self.buddy, msg[:-1])
return
def get_cmds(self):
try:
self.trellis.sync() # TODO undo? Fails if called too often
except Exception as e:
debug("HW error: {}".format(str(e)))
m = {'cmd': None}
if self.read_gbl_button():
if self.state != 'gbl_cfg':
m['cmd'] = "CONFIG_A"
self.state = 'gbl_cfg'
else:
self.state = 'play'
elif self.read_ins_button():
if self.state != 'ins_cfg':
m['cmd'] = "CONFIG_B"
self.state = 'ins_cfg'
else:
self.state = 'play'
return m
def touch_note(self, state, x, y):
'''touch the x/y cell on the current page'''
if not x % 2:
return
c.debug("!")
osc = int((x - 1) / 2)
# c.debug(osc)
if y == 15:
# Play/Pause button
c.debug(f"play/pause {osc}")
self.oscillators[osc].running = not self.oscillators[osc].running
if y == 0:
c.debug(f"selected {osc}")
self.selected_osc = osc
c.debug(self.selected_osc)
return True
def hardware_main():
from interfaces.hardware import Display
from interfaces.oled_hw import OLED_Screens
# from interfaces.encoders import Encoder_Inputs, Encoder_RGB
from interfaces.i2c_bus import i2c_bus
# TODO create i2c bus here, pass to Display
display = Display(i2c_bus)
# encoders = Encoder_Inputs(encoder_out_bus, button_grid_bus, i2c_bus)
# encoders.start()
# encoders_RGB = Encoder_RGB(encoder_in_bus, i2c_bus)
# encoders_RGB.start()
debug(mido.get_input_names())
debug(mido.get_output_names())
debug("Creating MIDI ports")
with mido.open_output('f_midi:f_midi 16:0') as mportout:
with mido.open_input('f_midi:f_midi 16:0') as mportin:
start_supervisor(display, mportin, mportout, bpm)
def start_supervisor(display, mportin, mportout, bpm):
midi_in = MidiInListener(mportin)
midi_out = MidiOut(mportout)
ticker = SelfTicker(bpm)
clock = Clock('tick' if bpm else 'midi')
midi_in.start()
midi_out.start()
ticker.start()
clock.start()
display.start()
supervisor = Supervisor()
try:
supervisor.run()
finally:
debug("Stopping everything")
midi_in.keep_running = False
midi_out.keep_running = False
ticker.keep_running = False
clock.keep_running = False
display.keep_running = False
supervisor.keep_running = False
debug("Threads stopped")
exit()
debug("exiting?")
def add(self, name, bus):
debug("add")
debug(name)
debug(bus)
self.registry[name] = bus
from supervisor import Supervisor
import mido
import argparse
from buses import midi_in_bus, midi_out_bus, LED_grid_bus, button_grid_bus, clock_bus, ticker_bus
from midi_input import MidiInListener
from midi_output import MidiOut
from clock import Clock
from ticker import SelfTicker
from constants import debug
# import atexit
parser = argparse.ArgumentParser()
parser.add_argument("--hw", help="Use real hardware", type=bool)
parser.add_argument("--bpm", help="Use real hardware", type=int)
args = parser.parse_args()
debug(args)
bpm = int(args.bpm) if args.bpm else None
def console_main(stdscr):
from interfaces.console import Display
from interfaces.oled_sw import OLED_Screens
OLED_Screens = OLED_Screens.start(4)
curses.mousemask(1)
curses.mouseinterval(10)
curses.curs_set(0)
stdscr.nodelay(1)
display = Display(stdscr)
with mido.open_output('supervisor_Out', autoreset=True,
virtual=True) as mportout:
with mido.open_input('supervisor_In', autoreset=True,
def touch(self):
if self.menu_mode:
return self.get_menu_item()
else:
debug(f"touched encoder {self.num}")
from constants import debug
from board import SCL, SDA
import busio
debug("Creating i2c bus")
I2C_BUS = busio.I2C(SCL, SDA)
debug("Done")
