tbish: wired up accent param better, tweaked distortion, added saw2 wave

Author: todbot

circuitpython/tbish/code.py

@@ -19,9 +19,9 @@
 from synth_setup_pts import (mixer, knobA, knobB, keys,
                              setup_display, setup_touch, check_touch)
 
-from param_set import ParamSet, Param
+from paramset import ParamSet, Param
 
-from tbish_synth import TBishSynth
+from tbish_synth import TBishSynth, waves
 from tbish_sequencer import TBishSequencer
 from tbish_ui import TBishUI
 
@@ -35,6 +35,9 @@
     [[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
 
+    [[36, 48, 36, 48,  36, 48, 36, 48],  # notes, 0 = rest
+     [127, 80, 1, 1,  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
 
@@ -50,37 +53,41 @@
 
 params = [
     #      name     val,  min,   max, str,  tb.attr name
-    Param("cutoff", 4000, 100, 6000, "%4d", 'cutoff'),
+    Param("cutoff", 3000, 100, 5000, "%4d", 'cutoff'),
     Param('envmod', 0.5,  0.0, 1.0, "%.2f",'envmod'), 
 
     Param("resQ",  1.0, 0.5, 4.0, "%.2f", 'resonance'),
     Param('decay', 0.75,  0.0, 1.0, "%.2f", 'decay'),
 
-    Param('drive', 30, 5, 40, "%2d", 'drive'),
+    
+    Param('accent', 0.2, 0.0, 1.0, "%.2f", 'accent'),
+    Param('wave', 0, 0, len(waves)-1, "%1d", 'wavenum'),
+
+    Param('drive', 0, 0.0, 1.0, "%.2f", 'drive'),
     Param('drivemix', 0.2, 0.0, 1.0, "%.2f", 'drive_mix'),
-        
-    Param('delay', 0.0, 0.0, 1.0, "%.2f", 'delay_mix'),
+    
     Param('dtime', 0.25, 0.0, 1.0, "%.2f", 'delay_time'),
+    Param('delaymix', 0.0, 0.0, 1.0, "%.2f", 'delay_mix'),
 
-    Param('seq', 0, 0, len(seqs), "%1d"),
-    Param('transpose', 0, -13, 13, "%2d", 'transpose'),
 
-    Param('wave', 1, 0, 2, "%1d", 'wavenum'),
+    Param('transpose', 0, -13, 13, "%2d", 'transpose'),
+    Param('what', 0.0, 0.0, 1.0, "%.2f", ),
+    
+    Param('seq', 0, 0, len(seqs)-1, "%1d"),
     Param('bpm', bpm, 40, 200, "%3d"),
 
 ]
 
-touchpad_to_knobset = [1,3,6,8,10,13]
+touchpad_to_knobset = [1,3,6,8,10,13,15]
 touchpad_to_transpose = [0,2,4,5,7,9,11,12,14]
 
 tb = TBishSynth(mixer.sample_rate, mixer.channel_count)
 tb_audio = tb.add_audioeffects()
 mixer.voice[0].play(tb_audio)
 
-sequencer = TBishSequencer(tb, seqs)
+sequencer = TBishSequencer(tb, seqs=seqs)
 sequencer.bpm = bpm
 sequencer.steps_per_beat = steps_per_beat
-
 param_set = ParamSet(params, num_knobs=2, knob_smooth=0.125)
 param_set.apply_params(tb)  # set up synth with param set
 
@@ -122,6 +129,7 @@ def update_ui():
 
         tb_disp.update_param_pairs()
 
+sequencer.on_step_callback = tb_disp.show_beat
 sequencer.start()
 
 while True:

circuitpython/tbish/param_set.py renamed to circuitpython/tbish/paramset.py

@@ -18,10 +18,6 @@
 
 import json
 
-KNOB_MODE_PICKUP = 0
-KNOB_MODE_SCALE = 1
-KNOB_MODE_RELATIVE = 2
-
 class Param:
     """Params are a UI- and implementation-independent way of describing
     a named numerical parameter with a min/max, a display format, and
@@ -64,12 +60,19 @@ def apply_to_obj(self,o):
             setattr(o, self.objattr, self.val)
 
 class ParamSet:
+
+    KNOB_PICKUP = 0
+    KNOB_SCALE = 1
+    KNOB_RELATIVE = 2
+
     """ParamSet is a collection of Params that track normalized knob positions,
     especially for the case when there are fewer knobs than Params.
     """
 
-    def __init__(self, params, num_knobs, min_knob_change=0.05, knob_smooth=0.5):
+    def __init__(self, params, num_knobs, min_knob_change=0.05,
+                 knob_smooth=0.5, knob_mode = KNOB_PICKUP):
         self.params = params
+        self.knob_mode = knob_mode
         self.nparams = len(params)
         self.nknobs = num_knobs
         self.min_change = min_knob_change
@@ -95,17 +98,50 @@ def idx(self, i):
         self._idx = i
 
     def update_knobs(self, new_knob_vals):
-        """new_knob_val is list of new knob vals, each 0.0-1.0"""
+        if self.knob_mode == ParamSet.KNOB_PICKUP:
+            self.update_knobs_pickup(new_knob_vals)
+        elif self.knob_mode == ParamSet.KNOB_SCALE:
+            self.update_knobs_scale(new_knob_vals)
+
+    def update_knobs_pickup(self, new_knob_vals):
+        """new_knob_vals is list of new knob vals, each 0.0-1.0"""
         for i in range(self.nknobs):
             param = self.params[ (self._idx * self.nknobs) + i ]
             new_val = param.knob_to_val(new_knob_vals[i])
             if self.is_tracking[i]:
-                param.val = self.smoothing * new_val + (1-self.smoothing) * param.val
+                # only change param val if difference is big enough FIXME
+                if abs(new_val - param.val) >= 0.1 * self.min_change * param.span:
+                    param.val = new_val
             else:
                 delta = param.val - new_val
                 if abs(delta) < self.min_change * param.span:
                     self.is_tracking[i] = True
-                    #param.val = new_val
+
+    def update_knobs_scale(self, new_knob_vals):
+        """new_knob_val is list of new knob vals, each normalized 0.0-1.0"""
+        # note this sucks currently
+        for i in range(self.nknobs):
+            param = self.params[ (self._idx * self.nknobs) + i ]
+            new_val = param.knob_to_val(new_knob_vals[i])
+            delta_val = new_val - param.val
+            
+            val_min, val_max = param.vmin, param.vmax
+            knob_min, knob_max = 0.0, 1.0
+            
+            val_max_pos_delta = val_max - param.val
+            val_min_pos_delta = param.val - val_min
+            knob_max_pos_delta = val_max - new_val
+            knob_min_pos_delta = new_val - val_min
+            
+            if delta_val > 0 and knob_max_pos_delta != 0:
+                val_percent_change = delta_val * val_max_pos_delta / knob_max_pos_delta
+            elif delta_val < 0 and knob_min_pos_delta != 0:
+                val_percent_change = delta_val * val_min_pos_delta / knob_min_pos_delta
+            else:
+                val_percent_change = 0
+
+            param.val = min(max(param.val + val_percent_change, val_min), val_max)
+            
 
     def apply_params(self, obj):
         """ Apply all params to given object """

circuitpython/tbish/tbish_sequencer.py

@@ -1,11 +1,11 @@
 import time
 
 class TBishSequencer:
-    def __init__(self, tb, seqs):
+    def __init__(self, tb, steps_per_beat=4, bpm=120, seqs=None):
         self.tb = tb
         self.seqs = seqs
-        self._steps_per_beat = 4   # 4 = 16th note, 2 = 8th note, 1 = quarter note
-        self.bpm = 120
+        self._steps_per_beat = steps_per_beat   # 4 = 16th note, 2 = 8th note, 1 = quarter note
+        self.bpm = bpm
         self.gate_time = 0
         self.gate_amount = 0.75  # traiditional 303 gate length
         self.next_step_time = 0
@@ -16,6 +16,7 @@ def __init__(self, tb, seqs):
         self.transpose = 0
         self.i = 0  # step number
         self.playing = True
+        self.on_step_callback = None
 
     @property
     def steps_per_beat(self):
@@ -43,10 +44,9 @@ def start(self):
     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)
@@ -60,6 +60,12 @@ def update(self):
             self.next_step_time = now + self._secs_per_step + dt  
             # add dt delta to attempt to make up for display hosing us
 
+            if self.on_step_callback:  # and (self.i % self._steps_per_beat)==0:
+                self.on_step_callback(self.i, self.steps_per_beat)
+
+            if not self.playing:
+                return
+            
             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

circuitpython/tbish/tbish_synth.py

@@ -52,11 +52,17 @@
 from pitch_glider import Glider
 
 wave_size = 128
-wave_vol = 32677
+wave_vol = 32767
+saw_offset = 5
+wave_saw =  np.linspace(wave_vol, -wave_vol, num=wave_size, dtype=np.int16)   # saw
+wave_squ =  np.concatenate((np.ones(wave_size//2, dtype=np.int16) * wave_vol,  # square
+                            np.ones(wave_size//2, dtype=np.int16) * -wave_vol))
+wave_saw2 = wave_saw//2 + np.roll(wave_saw,saw_offset)//2    # equiv to np.add()
+
 waves = (
-    np.linspace(wave_vol, -wave_vol, num=wave_size, dtype=np.int16),   # saw
-    np.concatenate((np.ones(wave_size//2, dtype=np.int16) * wave_vol,  # square
-                    np.ones(wave_size//2, dtype=np.int16) * -wave_vol)),
+    wave_squ,
+    wave_saw,
+    wave_saw2,
 )
 
 class TBishSynth:
@@ -66,7 +72,7 @@ def __init__(self, sample_rate, channel_count):
         self.note = None
         self.secs_per_step = 0.125  # fixme
         self.transpose = 0
-        self.wavenum = 1   # which waveform to use: saw=0, square=1
+        self.wavenum = 0   # which waveform to use: square=0, saw=1, saw2=2
         self.cutoff = 8000  # aka 'filter frequency'
         self.envmod = 0.5  # aka 'filter depth'
         self.decay = 0.01
@@ -87,12 +93,14 @@ def add_audioeffects(self):
 
         # No distortion on rp2040 (not enough CPU)
         self.fx_distortion = Distortion(**fxcfg, mix = 0.0,
+                                        #mode = audiofilters.DistortionMode.CLIP,
                                         mode = audiofilters.DistortionMode.LOFI,
                                         # other distortion modes are too slow? 
                                         #mode = audiofilters.DistortionMode.OVERDRIVE,
+                                        drive = 0.5,   # hmm this doesn't do what I expect
                                         soft_clip = True,
-                                        pre_gain = 30,
-                                        post_gain = -10)
+                                        pre_gain = 10,  # so we'll use pre-gain instead
+                                        post_gain = 0)
 
         # but yes filter on rp2040 with custom compile
         self.fx_filter1 = Filter(**fxcfg, mix=1.0)
@@ -108,7 +116,7 @@ def add_audioeffects(self):
 
         self.fx_delay = audiodelays.Echo(**fxcfg, mix=0.0,
                                          max_delay_ms = 400,
-                                         delay_ms = self.secs_per_step * 1000 * 2,
+                                         delay_ms = self.secs_per_step * 1000 * 4,
                                          decay = 0.1,
                                          freq_shift = False,
                                          )
@@ -121,18 +129,18 @@ def add_audioeffects(self):
 
     def note_on_step(self, midi_note, slide=False, accent=False):
         """Trigger a note, with slide and accent"""
-        print("note_on_step: %3d %1d %1d" % (midi_note, slide, accent))
+        print("note_on_step: %3d %1d %1d" % (midi_note, slide, accent), self.accent)
         self.note_off(midi_note) # must do when in step mode
         attack_level = 0.8
         cutoff = self.cutoff
         # resonance = self.resonance  # fixme how to do this
         envmod = self.envmod
         glide_time = 0.001  # minimal slide
         if accent:
-            attack_level +=  0.2 
-            cutoff *= 1.3   # FIXME: verify
-            #resonance *= 1.3
-            envmod *= 0.5
+            attack_level = min(1.0, attack_level + 0.5 * self.accent)
+            cutoff = cutoff + 0.3 * self.accent   # FIXME: verify
+            #resonance *= 1.3  # FIXME: how to do 
+            envmod = min(1.0, envmod + 0.25 * self.accent)
         if slide:
             glide_time = 0.1
             # FIXME also do appropriate other actions for slide
@@ -180,13 +188,15 @@ def resonance(self,q):
 
     @property
     def drive(self):
-        return self.fx_distortion.pre_gain
+        #return self.fx_distortion.drive
+        return self.fx_distortion.pre_gain / 50
 
     @drive.setter
     def drive(self,d):
-        self.fx_distortion.post_gain = -d/2
-        self.fx_distortion.pre_gain = d
-
+        #self.fx_distortion.drive = d  # hmm doesn't seem to work like I expect
+        self.fx_distortion.pre_gain = d * 50
+        self.fx_distortion.post_gain = self.fx_distortion.pre_gain * -0.5
+        
     @property
     def drive_mix(self):
         return self.fx_distortion.mix
@@ -205,8 +215,8 @@ def delay_mix(self, m):
 
     @property
     def delay_time(self):
-        return self.fx_delay.delay_ms / (self.secs_per_step * 100 * 4)
+        return self.fx_delay.delay_ms / (self.secs_per_step * 1000 * 4)
 
     @delay_time.setter
-    def delay_time(self, m):
-        self.fx_delay.delay_ms = self.secs_per_step * 1000 * 4 * m
+    def delay_time(self, t):
+        self.fx_delay.delay_ms = self.secs_per_step * 1000 * 4 * t   # FIXME: explain 4

circuitpython/tbish/tbish_ui.py

@@ -26,8 +26,10 @@ def __init__(self, display, params={}): #, knobAval, knobBval):
         palette = displayio.Palette(1)
         palette[0] = cw
         #self.rect = vectorio.Rectangle(pixel_shader=palette, width=64, height=1, x=32, y=1)
-        self.rect = vectorio.Rectangle(pixel_shader=palette, width=4, height=4, x=32, y=5)
-        self.append(self.rect)
+        self.paramspot = vectorio.Rectangle(pixel_shader=palette, width=4, height=4, x=32, y=5)
+        self.stepspot =  vectorio.Rectangle(pixel_shader=palette, width=5, height=5, x=64, y=60)
+        self.append(self.paramspot)
+        self.append(self.stepspot)
 
         for l in (self.textA, self.textB, self.labelA, self.labelB):
         #for l in (self.textA, self.textB):
@@ -37,9 +39,17 @@ def __init__(self, display, params={}): #, knobAval, knobBval):
 
     def next_param_pair(self):
         self.curr_param_pair = (self.curr_param_pair+1) % self.num_param_pairs
+
+    def show_beat(self, step, steps_per_beat):
+        # this doesn't work right but sorta works
+        if step % steps_per_beat == 0 :
+            self.stepspot.hidden = False
+        else:
+            self.stepspot.hidden = True
 
     def update_param_pairs(self):
-        self.rect.x = 45 + 5*(self.curr_param_pair)
+        self.paramspot.x = 45 + 4*(self.curr_param_pair)
+
         paramL = self.params[self.curr_param_pair*2+0]
         paramR = self.params[self.curr_param_pair*2+1]
         textAnew = paramL.fmt % paramL.val