circuitpython-synthtools 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

{circuitpython_synthtools-0.8.0.dist-info → circuitpython_synthtools-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-synthtools
-Version: 0.8.0
+Version: 0.9.0
 Summary: CircuitPython helper library to do help doing synthio
 Author-email: Tod Kurt <tod@todbot.com>
 License: MIT
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: Adafruit-Blinka
+Requires-Dist: adafruit-circuitpython-ticks
 Provides-Extra: optional
 Dynamic: license-file
 
@@ -60,6 +61,8 @@ Dependencies
 This driver depends on:
 
 * `Adafruit CircuitPython <https://github.com/adafruit/circuitpython>`_
+* `Adafruit CircuitPython Ticks <https://github.com/adafruit/Adafruit_CircuitPython_Ticks>`_
+  (``StepSequencer``)
 
 Please ensure all dependencies are available on the CircuitPython filesystem.
 This is easily achieved by downloading

{circuitpython_synthtools-0.8.0.dist-info → circuitpython_synthtools-0.9.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-circuitpython_synthtools-0.8.0.dist-info/licenses/LICENSE,sha256=jhhRyxpqyQxyF_D6SzY2-jCA5v8Z8JXfezCtxBS85CM,1075
-synthtools/__init__.py,sha256=dB2eJTgbLs_sfEMCFcm8F_FNoblgNcZd6toMpHFQThw,2752
+circuitpython_synthtools-0.9.0.dist-info/licenses/LICENSE,sha256=jhhRyxpqyQxyF_D6SzY2-jCA5v8Z8JXfezCtxBS85CM,1075
+synthtools/__init__.py,sha256=gJ90pjs_sYcEZsznlkNIZkOc8CBf983wybRAl7iL-R0,2752
 synthtools/ahr_envelope.py,sha256=fWhjp7LahNGjL8qtTgyiAnX5hnviAULuyc9dEJ6t74I,9233
-synthtools/arpeggiator.py,sha256=n2sPnpZcu9soXsFJCh6OP65_0DuPnvQGUP0ao7V8SXM,3901
+synthtools/arpeggiator.py,sha256=s9tV68pw_GhKlxuNKrN0f8l7V2azhp5SyO-4lOPijQA,4185
 synthtools/audio_fx.py,sha256=PjnETf5kKIlG_tLKwM49PCvSkM2txfZf2o7MuEnU2W4,8778
-synthtools/bassline_synth.py,sha256=X8efKBgemBP2qAX0hL3PgWk3c_jkBWo0aX4KrgccHKE,51547
+synthtools/bassline_synth.py,sha256=1QM7r2l29Nscbgn_sxmD_f-XhZt80xaOFsevOM0dpbQ,51553
 synthtools/blocks.py,sha256=EsGcDEzIJX_dvBN8CVlDrewtl16x5leU03tum9jrhr0,1995
 synthtools/fm_synth.py,sha256=-r4NcsESjEechkbmV0tZx4pXayHIz4qUfIznKtQoKgQ,6073
 synthtools/gauge_cluster.py,sha256=lcMkRK-db6KV6pu0PUJRWAOJT8IdjgpE_4bAi0lQwxc,2910
@@ -12,16 +12,16 @@ synthtools/param_scaler.py,sha256=dmaFkzRhrfZn54DAgPwZs7P4B4BFd90ZUvMHpWIf2i4,62
 synthtools/paramset.py,sha256=--V89zHR4pUhkSey1CX7iMLNsF5l1hKmKWrAr3j_cRA,9938
 synthtools/patch.py,sha256=vMr-kdVD66uxY8BrrnB0J6uDLREjuu16I8HzfhAkqHs,6033
 synthtools/pitch_glider.py,sha256=R5h0Lbyq_slo7SKORRM7a0oumVugE15L8hOZJCov0AY,1927
-synthtools/step_sequencer.py,sha256=SkQuDsRtpAdKOXU3OsFmngeDPVQ0OXt3Gj5wqFCkEPM,4202
+synthtools/step_sequencer.py,sha256=lCFsFmysXOAo_aXFLiBHqK4pStW2Fr5QmnxQ-uA_Kzw,4831
 synthtools/subtractive_synth.py,sha256=WIpmhbiiLtyQRFV9mHWWM-duST5RfY9HUN4SRf5wTOw,3382
 synthtools/swarm_synth.py,sha256=kCYsdVuaafTKkD06_m22iFaPUMCzeBKX67mkrsEq3pk,10945
 synthtools/synth.py,sha256=ZdmAKWBVzJqPyzU5W1hxnJ6j09D4rnCWm77s5jRW_Ww,36528
-synthtools/trig_sequencer.py,sha256=J3_PdbNmYEoFkz7Hj58qNzMRZQuUm-sf2dKZIrBTV8U,3052
+synthtools/trig_sequencer.py,sha256=kqMFgr7q_lNn0KV-tt-52SEP4oz2PpS7kSq18svvFlM,3300
 synthtools/utils.py,sha256=deKQbkGXIBdGUOXBOpRCc-UHdPiL8YmybIJ3BBo9aA4,648
 synthtools/waves.py,sha256=lwDka71TsoHGJcyVfmG4t-TEf6TjBwftJEXSS4Qxyx0,22407
 synthtools/wavetable.py,sha256=7zQdAvHyiSp7wiVjl-lIfeifpbdsp7M5cCVbMT7eku0,3725
 synthtools/wavetable_synth.py,sha256=nggGXEr3tlADvTI38gCDRSw8XEaB5kHkzvQGSFfw16E,7969
-circuitpython_synthtools-0.8.0.dist-info/METADATA,sha256=K6l8EWT1soJUgzphRNq1V1Qhi3mdcCYXt0VAHjE5MFw,7139
-circuitpython_synthtools-0.8.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-circuitpython_synthtools-0.8.0.dist-info/top_level.txt,sha256=1xt53cH064i7vvFVDFyuJugc1NogReXvzsXbYGlgnKE,11
-circuitpython_synthtools-0.8.0.dist-info/RECORD,,
+circuitpython_synthtools-0.9.0.dist-info/METADATA,sha256=mhnlzRg78n-2sNVNECEcjAdwgrIKAlMco4fNI-PnNcM,7298
+circuitpython_synthtools-0.9.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+circuitpython_synthtools-0.9.0.dist-info/top_level.txt,sha256=1xt53cH064i7vvFVDFyuJugc1NogReXvzsXbYGlgnKE,11
+circuitpython_synthtools-0.9.0.dist-info/RECORD,,

{circuitpython_synthtools-0.8.0.dist-info → circuitpython_synthtools-0.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

synthtools/__init__.py

@@ -36,7 +36,7 @@ Anything not listed below is still importable by its module path::
 
 import sys
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"
 __repo__ = "https://github.com/todbot/CircuitPython_SynthTools.git"
 
 #: Public name -> the submodule that defines it. Every entry is loaded on

synthtools/arpeggiator.py

@@ -11,16 +11,7 @@ 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
-
+from adafruit_ticks import ticks_add, ticks_diff, ticks_ms
 
 patterns = (
     (0, 4, 7, 12),
@@ -68,6 +59,7 @@ class Arpeggiator:
         self.held_note = None
         self.next_millis = 0
         self.held_millis = 0
+        self._frac_millis = 0.0  # step_millis's fraction, carried between steps
 
     def set_bpm(self, bpm, rate=None):
         """Set BPM and optionally rate"""
@@ -90,6 +82,7 @@ class Arpeggiator:
     def start(self):
         """Start the arpeggiator running"""
         self.next_millis = ticks_ms()
+        self._frac_millis = 0.0
         self.on = True
 
     def stop(self):
@@ -105,12 +98,12 @@ class Arpeggiator:
         now = ticks_ms()
 
         # trigger note-off after gate time
-        if self.held_note and now - self.held_millis > 0:
+        if self.held_note and ticks_diff(now, self.held_millis) > 0:
             self.off_func(self.held_note)
             self.held_note = None
 
         # trigger note-on on if time to do so
-        delta_millis = now - self.next_millis
+        delta_millis = ticks_diff(now, self.next_millis)
         if delta_millis >= 0 and len(self.notes) > 0:  # time for new note
             note = self.notes[self.i] + self.oct_distance * self.octave
             # print("\t\t\t\t\t", "delta:",delta_millis)
@@ -120,8 +113,13 @@ class Arpeggiator:
             self.held_note = note  # save for note-off
 
             # set up when note off and next note happens
-            self.held_millis = now + (self.step_millis * self.gate)
-            self.next_millis = now + self.step_millis - delta_millis // 2
+            # int ticks: they wrap at 2**29, first ~65 s after power-on, and a
+            # 30-bit float can't hold one that big to the ms
+            self._frac_millis += self.step_millis
+            step = int(self._frac_millis)
+            self._frac_millis -= step
+            self.held_millis = ticks_add(now, int(self.step_millis * self.gate))
+            self.next_millis = ticks_add(now, step - delta_millis // 2)
 
             # go to next note
             self.i = (self.i + 1) % len(self.notes)

synthtools/bassline_synth.py

@@ -306,8 +306,8 @@ class BasslineSynth(Synth):
         self._accent_sweep_decay = getattr(p, "accent_sweep_decay", 0.55)
         self._accent_sweep_max = getattr(p, "accent_sweep_max", 1.6)
         self._slide_time = getattr(p, "slide_time", 0.06)
-        self._decay = p.fenv_attack  # super() already wrote it into the block
-        self._fall = p.fenv_attack  # ...and that is what the block holds
+        self._decay = getattr(p, "decay", p.fenv_attack)
+        self._fall = p.fenv_attack  # what super() wrote into the block
         get_wave(self._wave_name)  # warm the cache; note-on only reads it
         self._accent_on = False
         self._accent_sweep = 0.0
@@ -368,6 +368,7 @@ class BasslineSynth(Synth):
         peak, rest = self._env_endpoints()  # un-accented: no sweep widening
         p.fenv_amount = rest - peak
         p.fenv_attack = self._decay
+        p.decay = self._decay
         p.fx_filter_stages = self._fx_filter_stages
         p.fx_filter_mix = self._fx_filter_mix
         p.fx_hpf_f = self._fx_hpf_f

synthtools/step_sequencer.py

@@ -11,15 +11,7 @@ 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
+from adafruit_ticks import ticks_add, ticks_diff, ticks_ms
 
 
 class StepSequencer:
@@ -46,8 +38,10 @@ class StepSequencer:
         self.held_note = None  # the current note playing
         self.transpose = 0
         self.playing = False  # is sequence running or not (but use .start()/.stop())
+        self.external_clock = False  # owner calls trigger(), update() only releases gates
+        self.catch_up_steps = 0  # how far behind to still play every step, late, not resync
         self.next_millis = 0
-        self.error_millis = 0
+        self._frac_millis = 0.0  # step_millis's fraction, carried between steps
 
     @property
     def bpm(self):
@@ -68,46 +62,61 @@ class StepSequencer:
     def start(self):
         """Start sequencer going"""
         self.next_millis = ticks_ms()
+        self._frac_millis = 0.0
         self.playing = True
-        self.error_millis = 0
 
-    def stop(self):
-        """Stop sequencer, turning off any currently-sounding note"""
+    def pause(self):
+        """Pause sequencer where it is, turning off any currently-sounding note"""
         if self.held_note:
             self.off_func(*self.held_note)
+            self.held_note = None
         self.playing = False
+
+    def stop(self):
+        """Stop sequencer and rewind, turning off any currently-sounding note"""
+        self.pause()
         self.i = 0
 
+    def trigger(self, now=None):
+        """Play the current step and advance, for an owner keeping its own clock"""
+        if now is None:
+            now = ticks_ms()
+        if self.i >= self.step_count:  # step_count shrank under us
+            self.i = 0
+        (note, vel, gate, on) = self.steps[self.i]  # get new note to play
+        note += self.transpose  # adjust for transpose
+        self.held_note = (note, vel, gate, on)  # save it for when we note_off it
+
+        # trigger new note
+        self.on_func(*self.held_note)  # held_note = (note,vel,gate,on)
+
+        # prep for next step in sequence
+        self.i = (self.i + 1) % self.step_count
+
+        # int ticks: they wrap at 2**29, first ~65 s after power-on, and a
+        # 30-bit float can't hold one that big to the ms
+        self._frac_millis += self.step_millis
+        step = int(self._frac_millis)
+        self._frac_millis -= step
+        self.next_millis = ticks_add(self.next_millis, step)
+        # a stall put us too far behind
+        if ticks_diff(self.next_millis, now) < -self.catch_up_steps * step:
+            self.next_millis = ticks_add(now, step)
+        # next note off is some percentage smaller
+        gate = int(self.step_millis * self.held_note[2])
+        self.gate_off_millis = ticks_add(now, gate)
+
     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
 
         # trigger note-off after gate time
-        if now - self.gate_off_millis >= 0 and self.held_note:
+        if self.held_note and ticks_diff(now, self.gate_off_millis) >= 0:
             self.off_func(*self.held_note)
             self.held_note = None
 
-        if delta_millis >= 0:  # if zero or great, time for next step
-            # print("                      delta_millis:", delta_millis, self.error_millis)
-            self.error_millis += delta_millis
-            (note, vel, gate, on) = self.steps[self.i]  # get new note to play
-            note += self.transpose  # adjust for transpose
-            self.held_note = (note, vel, gate, on)  # save it for when we note_off it
-
-            # trigger new note
-            self.on_func(*self.held_note)  # held_note = (note,vel,gate,on)
-
-            # prep for next step in sequence
-            self.i = (self.i + 1) % self.step_count
-
-            # set up when next note on is, with some error correction
-            self.next_millis = now + self.step_millis
-            if self.error_millis > 1:
-                self.next_millis -= self.error_millis
-                self.error_millis = 0
-            # next note off is some percentage smaller
-            self.gate_off_millis = now + self.step_millis * self.held_note[2]
+        if not self.external_clock and ticks_diff(now, self.next_millis) >= 0:
+            self.trigger(now)

synthtools/trig_sequencer.py

@@ -11,15 +11,7 @@ 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
+from adafruit_ticks import ticks_add, ticks_diff, ticks_ms
 
 
 class TrigSequencer:
@@ -45,6 +37,7 @@ class TrigSequencer:
         self.drum_map = [0] * trig_count
         self.step_millis = 0  # real value once bpm is set; update()/start() need it to exist
         self.next_millis = 0
+        self._frac_millis = 0.0  # step_millis's fraction, carried between steps
 
     @property
     def bpm(self):
@@ -58,6 +51,7 @@ class TrigSequencer:
     def start(self):
         """Start sequencer going"""
         self.next_millis = ticks_ms()
+        self._frac_millis = 0.0
         self.playing = True
 
     def stop(self):
@@ -78,15 +72,19 @@ class TrigSequencer:
             return
 
         now = ticks_ms()
-        delta_millis = now - self.next_millis
 
-        if delta_millis >= 0:  # time to play
+        if ticks_diff(now, self.next_millis) >= 0:  # time to play
             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 += self.step_millis
-            if self.next_millis < now:  # a stall put us a whole step behind: resync
-                self.next_millis = now + self.step_millis
+            # int ticks: they wrap at 2**29, first ~65 s after power-on, and a
+            # 30-bit float can't hold one that big to the ms
+            self._frac_millis += self.step_millis
+            step = int(self._frac_millis)
+            self._frac_millis -= step
+            self.next_millis = ticks_add(self.next_millis, step)
+            if ticks_diff(self.next_millis, now) < 0:  # a stall put us a whole step behind
+                self.next_millis = ticks_add(now, step)