From cb0bd4589c1350844924f8b909ae2f33d1cb40fd Mon Sep 17 00:00:00 2001 From: duffyduck Date: Tue, 30 Dec 2025 19:28:25 +0100 Subject: [PATCH] new main loop --- python_bridge/chat_audio_bridge.py | 121 ++++++++++++++--------------- 1 file changed, 60 insertions(+), 61 deletions(-) diff --git a/python_bridge/chat_audio_bridge.py b/python_bridge/chat_audio_bridge.py index a34235a..b876d57 100755 --- a/python_bridge/chat_audio_bridge.py +++ b/python_bridge/chat_audio_bridge.py @@ -689,77 +689,76 @@ Erst wenn ich [READY] sehe, starten die TICKs mit Bildern!""" break # ════════════════════════════════════════════════════════════════ - # STEFAN-ZEIT: Nach Claudes Antwort warten ob Stefan was sagen will. - # Sammle ALLE Eingaben bis Stefan wirklich fertig ist. + # STEFAN-ZEIT: Einfache, robuste Schleife # - # WICHTIG: Wir prüfen BEIDES: - # 1. _recording Flag (gesetzt wenn STT Sprache erkennt) - # 2. Ob gerade kein Mute aktiv ist (damit wir überhaupt hören können) + # Logik: + # - Warte bis zu 5s auf Stefan (wenn er nicht spricht) + # - SOBALD er spricht: warte bis er FERTIG ist (Recording=False) + # - Nach Recording-Ende: warte 3s ob er weiter spricht + # - Wenn 3s Stille: Buffer holen und weiter # - # Die Schleife läuft solange bis ENTWEDER: - # - Stefan fertig gesprochen hat (Buffer gefüllt, kein Recording mehr) - # - ODER der Timeout abläuft UND kein Recording aktiv ist + # Eine einzige while-Schleife mit klaren Zuständen! # ════════════════════════════════════════════════════════════════ - logger.debug("Warte auf Stefan...") - stefan_wait_start = time.time() - stefan_initial_timeout = 5.0 # Sekunden um mit Sprechen zu beginnen - stefan_has_spoken = False + logger.debug("Stefan-Zeit startet...") + + stefan_timeout = 5.0 # Max warten wenn Stefan NICHT spricht + nachdenk_pause = 3.0 # Warten nach Recording ob er weiter spricht + stefan_start = time.time() + last_recording_end = 0 # Wann endete das letzte Recording? + stefan_hat_gesprochen = False while self.running: - # Timeout nur anwenden wenn Stefan NICHT gerade spricht - if not self._recording.is_set(): - if (time.time() - stefan_wait_start) >= stefan_initial_timeout: - logger.debug("Stefan-Timeout, kein Recording aktiv") + ist_recording = self._recording.is_set() + jetzt = time.time() + + # ─── FALL 1: Stefan spricht gerade ─── + if ist_recording: + if not stefan_hat_gesprochen: + logger.debug("Stefan spricht!") + stefan_hat_gesprochen = True + last_recording_end = 0 # Reset! Er spricht (wieder) + time.sleep(0.05) + continue + + # ─── FALL 2: Stefan spricht NICHT ─── + + # Hat Stefan gerade aufgehört zu sprechen? + if stefan_hat_gesprochen and last_recording_end == 0: + last_recording_end = jetzt + logger.debug(f"Recording-Pause, warte {nachdenk_pause}s...") + + # War Stefan am Sprechen? → Warte auf Nachdenk-Pause + if stefan_hat_gesprochen: + zeit_seit_ende = jetzt - last_recording_end + + if zeit_seit_ende >= nachdenk_pause: + # 3s Stille nach dem Sprechen → Stefan ist fertig + logger.debug("Stefan ist fertig (3s Stille)") break - # Wenn Stefan anfängt zu sprechen, sammle ALLES was er sagt - if self._recording.is_set(): - if not stefan_has_spoken: - logger.debug("Stefan spricht, sammle alle Eingaben...") - stefan_has_spoken = True + # Noch in der Nachdenk-Pause, weiter warten + time.sleep(0.05) + continue - # Sammle alle Eingaben bis Stefan WIRKLICH fertig ist - # Das heißt: Recording endet UND danach kommt 3s lang nichts mehr - while self.running: - # Warte bis aktuelles Recording endet - while self.running and self._recording.is_set(): - time.sleep(0.1) # Schnellere Prüfung + # ─── FALL 3: Stefan hat noch GAR NICHT gesprochen ─── + zeit_gewartet = jetzt - stefan_start - # Recording ist beendet - aber spricht Stefan gleich weiter? - # Warte kurz und prüfe ob neues Recording startet - nachdenk_pause = 3.0 # Sekunden warten ob Stefan weiter spricht - pause_start = time.time() - weiter_gesprochen = False - - logger.debug(f"Recording-Pause, warte {nachdenk_pause}s ob Stefan weiter spricht...") - - while self.running and (time.time() - pause_start) < nachdenk_pause: - if self._recording.is_set(): - logger.debug("Stefan spricht weiter!") - weiter_gesprochen = True - break - time.sleep(0.1) # Schnellere Prüfung - - if not weiter_gesprochen: - # Stefan hat nicht weiter gesprochen - jetzt ist er fertig - logger.debug("Stefan ist fertig (keine weitere Eingabe)") - break - - # Jetzt auf Buffer warten - buffer_wait_start = time.time() - buffer_timeout = 10.0 # Sicherheits-Timeout - logger.debug("Warte auf Stefan-Buffer...") - - while self.running and (time.time() - buffer_wait_start) < buffer_timeout: - with self._stefan_buffer_lock: - if self._stefan_buffer: - logger.debug(f"Stefan-Buffer gefüllt: {len(self._stefan_buffer)} Einträge") - break - time.sleep(0.1) # Schnellere Prüfung - - logger.debug("STT-Verarbeitung abgeschlossen") + if zeit_gewartet >= stefan_timeout: + # 5s gewartet, Stefan schweigt → weiter mit TICK + logger.debug("Stefan-Timeout (5s ohne Sprache)") break - time.sleep(0.1) # Schnellere Prüfung für bessere Reaktion + + time.sleep(0.05) + + # Buffer holen (falls Stefan was gesagt hat) + if stefan_hat_gesprochen: + # Kurz warten bis STT den Buffer gefüllt hat + buffer_start = time.time() + while self.running and (time.time() - buffer_start) < 2.0: + with self._stefan_buffer_lock: + if self._stefan_buffer: + break + time.sleep(0.05) if not self.running: break