Non-blocking buzzer inter-note gap handling

Implement proper inter-note silence and robust non-blocking playback for the Buzzer.

- Add _in_gap and _gap_end_time state to track short gaps between notes instead of sleeping inside the timer callback; refactor _update to advance songs after the gap expires and stop the timer when the song finishes.
- Fix note parsing by initializing octave_pos and handling modifier positions to avoid undefined behavior.
- When starting single non-blocking notes, clear any active song state and reset gap flags; when starting a non-blocking song, stop any existing timer/playback before beginning.
- Ensure _in_gap is cleared on reset.
- Update resetbot to call Buzzer.get_default_buzzer().reset_buzzer() (use instance) instead of calling a class method.

These changes remove blocking sleeps from timer callbacks, prevent race conditions between single-note and song playback, and make non-blocking behavior deterministic.

Author: SaintSampo

XRPLib/buzzer.py

@@ -68,6 +68,8 @@ def __init__(self, buzzer_pin: int|str = None):
         # State variables for non-blocking playback
         self._note_end_time = 0
         self._tempo = 120  # Default BPM
+        self._in_gap = False
+        self._gap_end_time = 0
 
         # Song playback state
         self._song = []
@@ -131,15 +133,14 @@ def _parse_note(self, note_str: str):
         if note_letter in "ABCDEFG":
             # Check for sharp (#) or flat (b) modifier
             note_with_modifier = note_letter
+            octave_pos = 1
             if len(note_str) > 1:
                 if note_str[1] == "#":
                     note_with_modifier = note_letter + "#"
                     octave_pos = 2
                 elif note_str[1] == "B":
                     note_with_modifier = note_letter + "B"
                     octave_pos = 2
-                else:
-                    octave_pos = 1
 
             try:
                 if octave_pos < len(note_str):
@@ -157,24 +158,25 @@ def _update(self, timer):
         Internal callback for non-blocking playback.
         Called by the timer when running in non-blocking mode.
         """
-            
-        # Check if current note is done
-        if time.ticks_diff(self._note_end_time, time.ticks_ms()) <= 0:
-            # Note done - stop the tone
+        now = time.ticks_ms()
+
+        if self._in_gap:
+            # Waiting for the inter-note silence to pass before advancing
+            if time.ticks_diff(self._gap_end_time, now) <= 0:
+                self._in_gap = False
+                self._song_index += 1
+                if self._song_index < len(self._song):
+                    note, duration = self._song[self._song_index]
+                    self._start_note(note, duration, self._song_tempo)
+                else:
+                    # Song finished
+                    self._timer.deinit()
+                    self._timer_in_use = False
+        elif time.ticks_diff(self._note_end_time, now) <= 0:
+            # Note done - silence and schedule a short gap before next note
             self._pwm.duty_u16(0)
-            
-            # Small gap between notes
-            time.sleep_ms(20)
-            
-            # Play next note in song
-            self._song_index += 1
-            if self._song_index < len(self._song):
-                note, duration = self._song[self._song_index]
-                self._start_note(note, duration, self._song_tempo)
-            else:
-                # Song finished
-                self._timer.deinit()
-                self._timer_in_use = False
+            self._in_gap = True
+            self._gap_end_time = time.ticks_add(now, 20)
 
     def _start_note(self, note: str, duration: str = "quarter", tempo: int = None):
         """Start playing a note (non-blocking helper)."""
@@ -238,14 +240,17 @@ def play_note(self, note: str, duration: str = "quarter", blocking: bool = True,
         if blocking:
             self._play_tone_blocking(frequency, duration_ms)
         else:
-            # Non-blocking - start the note and set up timer if needed
+            # Non-blocking - clear any active song so _update won't advance it
+            self._song = []
+            self._song_index = 0
+            self._in_gap = False
+
             if frequency > 0:
                 self._pwm.freq(frequency)
                 self._pwm.duty_u16(32768)
-            
+
             self._note_end_time = time.ticks_add(time.ticks_ms(), duration_ms)
-            
-            # Start timer if not already running
+
             if not self._timer_in_use:
                 self._timer.init(freq=100, callback=lambda t: self._update(t))
                 self._timer_in_use = True
@@ -291,17 +296,21 @@ def play_song(self, song: list, tempo: int = None, blocking: bool = True):
                 duration_ms = self._duration_to_ms(duration, tempo)
                 self._play_tone_blocking(frequency, duration_ms)
         else:
-            # Non-blocking - store song and start playing with timer
+            # Non-blocking - stop any existing playback before starting new song
+            if self._timer_in_use:
+                self._timer.deinit()
+                self._timer_in_use = False
+            self._in_gap = False
+
             self._song = song
             self._song_index = 0
             self._song_tempo = tempo
-            self._timer_in_use = False
-            
+
             # Start playing first note
             note, duration = song[0]
             self._start_note(note, duration, tempo)
             self._song_index = 1
-            
+
             # Start the timer for non-blocking playback
             self._timer.init(freq=100, callback=lambda t: self._update(t))
             self._timer_in_use = True
@@ -322,6 +331,7 @@ def reset_buzzer(self):
         # Reset song state
         self._song = []
         self._song_index = 0
+        self._in_gap = False
 
     def play_move_it(self, blocking: bool = True):
         """

XRPLib/resetbot.py

@@ -33,7 +33,7 @@ def reset_buzzer():
     # Turn off the buzzer
     try:
         # Turn off the Buzzer if the board has one
-        Buzzer.reset_buzzer()
+        Buzzer.get_default_buzzer().reset_buzzer()
     except:
         pass