Work ok effects

Author: rjtokenring

src/arduino/app_bricks/sound_generator/README.md

@@ -1,6 +1,6 @@
 # Sound Generator Brick
 
-Play sounds and melodies
+Play sounds and melodies 
 
 ## Code example and usage
 
@@ -35,7 +35,7 @@ waveform can be customized to change effect. For example, for a retro-gaming sou
 player = SoundGenerator(wave_form="square")
 ```
 
-instead, to have a more "rock" like sound, you can add effect
+instead, to have a more "rock" like sound, you can add effects like:
 
 ```python
 player = SoundGenerator(sound_effects=[SoundEffect.adsr(), SoundEffect.overdrive(drive=180.0), SoundEffect.chorus(depth_ms=15, rate_hz=0.2, mix=0.4)])

src/arduino/app_bricks/sound_generator/__init__.py

@@ -7,6 +7,7 @@
 import threading
 from typing import Iterable
 import numpy as np
+import time
 
 from .effects import *
 from .loaders import ABCNotationLoader
@@ -73,13 +74,14 @@ def __init__(
                 signal (e.g., [SoundEffect.adsr()]). See SoundEffect class for available effects.
         """
 
-        self._wave_gen = WaveGenerator(sample_rate=self.SAMPLE_RATE, wave_form=wave_form)
+        self._cfg_lock = threading.Lock()
+        self._init_wave_generator(wave_form)
+
         self._bpm = bpm
         self.time_signature = time_signature
         self._master_volume = master_volume
         self._sound_effects = sound_effects
 
-        self._cfg_lock = threading.Lock()
         self._notes = {}
         for octave in range(octaves):
             notes = self._fill_node_frequencies(octave)
@@ -91,6 +93,19 @@ def start(self):
     def stop(self):
         pass
 
+    def _init_wave_generator(self, wave_form: str):
+        with self._cfg_lock:
+            self._wave_gen = WaveGenerator(sample_rate=self.SAMPLE_RATE, wave_form=wave_form)
+
+    def set_wave_form(self, wave_form: str):
+        """
+        Set the wave form type for sound generation.
+        Args:
+            wave_form (str): The type of wave form to generate. Supported values
+                are "sine", "square", "triangle" and "sawtooth".
+        """
+        self._init_wave_generator(wave_form)
+
     def set_master_volume(self, volume: float):
         """
         Set the master volume level.
@@ -368,14 +383,14 @@ def play_tone(self, note: str, duration: float = 0.25, volume: float = None) ->
             data = self._apply_sound_effects(data, frequency)
             return self._to_bytes(data)
 
-    def play_abc(self, abc_string: str, volume: float = None) -> Iterable[bytes]:
+    def play_abc(self, abc_string: str, volume: float = None) -> Iterable[tuple[bytes, float]]:
         """
         Play a sequence of musical notes defined in ABC notation.
         Args:
             abc_string (str): ABC notation string defining the sequence of notes.
             volume (float, optional): Volume level (0.0 to 1.0). If None, uses master volume.
         Returns:
-            Iterable[bytes]: An iterable yielding the audio blocks of the played notes (float32).
+            Iterable[tuple[bytes, float]]: An iterable yielding the audio blocks of the played notes (float32) and its duration.
         """
         if not abc_string or abc_string.strip() == "":
             return
@@ -387,7 +402,7 @@ def play_abc(self, abc_string: str, volume: float = None) -> Iterable[bytes]:
             if frequency is not None and frequency >= 0.0:
                 data = self._wave_gen.generate_block(float(frequency), duration, volume)
                 data = self._apply_sound_effects(data, frequency)
-                yield self._to_bytes(data)
+                yield (self._to_bytes(data), duration)
 
 
 @brick
@@ -424,20 +439,26 @@ def __init__(
             sound_effects=sound_effects,
         )
 
+        self._started = threading.Event()
         if output_device is None:
-            self._self_created_device = True
+            self.external_speaker = False
             self._output_device = Speaker(sample_rate=self.SAMPLE_RATE, format="FLOAT_LE")
+            self.start()
         else:
-            self._self_created_device = False
+            self.external_speaker = True
             self._output_device = output_device
 
     def start(self):
-        if self._self_created_device:
+        if self._started.is_set():
+            return
+        if self.external_speaker == False:
             self._output_device.start(notify_if_started=False)
+        self._started.set()
 
     def stop(self):
-        if self._self_created_device:
+        if self.external_speaker == False:
             self._output_device.stop()
+        self._started.clear()
 
     def set_master_volume(self, volume: float):
         """
@@ -508,15 +529,20 @@ def play_tone(self, note: str, duration: float = 0.25, volume: float = None):
         data = super().play_tone(note, duration, volume)
         self._output_device.play(data, block_on_queue=False)
 
-    def play_abc(self, abc_string: str, volume: float = None):
+    def play_abc(self, abc_string: str, volume: float = None, wait_completion: bool = False):
         """
         Play a sequence of musical notes defined in ABC notation.
         Args:
             abc_string (str): ABC notation string defining the sequence of notes.
             volume (float, optional): Volume level (0.0 to 1.0). If None, uses master volume.
+            wait_completion (bool): If True, block until the entire sequence has been played.
         """
         if not abc_string or abc_string.strip() == "":
             return
         player = super().play_abc(abc_string, volume)
-        for data in player:
-            self._output_device.play(data, block_on_queue=False)
+        overall_duration = 0.0
+        for data, duration in player:
+            self._output_device.play(data, block_on_queue=True)
+            overall_duration += duration
+        if wait_completion:
+            time.sleep(overall_duration)

src/arduino/app_bricks/sound_generator/effects.py

@@ -7,7 +7,7 @@
 
 class SoundEffect:
     @staticmethod
-    def overdrive(drive: float = 1.0) -> np.ndarray:
+    def overdrive(drive: float = 100.0) -> np.ndarray:
         """
         Apply overdrive effect to the audio signal.
         Args:
@@ -29,12 +29,11 @@ def apply(self, signal: np.ndarray) -> np.ndarray:
         return SoundEffectOverdrive(drive)
 
     @staticmethod
-    def chorus(fs: int = 16000, depth_ms=10, rate_hz: float = 0.25, mix: float = 0.5) -> np.ndarray:
+    def chorus(depth_ms=10, rate_hz: float = 0.25, mix: float = 0.5) -> np.ndarray:
         """
         Apply chorus effect to the audio signal.
         Args:
             signal (np.ndarray): Input audio signal.
-            fs (int): Sampling frequency in Hz.
             depth_ms (float): Depth of the chorus effect in milliseconds.
             rate_hz (float): Rate of the LFO in Hz.
             mix (float): Mix ratio between dry and wet signals (0.0 to 1.0).
@@ -43,8 +42,8 @@ def chorus(fs: int = 16000, depth_ms=10, rate_hz: float = 0.25, mix: float = 0.5
         """
 
         class SoundEffectChorus:
-            def __init__(self, fs: int = 16000, depth_ms: int = 10, rate_hz: float = 0.25, mix: float = 0.5):
-                self.fs = fs
+            def __init__(self, depth_ms: int = 10, rate_hz: float = 0.25, mix: float = 0.5):
+                self.fs = 16000  # sample rate
                 self.depth_ms = depth_ms
                 self.rate_hz = rate_hz
                 self.mix = mix
@@ -67,14 +66,13 @@ def apply(self, signal: np.ndarray) -> np.ndarray:
                 # mix dry/wet
                 return ((1 - self.mix) * signal + self.mix * out).astype(np.float32)
 
-        return SoundEffectChorus(fs, depth_ms, rate_hz, mix)
+        return SoundEffectChorus(depth_ms, rate_hz, mix)
 
     @staticmethod
     def adsr(attack: float = 0.015, decay: float = 0.2, sustain: float = 0.5, release: float = 0.35):
         """
         Apply ADSR (attack/decay/sustain/release) envelope to the audio signal.
         Args:
-            fs (int): Sampling frequency in Hz.
             attack (float): Attack time in seconds.
             decay (float): Decay time in seconds.
             sustain (float): Sustain level (0.0 to 1.0).

src/arduino/app_bricks/sound_generator/examples/2_stream_sequence.py

@@ -0,0 +1,66 @@
+# SPDX-FileCopyrightText: Copyright (C) 2025 ARDUINO SA <http://www.arduino.cc>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# EXAMPLE_NAME: Stream a sequence of notes over websocket via WebUI
+import time
+from arduino.app_utils import *
+from arduino.app_bricks.web_ui import WebUI
+from arduino.app_bricks.sound_generator import SoundGeneratorStreamer, SoundEffect
+
+ui = WebUI()
+
+player = SoundGeneratorStreamer(master_volume=1.0, wave_form="square", bpm=120, sound_effects=[SoundEffect.adsr()])
+
+tune_sequence = [
+    ("E5", 0.125),
+    ("E5", 0.125),
+    ("REST", 0.125),
+    ("E5", 0.125),
+    ("REST", 0.125),
+    ("C5", 0.125),
+    ("E5", 0.125),
+    ("REST", 0.125),
+    ("G5", 0.25),
+    ("REST", 0.25),
+    ("G4", 0.25),
+    ("REST", 0.25),
+    ("C5", 0.25),
+    ("REST", 0.125),
+    ("G4", 0.25),
+    ("REST", 0.125),
+    ("E4", 0.25),
+    ("REST", 0.125),
+    ("A4", 0.25),
+    ("B4", 0.25),
+    ("Bb4", 0.125),
+    ("A4", 0.25),
+    ("G4", 0.125),
+    ("E5", 0.125),
+    ("G5", 0.125),
+    ("A5", 0.25),
+    ("F5", 0.125),
+    ("G5", 0.125),
+    ("REST", 0.125),
+    ("E5", 0.25),
+    ("C5", 0.125),
+    ("D5", 0.125),
+    ("B4", 0.25),
+]
+
+
+def user_lp():
+    while True:
+        overall_time = 0
+        for note, duration in tune_sequence:
+            frame = player.play_tone(note, duration)
+            entry = {
+                "raw_data": frame,
+            }
+            ui.send_message("audio_frame", entry)
+            overall_time += duration
+
+        time.sleep(overall_time)  # wait for the whole sequence to finish before restarting
+
+
+App.run(user_loop=user_lp)

src/arduino/app_bricks/sound_generator/examples/3_play_abc_notation.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: Copyright (C) 2025 ARDUINO SA <http://www.arduino.cc>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# EXAMPLE_NAME: Play music in ABC notation
+from arduino.app_bricks.sound_generator import SoundGenerator, SoundEffect
+from arduino.app_utils import App
+
+player = SoundGenerator(sound_effects=[SoundEffect.adsr()])
+
+
+def play_melody():
+    abc_music = """
+    X:1
+    T:Twinkle, Twinkle Little Star - #11
+    T:Alphabet Song
+    C:Traditional Kid's Song
+    M:4/4
+    L:1/4
+    K:D
+    |"D"D D A A|"G"B B "D"A2
+    |"G"G G "D"F F|"A"E/2E/2E/2E/2 "D"D2
+    |A A "G"G G|"D"F F "A"E2
+    |"D"A A "G"G G|"D"F F "A"E2
+    |"D"D D A A|"G"B B "D"A2
+    |"G"G G "D"F F|"A"E E "D"D2|
+    """
+    player.play_abc(abc_music, wait_completion=True)
+
+
+App.run(user_loop=play_melody)

src/arduino/app_bricks/sound_generator/examples/4_effects.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (C) 2025 ARDUINO SA <http://www.arduino.cc>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# EXAMPLE_NAME: Play a sequence using effects
+from arduino.app_bricks.sound_generator import SoundGenerator, SoundEffect
+from arduino.app_utils import App
+
+player = SoundGenerator()
+
+tune_sequence = [
+    ("A4", 0.25),
+    ("C5", 0.25),
+    ("E5", 0.25),
+    ("C5", 0.25),
+    ("A4", 0.25),
+    ("C5", 0.25),
+    ("E5", 0.25),
+    ("REST", 0.25),
+    ("G4", 0.25),
+    ("B4", 0.25),
+    ("D5", 0.25),
+    ("B4", 0.25),
+    ("G4", 0.25),
+    ("B4", 0.25),
+    ("D5", 0.25),
+    ("REST", 0.25),
+    ("A4", 0.25),
+    ("A4", 0.25),
+    ("C5", 0.25),
+    ("E5", 0.25),
+    ("F5", 0.5),
+    ("E5", 0.25),
+    ("REST", 0.25),
+    ("D5", 0.25),
+    ("C5", 0.25),
+    ("B4", 0.25),
+    ("A4", 0.25),
+    ("G4", 0.5),
+    ("B4", 0.5),
+    ("REST", 1),
+]
+
+# Play as a retro-game sound
+player.set_wave_form("square")
+player.set_effects([SoundEffect.adsr()]) # For a more synththetic sound, add SoundEffect.bitcrusher() effect
+for note, duration in tune_sequence:
+    player.play_tone(note, duration)
+
+# Play with distortion
+player.set_wave_form("sine")
+player.set_effects([SoundEffect.adsr(), SoundEffect.chorus(), SoundEffect.overdrive(drive=200.0)])
+for note, duration in tune_sequence:
+    player.play_tone(note, duration)
+
+# Vibrato effect
+player.set_effects([SoundEffect.adsr(), SoundEffect.vibrato()])
+for note, duration in tune_sequence:
+    player.play_tone(note, duration)
+
+# Tremolo effect
+player.set_wave_form("triangle")
+player.set_effects([SoundEffect.adsr(), SoundEffect.tremolo(), SoundEffect.chorus()])
+for note, duration in tune_sequence:
+    player.play_tone(note, duration)
+
+App.run()