tbish: pulled out simple step sequencer to its own class, modeled after synth_tools.step_sequencer

Author: todbot

circuitpython/tbish/code.py

@@ -9,6 +9,9 @@
 14 May 2025 - @todbot / Tod Kurt
 
 """
+# this reduces some of per-step latency from 10ms down to 6ms
+import microcontroller
+microcontroller.cpu.frequency = 200_000_000
 
 import time, random
 import ulab.numpy as np
@@ -19,32 +22,28 @@
 from param_set import ParamSet, Param
 
 from tbish_synth import TBishSynth
+from tbish_sequencer import TBishSequencer
 from tbish_ui import TBishUI
 
 display = setup_display()
 touches = setup_touch()
 
-playing = True
-bpm = 120
-steps_per_beat = 2
-secs_per_step = 60 / bpm / steps_per_beat
-glide_time = 0.25
 seqs = [
     [[36, 36, 48, 36,  48, 48+7, 36, 48],  # notes, 0 = rest
-     [127, 80, 80, 80,  127, 1, 30, 1]],   # vels, 1=slide, 127=accent  
+     [127, 80, 80, 80,  127, 1, 30, 1]],   # vels, 1=slide, 127=accent
+    
     [[34, 36, 34, 36,  48, 48, 36, 48],    # notes, 0 = rest
-     [127, 80, 120, 80,  127, 11, 127, 80]],  # vels 127=accent  
-    [[36, 36+12, 36, 36+12,  36, 0, 36, 0],    # notes, 0 = rest
-     [127, 80, 120, 80,  127, 80, 127, 80]],  # vels 127=accent  
+     [127, 80, 120, 80,  127, 11, 127, 80]],  # vels 127=accent
+    
+    [[36, 36-12, 36, 36+12,  36, 0, 36, 0],    # notes, 0 = rest
+     [127,  1,   1, 80,  127, 80, 127, 80]],  # vels 127=accent  
 ]
-seq_num = 0
-
-midi_note = seqs[seq_num][0][0]
-next_midi_note = 0
-gate_off_time = 0
-gate_amount = 0.75  # TB-303 historical gate lengnth
-transpose = 0
-i=0
+# future path
+seqs_steps = [
+    [[ ],  # notes,
+     [ ],  # slide,
+     [ ],],  # accent,
+]    
 
 params = [
     Param("cutoff", 4000, 200, 6000, "%4d", 'cutoff'),
@@ -70,6 +69,8 @@
 tb_audio = tb.add_audioeffects()
 mixer.voice[0].play(tb_audio)
 
+sequencer = TBishSequencer(tb, seqs)
+
 param_set = ParamSet(params, num_knobs=2)
 param_set.apply_params(tb)  # set up synth with param set
 
@@ -78,19 +79,22 @@
 print("="*80)
 print("tbish synth! press button to play/pause")
 print("="*80)
-print("secs_per_step:%.3f" % secs_per_step)
+print("secs_per_step:%.3f" % sequencer._secs_per_step)
 import gc
 print("mem_free:", gc.mem_free())
 
 last_ui_time = time.monotonic()
 def update_ui():
-    global last_ui_time, gate_amount, bpm, secs_per_step
+    global last_ui_time
     ki = tb_disp.curr_param_pair  # shorthand
     if time.monotonic() - last_ui_time > 0.05:
         last_ui_time = time.monotonic()
 
+        # bit-reduction filtering then normalize
+        #knobvals = (knobA.value, knobB.value)
+        #knobvals = [((k>>8)<<8)/65535 for k in knobvals]
+        # just normalized
         knobvals = (knobA.value/65535, knobB.value/65535)
-        #knobvals = [int(k)>>8<<8 for k in knobvals]
         param_set.update_knobs(knobvals)
 
         # set synth with params
@@ -99,21 +103,23 @@ def update_ui():
         # for non-tb params
         #gate_amount = param_set.param_for_name('gate').val
         bpm = param_set.param_for_name('bpm').val
-        secs_per_step = 60 / bpm / steps_per_beat
-
+        sequencer.bpm = bpm
+        
+        seq_num = int(param_set.param_for_name('seq').val)
+        sequencer.seq_num = seq_num
+        
         tb_disp.update_param_pairs()
 
-next_step_time = time.monotonic()
+sequencer.start()
 
 while True:
 
     if key := keys.events.get():
         if key.pressed:
-            playing = not playing
-            if playing:
-                next_step_time = time.monotonic()
+            if sequencer.playing:
+                sequencer.stop()
             else:
-                tb.note_off(midi_note)
+                sequencer.start()
 
     if touch_events := check_touch():
         for touch in touch_events:
@@ -124,39 +130,10 @@ def update_ui():
                     param_set.idx = tb_disp.curr_param_pair
                 if touch.key_number in touchpad_to_transpose:
                     transpose = touch.key_number   # chromatic
+                    sequencer.transpose = transpose
 
     update_ui()
 
-    if not playing:
-        continue
-    
-    now = time.monotonic()
-    if gate_off_time and gate_off_time - now <= 0:
-        gate_off_time = 0
-        #if next_midi_note != 0:
-        tb.note_off(midi_note)
-
-    dt = (next_step_time - now)
-    if dt <= 0:
-        next_step_time = now + secs_per_step + dt  
-        # add dt delta to attempt to make up for display hosing us
-
-        midi_note = seqs[seq_num][0][i]
-        vel       = seqs[seq_num][1][i]
-        if midi_note != 0:
-            midi_note += transpose
-            vel = vel  # + random.randint(-30,0)
-            tb.secs_per_step = secs_per_step * 1.0
-            tb.note_on(midi_note, vel)
-            #tb.note_on(midi_note, True, False)
-            gate_off_time = time.monotonic() + secs_per_step * gate_amount
-
-        seq_num = int(param_set.param_for_name('seq').val)
-        i = (i+1) % len(seqs[seq_num][0])
-        #next_midi_note = midi_notes[i]
-        print(i,"new: %d old: %d glide_time: %.2f vel:%3d" %
-              (midi_note, tb.glider.midi_note, tb.glider.glide_time, vel),
-              tb.filt_env.offset, tb.filt_env.scale)
-
+    sequencer.update()
 
 

circuitpython/tbish/param_set.py

@@ -64,7 +64,7 @@ class ParamSet:
     especially for the case when there are fewer knobs than Params.
     """
 
-    def __init__(self, params, num_knobs, min_knob_change=0.1, knob_smooth=0.5):
+    def __init__(self, params, num_knobs, min_knob_change=0.05, knob_smooth=0.5):
         self.params = params
         self.nparams = len(params)
         self.nknobs = num_knobs

circuitpython/tbish/tbish_sequencer.py

@@ -0,0 +1,79 @@
+import time
+
+class TBishSequencer:
+    def __init__(self, tb, seqs):
+        self.tb = tb
+        self.seqs = seqs
+        self._steps_per_beat = 4   # 4 = 16th note, 2 = 8th note, 1 = quarter note
+        self.bpm = 120
+        self.gate_time = 0
+        self.gate_amount = 0.75  # traiditional 303 gate length
+        self.next_step_time = 0
+        self.gate_off_time = 0
+        self.midi_note = 0   # current note being played or 0 for none
+        self.seqs = seqs
+        self.seq_num = 0
+        self.transpose = 0
+        self.i = 0  # step number
+        self.playing = True
+
+    @property
+    def steps_per_beat(self):
+        return self._steps_per_beat
+    
+    @steps_per_beat.setter
+    def steps_per_beat(self, s):
+        self._steps_per_beat = s
+        self._secs_per_step = 60 / self._bpm / self._steps_per_beat       
+    
+    @property
+    def bpm(self):
+        return self._bpm
+    
+    @bpm.setter
+    def bpm(self, b):
+        self._bpm = b
+        self._secs_per_step = 60 / self._bpm / self._steps_per_beat
+
+    def start(self):
+        self.playing = True
+        self.i = 0
+        self.next_step_time = time.monotonic()
+
+    def stop(self):
+        self.playing = False
+        self.tb.note_off(self.midi_note)
+    
+    def update(self):
+        if not self.playing:
+            return
+        now = time.monotonic()
+    
+        # turn off note (not really a TB-303 thing, but a MIDI thing)
+        if self.gate_off_time and self.gate_off_time - now <= 0:
+            self.gate_off_time = 0
+            self.tb.note_off(self.midi_note)
+
+        # time for next step? 
+        dt = (self.next_step_time - now)
+        if dt <= 0:
+            self.next_step_time = now + self._secs_per_step + dt  
+            # add dt delta to attempt to make up for display hosing us
+
+            midi_note = self.seqs[self.seq_num][0][self.i]
+            vel       = self.seqs[self.seq_num][1][self.i]
+            if midi_note != 0:    # midi_note == 0 = rest
+                midi_note += self.transpose
+                vel = vel  # + random.randint(-30,0)
+                self.tb.secs_per_step = self._secs_per_step * 1.0
+                self.tb.note_on(midi_note, vel)
+                #self.tb.note_on(midi_note, True, False)
+                self.gate_off_time = time.monotonic() + self._secs_per_step * self.gate_amount
+
+            #seq_num = int(param_set.param_for_name('seq').val)
+            self.i = (self.i+1) % len(self.seqs[self.seq_num][0])
+            self.midi_note = midi_note
+        
+            print(self.i,"note: %d vel:%3d" % (midi_note, vel),
+                  int(self._secs_per_step*1000), int(dt*1000))
+

circuitpython/tbish/tbish_synth.py

@@ -69,6 +69,7 @@ def __init__(self, sample_rate, channel_count):
         self.cutoff = 8000  # aka 'filter frequency'
         self.envmod = 0.5  # aka 'filter depth'
         self.envdecay = 0.01
+        self._accent = 0.5
         self.autoslide = True  # FIXME unused yet
         self.filt_env = synthio.LFO(rate=1, scale=self.cutoff, once=True,
                                     waveform=np.array((32767,0),dtype=np.int16))
@@ -108,14 +109,12 @@ def add_audioeffects(self):
                                          decay = 0.1,
                                          freq_shift = False,
                                          )
-        print("delay_ms=", self.secs_per_step * 1000 * 4)
-        #self.fx_delay = ...   # FIXME: add tempo-sync'd delay
         self.fx_delay.play(self.fx_distortion)
         self.fx_distortion.play(self.fx_filter2)  # plug 2nd filter into distortion
         self.fx_filter2.play(self.fx_filter1)  # plug 1st filter into 2nd filter
         self.fx_filter1.play(self.synth)   # plug synth into 1st filter
-        #return self.fx_distortion  # this "output" of this synth
-        return self.fx_delay
+        #return self.fx_distortion  # the "output" of this synth
+        return self.fx_delay   # the "output" of this synth
 
     def note_on_step(self, midi_note, slide=False, accent=False):
         print("note_on_step:", midi_note, slide, accent)
@@ -130,7 +129,7 @@ def note_on(self, midi_note, vel=127):
         self.note_off(midi_note)  # just in case
 
         #frate = 1 / self.secs_per_step
-        envdecay = max(0.05, self.secs_per_step * self.envdecay)
+        envdecay = max(0.05, self.secs_per_step * self.envdecay * 1.5)  # 1.5 fudge 
         frate = 1 / envdecay
         cutoff = self.cutoff * 1.3 if vel==127 else self.cutoff  # FIXME verify
         envmod = self.envmod * 0.5 if vel==127 else self.envmod
@@ -167,6 +166,14 @@ def decay(self):
     def decay(self,t):
         self.envdecay = t
 
+    @property
+    def accent(self):
+        return self.accent
+    
+    @accent.setter
+    def accent(self, v):
+        self.accent = v
+        
     @property
     def drive(self):
         return self.fx_distortion.pre_gain

circuitpython/tbish/tbish_ui.py

@@ -42,10 +42,16 @@ def update_param_pairs(self):
         self.rect.x = 45 + 5*(self.curr_param_pair)
         paramL = self.params[self.curr_param_pair*2+0]
         paramR = self.params[self.curr_param_pair*2+1]
-        self.labelA.text = paramL.name
-        self.labelB.text = paramR.name
-        self.textA.text = paramL.fmt % paramL.val
-        self.textB.text = paramR.fmt % paramR.val
-        #print("refreshing")
+        textAnew = paramL.fmt % paramL.val
+        textBnew = paramR.fmt % paramR.val
+        # try to be smart and only update what's needed
+        if paramL.name != self.labelA.text:
+            self.labelA.text = paramL.name
+        if paramR.name != self.labelB.text:
+            self.labelB.text = paramR.name
+        if self.textA.text != textAnew:
+            self.textA.text = textAnew
+        if self.textB.text != textBnew:
+            self.textB.text = textBnew
         self.display.refresh()