hooked up delay to knobs, added first cut at save/load of ParamSets

Author: todbot

circuitpython/tbish/code.py

@@ -28,6 +28,9 @@
 display = setup_display()
 touches = setup_touch()
 
+bpm = 180
+steps_per_beat = 2   # 4 = 16th note, 2 = 8th note, 1 = quarter note
+
 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
@@ -46,20 +49,22 @@
 ]    
 
 params = [
-    Param("cutoff", 4000, 200, 6000, "%4d", 'cutoff'),
+    #      name     val,  min,   max, str,  tb.attr name
+    Param("cutoff", 4000, 100, 6000, "%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.5,  0.0, 1.0, "%.2f", 'decay'),
+    Param('decay', 0.75,  0.0, 1.0, "%.2f", 'decay'),
 
-    Param('drive', 20, 5, 40, "%2d", 'drive'),
+    Param('drive', 320, 5, 40, "%2d", 'drive'),
     Param('drivemix', 0.2, 0.0, 1.0, "%.2f", 'drive_mix'),
 
-    Param('delay', 0.3, 0.0, 1.0, "%.2f"),
-    Param('dtime', 0.25, 0.0, 1.0, "%.2f"),
+    Param('delay', 0.0, 0.0, 1.0, "%.2f", 'delay_mix'),
+    Param('dtime', 0.25, 0.0, 1.0, "%.2f", 'delay_time'),
 
     Param('seq', 0, 0, len(seqs), "%1d"),
-    Param('bpm', 120, 40, 200, "%3d"),
+    Param('bpm', bpm, 40, 200, "%3d"),
+    
 ]
 
 touchpad_to_knobset = [1,3,6,8,10] # ,13]
@@ -70,8 +75,10 @@
 mixer.voice[0].play(tb_audio)
 
 sequencer = TBishSequencer(tb, seqs)
+sequencer.bpm = bpm
+sequencer.steps_per_beat = steps_per_beat
 
-param_set = ParamSet(params, num_knobs=2)
+param_set = ParamSet(params, num_knobs=2, knob_smooth=0.125)
 param_set.apply_params(tb)  # set up synth with param set
 
 tb_disp = TBishUI(display, params)
@@ -87,14 +94,16 @@
 def update_ui():
     global last_ui_time
     ki = tb_disp.curr_param_pair  # shorthand
-    if time.monotonic() - last_ui_time > 0.05:
+    #if time.monotonic() - last_ui_time > 0.05:  # every 50 millis
+    if time.monotonic() - last_ui_time > 0.01:  # every 10 millis
         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)
+        #print(knobvals, time.monotonic())
         param_set.update_knobs(knobvals)
 
         # set synth with params
@@ -118,6 +127,11 @@ def update_ui():
         if key.pressed:
             if sequencer.playing:
                 sequencer.stop()
+                # testing out save/load params
+                s = ParamSet.dump(param_set)
+                print(s)
+                ParamSet.load(s)
+                
             else:
                 sequencer.start()
 

circuitpython/tbish/param_set.py

@@ -16,6 +16,8 @@
 
 """
 
+import json
+
 KNOB_MODE_PICKUP = 0
 KNOB_MODE_SCALE = 1
 KNOB_MODE_RELATIVE = 2
@@ -26,17 +28,19 @@ class Param:
     (optionally) an object attribute that they represent.
     """
 
-    def __init__(self, name, val, min_val, max_val, fmt, objattr=None):
+    def __init__(self, name, val, vmin, vmax, fmt, objattr=None):
         self.name = name
         self.val = val
-        self.vmin = min_val
-        self.vmax = max_val
+        self.vmin = vmin
+        self.vmax = vmax
         self.fmt = fmt
         self.objattr = objattr
 
     def __str__(self):
+        obstr = 'None' if self.objattr is None else "'%s'" % self.objattr
         return("Param('" + self.name + "'," + str(self.val) + "," +
-               str(self.vmin) + "," + str(self.vmax) + ",'" + str(self.fmt) + "')")
+               str(self.vmin) + "," + str(self.vmax) + ",'" + str(self.fmt) +
+               "'," + obstr + ")")
 
     def __repr__(self):
         return self.__str__()
@@ -101,7 +105,7 @@ def update_knobs(self, new_knob_vals):
                 delta = param.val - new_val
                 if abs(delta) < self.min_change * param.span:
                     self.is_tracking[i] = True
-                    param.val = new_val
+                    #param.val = new_val
 
     def apply_params(self, obj):
         """ Apply all params to given object """
@@ -117,12 +121,25 @@ def param_for_name(self, name):
         for p in filter(lambda p: p.name == name, self.params):
             return p
         return None
-        
+
     def __str__(self):
         return("ParamSet(nknobs="+str(self.nknobs) + ", " +
                "nknobsets="+str(self.nknobsets) +
                ", params="+str(self.params)+")")
 
+    @staticmethod
+    def load(dumpstr):
+        dumpobj = json.loads(dumpstr)
+        newparams = [Param(**d) for d in dumpobj['params']]
+        return newparams
+    
+    @staticmethod
+    def dump(paramset):
+        dumpobj = {
+            'params': [p.__dict__ for p in paramset.params]
+            }
+        return json.dumps(dumpobj)
+        
 # simple test
 
 if __name__ == "__main__":

circuitpython/tbish/tbish_sequencer.py

@@ -86,11 +86,13 @@ def add_audioeffects(self):
 
         # No distortion on rp2040 (not enough CPU)
         self.fx_distortion = Distortion(**fxcfg, mix = 0.0,
-                                        # other distortion modes are too slow? 
                                         mode = audiofilters.DistortionMode.LOFI,
+                                        # other distortion modes are too slow? 
+                                        #mode = audiofilters.DistortionMode.OVERDRIVE,
                                         soft_clip = True,
                                         pre_gain = 30,
                                         post_gain = -10)
+        
         # but yes filter on rp2040 with custom compile
         self.fx_filter1 = Filter(**fxcfg, mix=1.0)
         self.fx_filter2 = Filter(**fxcfg, mix=1.0)
@@ -117,43 +119,48 @@ def add_audioeffects(self):
         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)
-        pass
-    
-    def note_on(self, midi_note, vel=127):
-        """
-        Trigger a note. 'vel' has special meaning.
-        vel = 1 : slide, not new not
-        vel = 127 : accent
-        """
-        self.note_off(midi_note)  # just in case
-
-        #frate = 1 / self.secs_per_step
+        print("note_on_step: %3d %1d %1d" % (midi_note, slide, 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
+        if slide:
+            glide_time = 0.1
+            # FIXME also do appropriate other actions for slide
         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
-        
         self.filt_env.offset = ((1-envmod) * cutoff) 
         self.filt_env.scale = cutoff - self.filt_env.offset
         self.filt_env.rate = frate
         self.filt_env.retrigger()  # must retrigger once-shot LFOs
-        self.glider.glide_time = 0.1 if vel==1 else 0.001  # slide or minimal slide
+        self.glider.glide_time = glide_time
         self.glider.update(midi_note)  # glide up to new note
         ampenv = synthio.Envelope(attack_time=0.001,
-                                  attack_level = 0.8 if vel != 127 else 1.0,
+                                  attack_level = attack_level,
                                   decay_time = envdecay,
-                                  #decay_time = frate, 
                                   sustain_level=0,
-                                  release_time=0.01,) # self.envdecay)  
+                                  release_time=0.01) 
         self.note = synthio.Note(synthio.midi_to_hz(midi_note),
                                  bend = self.glider.lerp,
                                  filter = self.filter,
                                  envelope = ampenv,
                                  waveform = waves[self.wavenum])
         self.synth.press(self.note)
+        
+
+    def note_on(self, midi_note, vel=100):
+        """For MIDI use"""
+        self.note_on_step(midi_note, slide=(vel==1), accent=(vel==127))
 
     def note_off(self, midi_note, vel=0):
+        """Used for both MIDI and sequencer mode"""
         if self.note:
             self.synth.release(self.note)
             self.note = None
@@ -174,6 +181,17 @@ def accent(self):
     def accent(self, v):
         self.accent = v
 
+    @property
+    def resonance(self):
+        return self.filter.Q
+    
+    @resonance.setter
+    def resonance(self,q):
+        self.filter.Q = q
+        if self.fx_filter1:
+            self.fx_filter1.filter.Q = q
+            self.fx_filter2.filter.Q = q
+
     @property
     def drive(self):
         return self.fx_distortion.pre_gain
@@ -184,20 +202,17 @@ def drive(self,d):
         self.fx_distortion.pre_gain = d
 
     @property
-    def drive_mix(self):
-        return self.fx_distortion.mix
+    def delay_mix(self):
+        return self.fx_delay.mix
 
-    @drive_mix.setter
-    def drive_mix(self, m):
-        self.fx_distortion.mix = m
+    @delay_mix.setter
+    def delay_mix(self, m):
+        self.fx_delay.mix = m
 
     @property
-    def resonance(self):
-        return self.filter.Q
+    def delay_time(self):
+        return self.fx_delay.delay_ms / (self.secs_per_step * 100 * 2)
 
-    @resonance.setter
-    def resonance(self,q):
-        self.filter.Q = q
-        if self.fx_filter1:
-            self.fx_filter1.filter.Q = q
-            self.fx_filter2.filter.Q = q
+    @delay_time.setter
+    def delay_time(self, m):
+        self.fx_delay.delay_ms = self.secs_per_step * 1000 * 2 * m