circuitpython-synthtools 0.5__py3-none-any.whl

synthtools/trig_sequencer.py

@@ -0,0 +1,91 @@
+## pylint: disable=invalid-name,too-many-arguments,multiple-statements
+# SPDX-FileCopyrightText: Copyright (c) 2023 Tod Kurt
+# SPDX-License-Identifier: MIT
+"""
+``trig_sequencer``
+================================================================================
+
+``TrigSequencer`` is a trigger-based (drum) sequencer for rhythmic events.
+
+Part of synthtools.
+
+"""
+
+import time
+
+try:
+    from supervisor import ticks_ms
+except ImportError:
+
+    def ticks_ms():
+        """stand-in for supervisor.ticks_ms"""
+        return time.monotonic_ns() // 1_000_000
+
+
+class TrigSequencer:
+    """
+    TrigSequencer contains a list of on/off event triggers in list of steps.
+
+    :param int trig_count: how many triggers to keep track of
+    :param int step_count: how many for all the triggers
+    :param int steps_per_beat: number of steps in a beat (1=quarter note, 2=8th note, 4=16th note)
+    :param function on_func: function to call on trigger start
+    :param function off_func: function to call on trigger end (unused)
+    """
+
+    def __init__(self, trig_count, step_count, steps_per_beat, on_func=None, off_func=None):
+        self.trig_count = trig_count
+        self.step_count = step_count
+        self.steps_per_beat = steps_per_beat
+        self.on_func = on_func
+        self.off_func = off_func
+        self.trigs = [[0 for t in range(step_count)] for i in range(trig_count)]
+        self.i = 0  # where in the step sequence we currently are
+        self.playing = False
+        self.drum_map = [0] * trig_count
+
+    @property
+    def bpm(self):
+        return 60_000 / self.step_millis / self.steps_per_beat
+
+    @bpm.setter
+    def bpm(self, bpm):
+        """Sets the internal tempo. step_millis is time between steps"""
+        self.step_millis = 60_000 / self.steps_per_beat / bpm
+
+    def start(self):
+        """Start sequencer going"""
+        self.next_millis = ticks_ms()
+        self.playing = True
+
+    def stop(self):
+        """Stop sequencer, turning off any currently-sounding note"""
+        self.off_func(*self.held_note)
+        self.playing = False
+        self.i = 0
+
+    def set_drum_map(self, drum_map):
+        self.drum_map = drum_map
+
+    def set_pattern(self, pattern):
+        for i in range(len(pattern)):
+            self.trigs[i] = pattern[i]
+
+    def update(self):
+        """Update the sequencer. Call as frequently as possible"""
+        if not self.playing:
+            return
+
+        now = ticks_ms()
+        delta_millis = now - self.next_millis
+
+        if delta_millis >= 0:  # time to play
+            # print("                      delta_millis:", delta_millis)
+
+            for t in range(self.trig_count):
+                if self.trigs[t][self.i] == 1:
+                    self.on_func(t, self.drum_map[t])
+
+            # prep for next step in sequence
+            self.i = (self.i + 1) % self.step_count
+            self.next_millis = now + self.step_millis - delta_millis

synthtools/ui/gauge_cluster.py

@@ -0,0 +1,79 @@
+##pylint: disable=invalid-name
+# SPDX-FileCopyrightText: Copyright (c) 2024 Tod Kurt
+# SPDX-License-Identifier: MIT
+"""
+`gauge_cluster`
+================================================================================
+
+A group of `displayio` objects that display a list of values graphically.
+
+Part of synthtools.
+
+"""
+
+import displayio
+from vectorio import Rectangle
+
+
+class GaugeCluster:  # (dispalyio.Group) ?
+    """
+    GaugeCluster is a group of `displayio` objects that display a list
+    of values graphically.
+    """
+
+    # pylint: disable=too-many-arguments,too-many-locals
+    def __init__(self, num_vals, x=2, y=4, width=5, height=40, xstride=3):
+        self.gauge_vals = [0] * num_vals  # 0-255 is val range
+        self.x = x
+        self.y = y
+        self.w = width
+        self.h = height
+        palW = displayio.Palette(1)
+        palW[0] = 0xFFFFFF
+        palB = displayio.Palette(1)
+        palB[0] = 0x000000
+        xspacing = width + 2  # 7
+        xstride = int(xspacing * xstride)  # 21 orig
+        gauges = displayio.Group()
+        select_lines = displayio.Group()
+        # fmt: off
+        for i in range(num_vals // 2):
+            rL = Rectangle(pixel_shader=palW, width=self.w, height=self.h,
+                           x=self.x + (i * xstride),
+                           y=self.y)
+            rLB = Rectangle(pixel_shader=palB, width=self.w-2, height=self.h,
+                            x=self.x+1+(i*xstride),
+                            y=self.y+1)
+            rR = Rectangle(pixel_shader=palW, width=self.w, height=self.h,
+                           x=self.x+xspacing+(i*xstride),
+                           y=self.y)
+            rRB = Rectangle(pixel_shader=palB,width=self.w-2, height=self.h,
+                            x=self.x + xspacing+1+(i*xstride),
+                            y=self.y + 1)
+            for r in (rL, rLB, rR, rRB):
+                gauges.append(r)
+
+            # add in the select lines, above the actual cluster
+            line = Rectangle(pixel_shader=palW, width=self.w*2+2, height=2,
+                             x=self.x+(i*xstride),
+                             y=self.y-3)
+            line.hidden = True
+            select_lines.append(line)
+        # fmt: on
+
+        self.gauges = gauges
+        self.select_lines = select_lines
+
+    def set_gauge_val(self, i, v):
+        """Set gauge `i` with value `v`. v ranges from 0-255"""
+        self.gauge_vals[i] = v  # 0-255
+        self.gauges[1 + (i * 2)].height = self.h - 2 - ((v * (self.h - 2)) // 255)
+
+    def get_gauge_val(self, i):
+        """Get gauge value of gauge `i`, return value ranges from 0-255"""
+        return self.gauge_vals[i]
+
+    def select_line(self, i, show=True):
+        """Show a bar above two of the gauges, indicating they are the pair
+        able to be edited  (this should maybe go in synthui)"""
+        self.select_lines[i].hidden = not show

synthtools/ui/param.py

@@ -0,0 +1,108 @@
+## pylint: disable=invalid-name,too-many-arguments,multiple-statements
+# SPDX-FileCopyrightText: Copyright (c) 2024 Tod Kurt
+# SPDX-License-Identifier: MIT
+"""
+`param`
+================================================================================
+
+A `Param` is a named represention of an on-screen configuration value.
+
+A `ParamRange` is a Param with a numeric range and setter function to update
+when the Param is changed.
+
+A `ParamChoice` is a Param with a list of options to choose from and
+a setter function to update when the Param is changed.
+
+Part of synthtools.
+
+"""
+
+
+class Param:  # pylint: disable=too-few-public-methods
+    """Param is a named representation of an on-screen config value"""
+
+    def __init__(self, name, fullname, val):
+        self.name = name
+        self.fullname = fullname
+        self.val = val
+
+
+class ParamRange:
+    """ParamRange is a Param with a numeric range and setter/getter functions
+    to update and set the represented value"""
+
+    def __init__(self, name, fullname, val, fmt, minval, maxval, setter=None, getter=None):
+        self.name = name
+        self.fullname = fullname
+        self.val = val
+        self.fmt = fmt
+        self.minval = minval
+        self.maxval = maxval
+        self.valrange = maxval - minval
+        self.setter = setter
+        self.getter = getter
+
+    def __repr__(self):
+        return "ParamRange('%s', %s, %s,%s)" % (
+            self.name,
+            self.fmt % self.val,
+            self.fmt % self.minval,
+            self.fmt % self.maxval,
+        )
+
+    def update(self):
+        """Update the param's value using the getter"""
+        if self.getter:
+            self.val = self.getter()
+
+    def get_text(self):
+        """Return a text version of the param's value, using its fmt"""
+        return self.fmt % self.val  # text representation
+
+    def set_by_gauge_val(self, gv):  # gv ranges 0-255
+        """Set the param's value (and the underlying value the param is
+        representing, using the 0-255 'gauge value' range"""
+        self.val = (gv * (self.valrange) / 255) + self.minval
+        if self.setter:
+            self.setter(self.val)
+
+    def get_by_gauge_val(self):
+        """Get the param's value in terms of the 0-255 'gauge value'"""
+        return (self.val - self.minval) / (self.valrange) * 255
+
+
+class ParamChoice:
+    """ParamChoice is a Param with a list of options and setter/getter functions
+    to update and set the represented value"""
+
+    def __init__(self, name, fullname, val, choices, setter=None, getter=None):
+        self.name = name
+        self.fullname = fullname
+        self.val = val
+        self.choices = choices
+        self.num_choices = len(choices)
+        self.setter = setter
+        self.getter = getter
+
+    def __repr__(self):
+        return "ParamChoice('%s', %s, %s)" % (self.name, self.val, self.choices)
+
+    def update(self):
+        """Update the param's value using the getter"""
+        if self.getter:
+            self.val = self.getter()
+
+    def get_text(self):
+        """Return a text version of the param's value, using its fmt"""
+        return self.choices[self.val]  # text representation
+
+    def set_by_gauge_val(self, gv):  # gv ranges 0-255
+        """Set the param's value (and the underlying value the param is
+        representing, using the 0-255 'gauge value' range"""
+        self.val = int(gv * (self.num_choices - 1) / 255)
+        if self.setter:
+            self.setter(self.val)
+
+    def get_by_gauge_val(self):
+        """Get the param's value in terms of the 0-255 'gauge value'"""
+        return int(self.val * 255 / (self.num_choices - 1))

synthtools/ui/param_scaler.py

@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 Tod Kurt
+# SPDX-License-Identifier: MIT
+"""
+`param_scaler`
+================================================================================
+
+`ParamScaler` attempts to solve the "knob pickup" problem when a control's
+position does not match the Param position.
+
+The scaler will increase/decrease its internal value relative to the change
+of the incoming knob position and the amount of "runway" remaining on the
+value. Once the knob reaches its max or min position, the value will
+move in sync with the knob.  The value will always decrease/increase
+in the same direction as the knob.
+This mirrors how the Deluge synth's "SCALE" mode works.
+
+Part of synthtools.
+
+"""
+
+from micropython import const
+
+knob_min, knob_max = const(0), const(255)
+val_min, val_max = const(0), const(255)
+
+
+class ParamScaler:
+    """
+    ParamScaler will scale its value based on input knob position, always
+    trying to 'do the right thing' no matter where the current value of
+    the knob is in relation to its own value
+    """
+
+    def __init__(self, val, knob_pos):
+        """val and knob_pos range from 0-255, floating point"""
+        self.val = val
+        self.knob_pos_last = knob_pos
+        self.knob_match = False
+
+    def reset(self, val=None, knob_pos=None):
+        """Reset the ParamScaler's value and knob_pos memory"""
+        if val is not None:
+            self.val = val
+        if knob_pos is not None:
+            self.knob_pos_last = knob_pos
+        self.knob_match = False
+
+    def update(self, knob_pos):
+        """Update the ParamScaler's internal value based on new knob_pos"""
+        # print("k:%3d lk:%3d m:%1d" % (knob_pos, self.knob_pos_last, self.knob_match))
+        if self.knob_match:
+            # print("!! ==")
+            self.val = knob_pos
+            self.knob_pos_last = knob_pos
+            return knob_pos
+
+        knob_delta = knob_pos - self.knob_pos_last
+        self.knob_pos_last = knob_pos
+
+        if abs(knob_pos - self.val) < 5:  # todfixme: make configurable
+            # print("!!!!")
+            self.knob_match = True
+            self.val = knob_pos
+            return knob_pos
+
+        val_max_pos_delta = val_max - self.val
+        val_min_pos_delta = self.val - val_min
+        knob_max_pos_delta = val_max - knob_pos
+        knob_min_pos_delta = knob_pos - val_min
+
+        if knob_delta > 0 and knob_max_pos_delta != 0:
+            # print("+ ", end='')
+            val_percent_change = knob_delta * val_max_pos_delta / knob_max_pos_delta
+        elif knob_delta < 0 and knob_min_pos_delta != 0:
+            # print("- ", end='')
+            val_percent_change = knob_delta * val_min_pos_delta / knob_min_pos_delta
+        else:
+            # print(". ", end='')
+            val_percent_change = 0
+
+        # print("val_percent_change: %2.2f" % val_percent_change)
+        self.val = min(max(self.val + val_percent_change, val_min), val_max)
+        return self.val

synthtools/utils.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 Tod Kurt
+# SPDX-License-Identifier: MIT
+
+from collections import deque
+
+
+class RollingAverage:
+    """A fixed-size moving average, for smoothing/deadbanding noisy knob
+    reads. update() pushes a new value onto a ``window_size``-deep deque and
+    returns the mean of whatever is currently in it -- so the window is
+    still filling for the first ``window_size`` calls."""
+
+    def __init__(self, window_size):
+        self.d = deque((), window_size)
+        self.window_size = window_size
+
+    def update(self, new_value):
+        self.d.append(new_value)
+        return sum(self.d) / self.window_size