fixes

.tf5_mixer_cache/channels_cache.json

@@ -45,8 +45,8 @@
     "7": {
       "channel": 7,
       "name": "Basso",
-      "on": false,
+      "on": true,
-      "level_db": null,
+      "level_db": -4.6,
       "pan": 0
     },
     "8": {
@@ -403,7 +403,7 @@
       "level_db": 6.0
     }
   },
-  "timestamp": 1776106373.6489363,
+  "timestamp": 1776706150.4343228,
   "steinch": {},
   "fxrtn": {
     "1": {

cache/mixer_ip.json

@@ -0,0 +1,4 @@
+{
+  "ip": "192.168.1.57",
+  "timestamp": 1781544233.9153695
+}

cache/tf5_cache.json

@@ -0,0 +1,49 @@
+{
+  "channels": {
+    "23": {
+      "channel": 23,
+      "level_db": 3.5
+    },
+    "24": {
+      "channel": 24,
+      "level_db": -4.1,
+      "on": false
+    },
+    "20": {
+      "channel": 20,
+      "level_db": -0.2,
+      "on": true
+    },
+    "5": {
+      "channel": 5,
+      "level_db": 2.7,
+      "on": true
+    },
+    "6": {
+      "channel": 6,
+      "level_db": -4.1,
+      "on": true
+    },
+    "2": {
+      "channel": 2,
+      "level_db": -2.55,
+      "on": true
+    }
+  },
+  "mixes": {},
+  "steinch": {},
+  "fxrtn": {},
+  "dcas": {},
+  "matrices": {},
+  "stereo": {
+    "1": {
+      "bus": 1,
+      "name": "Stereo",
+      "on": true,
+      "level_db": -11.9
+    }
+  },
+  "mono": {},
+  "mute_masters": {},
+  "timestamp": 1776707910.2890162
+}

config.py

@@ -7,31 +7,43 @@ import threading
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import time
 
-# Configurazione mixer
+# ==========================================
+# Specifiche Yamaha TF5 (FONDAMENTALI PER LA CACHE E IL CONTROLLER)
+# ==========================================
 DEFAULT_PORT = 49280
-TF5_INPUT_CHANNELS = 40
+TF5_INPUT_CHANNELS = 40        # CH 1-40
-TF5_MIX_BUSSES = 20
+TF5_ST_INPUT_CHANNELS = 2      # ST IN 1-2
-TF5_STEREO_BUSSES = 1
+TF5_FX_RETURN_CHANNELS = 4     # FX RTN 1-4
+TF5_DCA_GROUPS = 8             # DCA 1-8
+TF5_MIX_BUSSES = 20            # MIX 1-20
+TF5_MATRIX_BUSSES = 4          # MATRIX 1-4
+TF5_STEREO_BUSSES = 1          # 1 Bus Stereo (L/R)
+TF5_MUTE_GROUPS = 8            # Mute Master 1-8
+TF5_FX_SLOTS = 8               # Processori FX (8 slot interni)
 
-# Configurazione cache
+# ==========================================
-CACHE_DIR = Path(".tf5_mixer_cache")
+# Configurazione Cache (Mixer State & IP)
-CACHE_FILE = CACHE_DIR / "channels_cache.json"
+# ==========================================
+CACHE_DIR = Path(__file__).parent / "cache"
+CACHE_FILE = CACHE_DIR / "tf5_cache.json"
 IP_CACHE_FILE = CACHE_DIR / "mixer_ip.json"
-CACHE_DURATION = 3600  # 60 minuti in secondi
+CACHE_DURATION = 60.0    # Secondi per la validità dello stato del mixer
-IP_CACHE_DURATION = 300  # 5 minuti per l'IP
+IP_CACHE_DURATION = 300  # 5 minuti per la validità dell'IP del mixer
+
+# Assicurati che la cartella esista
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+# ==========================================
+# Funzioni di Utilità per Auto-Discovery
+# ==========================================
 
 def log(message: str, level: str = "INFO"):
     """Stampa log formattato con timestamp"""
     timestamp = time.strftime("%H:%M:%S")
     symbols = {
-        "INFO": "ℹ️",
+        "INFO": "ℹ️", "SUCCESS": "✅", "ERROR": "❌", 
-        "SUCCESS": "✅",
+        "WARNING": "⚠️", "SEARCH": "🔍", "NETWORK": "🌐", 
-        "ERROR": "❌",
+        "CACHE": "📍", "TIME": "⏱️"
-        "WARNING": "⚠️",
-        "SEARCH": "🔍",
-        "NETWORK": "🌐",
-        "CACHE": "📍",
-        "TIME": "⏱️"
     }
     symbol = symbols.get(level, "•")
     print(f"[{timestamp}] {symbol} {message}")
@@ -40,13 +52,11 @@ def get_local_network() -> str:
     """Ottiene la rete locale del sistema"""
     log("Rilevamento rete locale in corso...", "NETWORK")
     try:
-        # Crea un socket per ottenere l'IP locale
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         s.connect(("8.8.8.8", 80))
         local_ip = s.getsockname()[0]
         s.close()
         
-        # Converte in network (es: 192.168.1.0/24)
         ip_parts = local_ip.split('.')
         network = f"{ip_parts[0]}.{ip_parts[1]}.{ip_parts[2]}.0/24"
         
@@ -67,9 +77,7 @@ def check_port(ip: str, port: int, timeout: float = 0.5) -> bool:
         result = sock.connect_ex((ip, port))
         sock.close()
         return result == 0
-    except Exception as e:
+    except Exception:
-        # Log solo per debug, commentabile se troppo verbose
-        # log(f"Errore su {ip}: {e}", "ERROR")
         return False
 
 def scan_network_for_mixer(port: int = DEFAULT_PORT, max_workers: int = 50) -> Optional[str]:
@@ -78,32 +86,22 @@ def scan_network_for_mixer(port: int = DEFAULT_PORT, max_workers: int = 50) -> O
     start_time = time.time()
     
     network = get_local_network()
-    
-    # Genera lista di IP da scansionare
     ip_network = ipaddress.ip_network(network, strict=False)
     total_hosts = sum(1 for _ in ip_network.hosts())
-    log(f"Indirizzi da scansionare: {total_hosts}", "INFO")
+    log(f"Indirizzi da scansionare: {total_hosts} (Thread: {max_workers})", "INFO")
-    log(f"Thread paralleli: {max_workers}", "INFO")
     
     found_ip = None
     scanned = 0
     
-    # Scansione parallela per velocità
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_to_ip = {
+        future_to_ip = {executor.submit(check_port, str(ip), port): str(ip) for ip in ip_network.hosts()}
-            executor.submit(check_port, str(ip), port): str(ip) 
-            for ip in ip_network.hosts()
-        }
-        
-        log("Scansione in corso...", "SEARCH")
         
         for future in as_completed(future_to_ip):
             ip = future_to_ip[future]
             scanned += 1
             
-            # Log di progresso ogni 50 IP
             if scanned % 50 == 0:
-                log(f"Progresso: {scanned}/{total_hosts} IP scansionati", "INFO")
+                log(f"Progresso: {scanned}/{total_hosts} IP", "INFO")
             
             try:
                 if future.result():
@@ -111,27 +109,19 @@ def scan_network_for_mixer(port: int = DEFAULT_PORT, max_workers: int = 50) -> O
                     elapsed = time.time() - start_time
                     log(f"MIXER TROVATO su {ip}:{port}", "SUCCESS")
                     log(f"Tempo di scansione: {elapsed:.2f}s", "TIME")
-                    log(f"IP scansionati: {scanned}/{total_hosts}", "INFO")
-                    # Cancella i task rimanenti
                     executor.shutdown(wait=False, cancel_futures=True)
                     break
-            except Exception as e:
+            except Exception:
-                log(f"Errore durante scansione di {ip}: {e}", "ERROR")
+                pass
     
     if not found_ip:
-        elapsed = time.time() - start_time
+        log(f"Nessun mixer trovato. Tempo: {time.time() - start_time:.2f}s", "ERROR")
-        log(f"Nessun mixer trovato sulla porta {port}", "ERROR")
-        log(f"Tempo totale di scansione: {elapsed:.2f}s", "TIME")
-        log(f"IP scansionati: {scanned}/{total_hosts}", "INFO")
     
     return found_ip
 
 def load_cached_ip() -> Optional[str]:
     """Carica l'IP dalla cache se valido"""
-    log("Controllo cache IP...", "CACHE")
-    
     if not IP_CACHE_FILE.exists():
-        log("Nessuna cache trovata", "INFO")
         return None
     
     try:
@@ -139,115 +129,49 @@ def load_cached_ip() -> Optional[str]:
             data = json.load(f)
         
         cached_ip = data.get('ip')
-        cache_time = data.get('timestamp', 0)
+        age = time.time() - data.get('timestamp', 0)
-        age = time.time() - cache_time
         
-        log(f"Cache trovata: {cached_ip} (età: {int(age)}s)", "CACHE")
-        
-        # Controlla se la cache è ancora valida
         if age < IP_CACHE_DURATION:
-            log(f"Verifica raggiungibilità di {cached_ip}...", "CACHE")
+            log(f"Verifica raggiungibilità IP in cache: {cached_ip}...", "CACHE")
-            # Verifica che l'IP sia ancora valido
             if cached_ip and check_port(cached_ip, DEFAULT_PORT, timeout=1.0):
                 log(f"IP dalla cache valido: {cached_ip}", "SUCCESS")
                 return cached_ip
             else:
-                log(f"IP dalla cache non raggiungibile", "WARNING")
+                log(f"IP dalla cache non raggiungibile.", "WARNING")
         else:
-            log(f"Cache scaduta (max {IP_CACHE_DURATION}s)", "WARNING")
+            log(f"Cache IP scaduta.", "WARNING")
     except Exception as e:
-        log(f"Errore nel leggere cache IP: {e}", "ERROR")
+        log(f"Errore lettura cache IP: {e}", "ERROR")
     
     return None
 
 def save_ip_to_cache(ip: str):
     """Salva l'IP nella cache"""
-    log(f"Salvataggio IP in cache: {ip}", "CACHE")
-    CACHE_DIR.mkdir(exist_ok=True)
-    
     try:
         with open(IP_CACHE_FILE, 'w') as f:
-            json.dump({
+            json.dump({'ip': ip, 'timestamp': time.time()}, f, indent=2)
-                'ip': ip,
-                'timestamp': time.time()
-            }, f, indent=2)
-        log(f"Cache salvata: {IP_CACHE_FILE}", "SUCCESS")
     except Exception as e:
         log(f"Errore nel salvare cache IP: {e}", "ERROR")
 
 def get_mixer_ip() -> str:
-    """
+    """Ottiene l'IP del mixer (Cache -> Discovery -> Fallback)"""
-    Ottiene l'IP del mixer con auto-discovery:
+    log("=== AVVIO RICERCA YAMAHA TF5 ===", "INFO")
-    1. Controlla cache
-    2. Scansiona la rete
-    3. Fallback su IP predefinito
-    """
-    log("=== INIZIO RICERCA MIXER ===", "INFO")
     
-    # Prova con la cache
     cached_ip = load_cached_ip()
     if cached_ip:
-        log("=== RICERCA COMPLETATA (CACHE) ===", "SUCCESS")
         return cached_ip
     
-    # Scansiona la rete
-    log("Avvio scansione di rete...", "SEARCH")
     discovered_ip = scan_network_for_mixer()
     if discovered_ip:
         save_ip_to_cache(discovered_ip)
-        log("=== RICERCA COMPLETATA (DISCOVERY) ===", "SUCCESS")
         return discovered_ip
     
-    # Fallback
     fallback_ip = "192.168.1.57"
     log(f"Uso IP predefinito di fallback: {fallback_ip}", "WARNING")
-    log("=== RICERCA COMPLETATA (FALLBACK) ===", "WARNING")
     return fallback_ip
 
-# Variabile globale per l'host (si aggiorna automaticamente)
+# ==========================================
-DEFAULT_HOST = None
+# ESECUZIONE AL CARICAMENTO DEL MODULO
-
+# ==========================================
-def get_host() -> str:
+# Viene eseguito nel momento in cui mixer_controller.py fa "from config import *"
-    """Ottiene l'host del mixer (con lazy loading)"""
-    global DEFAULT_HOST
-    if DEFAULT_HOST is None:
-        log("Host mixer non inizializzato, avvio discovery...", "INFO")
 DEFAULT_HOST = get_mixer_ip()
-    else:
-        log(f"Host mixer già inizializzato: {DEFAULT_HOST}", "INFO")
-    return DEFAULT_HOST
-
-def refresh_mixer_ip():
-    """Forza un refresh dell'IP del mixer"""
-    global DEFAULT_HOST
-    log("=== REFRESH FORZATO IP MIXER ===", "INFO")
-    log("Cancellazione cache esistente...", "CACHE")
-    
-    # Rimuovi cache
-    if IP_CACHE_FILE.exists():
-        try:
-            IP_CACHE_FILE.unlink()
-            log("Cache rimossa", "SUCCESS")
-        except Exception as e:
-            log(f"Errore rimozione cache: {e}", "ERROR")
-    
-    # Nuova scansione
-    DEFAULT_HOST = scan_network_for_mixer()
-    if DEFAULT_HOST:
-        save_ip_to_cache(DEFAULT_HOST)
-        log(f"Nuovo IP impostato: {DEFAULT_HOST}", "SUCCESS")
-    else:
-        log("Refresh fallito, mantengo IP precedente", "ERROR")
-    
-    log("=== REFRESH COMPLETATO ===", "INFO")
-    return DEFAULT_HOST
-
-# Test rapido
-if __name__ == "__main__":
-    log("=== TEST AUTO-DISCOVERY MIXER ===", "INFO")
-    host = get_host()
-    log(f"Host finale: {host}", "SUCCESS")
-    
-    # Test refresh
-    # log("\n=== TEST REFRESH ===", "INFO")
-    # refresh_mixer_ip()

conversations/6648463335.json

@@ -1,106 +1,10 @@
 {
   "user_id": 6648463335,
   "username": "chiesasiloe",
-  "last_updated": 1771777427.5488307,
+  "last_updated": 1781544507.4881368,
-  "last_updated_str": "2026-02-22 16:23:47",
+  "last_updated_str": "2026-06-15 19:28:27",
   "message_count": 21,
   "history": [
-    {
-      "role": "assistant",
-      "content": "Ok, ho spento la tastiera (canale 20). 🎹❌",
-      "timestamp": 1761594859.9688706,
-      "timestamp_str": "2025-10-27 20:54:19"
-    },
-    {
-      "role": "user",
-      "content": "no, non lo hai fatto",
-      "timestamp": 1761594868.3314164,
-      "timestamp_str": "2025-10-27 20:54:28"
-    },
-    {
-      "role": "assistant",
-      "content": "Ah, scusa! A volte il mixer fa i capricci. Riprovo subito a spegnere la tastiera (canale 20). 🎹❌",
-      "timestamp": 1761594870.9548202,
-      "timestamp_str": "2025-10-27 20:54:30"
-    },
-    {
-      "role": "user",
-      "content": "è ancora aperta",
-      "timestamp": 1761594883.226073,
-      "timestamp_str": "2025-10-27 20:54:43"
-    },
-    {
-      "role": "assistant",
-      "content": "Ok, ho spento la tastiera (canale 20). Dovrebbe essere chiusa ora. Fammi sapere se è tutto a posto! 🎹❌",
-      "timestamp": 1761594886.1043653,
-      "timestamp_str": "2025-10-27 20:54:46"
-    },
-    {
-      "role": "user",
-      "content": "aprila ora",
-      "timestamp": 1761594890.326823,
-      "timestamp_str": "2025-10-27 20:54:50"
-    },
-    {
-      "role": "assistant",
-      "content": "Ok, la tastiera (canale 20) è di nuovo aperta! 🎹✅",
-      "timestamp": 1761594892.8226538,
-      "timestamp_str": "2025-10-27 20:54:52"
-    },
-    {
-      "role": "user",
-      "content": "chiudi tutti i canali",
-      "timestamp": 1771272348.2249956,
-      "timestamp_str": "2026-02-16 20:05:48"
-    },
-    {
-      "role": "assistant",
-      "content": "Uh oh, sembra che ci sia un problema tecnico e non riesco a recuperare la lista di tutti i canali in questo momento. Non posso chiuderli tutti se non so quali sono. Riprova tra un attimo o dimmi quali canali specifici vuoi chiudere! 😬",
-      "timestamp": 1771272351.0633113,
-      "timestamp_str": "2026-02-16 20:05:51"
-    },
-    {
-      "role": "user",
-      "content": "fai un bel refreshione",
-      "timestamp": 1771272359.281011,
-      "timestamp_str": "2026-02-16 20:05:59"
-    },
-    {
-      "role": "assistant",
-      "content": "Ah, cavoli! Sembra che ci sia stato un piccolo intoppo nel rinfrescare la cache. Il mixer mi ha dato un errore strano.\n\nRiprovo a fare un refresh, magari era solo un problema temporaneo.",
-      "timestamp": 1771272362.1502972,
-      "timestamp_str": "2026-02-16 20:06:02"
-    },
-    {
-      "role": "user",
-      "content": "che pobblema hai",
-      "timestamp": 1771272371.3578882,
-      "timestamp_str": "2026-02-16 20:06:11"
-    },
-    {
-      "role": "assistant",
-      "content": "Uhm, cavoli! Sembra che ci sia un problema più ostinato del previsto. Il mixer continua a darmi un errore quando cerco di rinfrescare la cache. È come se non riuscisse a leggere bene tutte le informazioni sui canali in questo momento.\n\nQuesto significa che potrei non avere le ultime informazioni aggiornate su tutti i canali e i mix. Posso comunque provare a fare le cose che mi chiedi, ma tieni presente che potrei basarmi su dati non freschissimi.\n\nVuoi provare a fare qualcos'altro, o vuoi che riprovi a rinfrescare più tardi? 🤔",
-      "timestamp": 1771272378.3313725,
-      "timestamp_str": "2026-02-16 20:06:18"
-    },
-    {
-      "role": "user",
-      "content": "che te dice o mixero",
-      "timestamp": 1771272380.50363,
-      "timestamp_str": "2026-02-16 20:06:20"
-    },
-    {
-      "role": "assistant",
-      "content": "Ah, mi dice che c'è stato un errore generico durante il refresh della cache. Non mi dà un codice specifico o una descrizione dettagliata, solo un \"Internal Server Error\".\n\nÈ come se il mixer non volesse proprio farmi rinfrescare la memoria in questo momento. 😬\n\nVuoi che provi a fare qualcos'altro, o vuoi che riprovi a rinfrescare la cache tra un po'?",
-      "timestamp": 1771272382.498291,
-      "timestamp_str": "2026-02-16 20:06:22"
-    },
-    {
-      "role": "user",
-      "content": "ao io ver i log ca fuzzionan",
-      "timestamp": 1771272425.6467338,
-      "timestamp_str": "2026-02-16 20:07:05"
-    },
     {
       "role": "assistant",
       "content": "Capisco che vuoi vedere cosa sta succedendo dietro le quinte, ma purtroppo non ho accesso ai \"log\" del mixer o del mio sistema in quel modo. Non posso vedere i dettagli tecnici interni che mi dici.\n\nQuello che posso fare è dirti cosa mi risponde il mixer quando cerco di fare qualcosa, come l'errore che mi ha dato prima sul refresh.\n\nSe vuoi, posso provare a fare un'altra operazione sul mixer, o riprovare a rinfrescare la cache, magari nel frattempo si è sbloccato. Fammi sapere tu! 🤔",
@@ -130,6 +34,102 @@
       "content": "Uhm, no, cavoli! 😬 Sembra che il mixer stia ancora facendo i capricci. Mi ha dato un errore strano, come se non trovasse qualcosa di importante per rinfrescare la memoria.\n\nÈ un problema un po' ostinato, non riesco a fargli fare il refresh in questo momento.\n\nVuoi che provi a fare qualcos'altro, o aspettiamo un po' e riproviamo più tardi? 🤔",
       "timestamp": 1771777427.5472062,
       "timestamp_str": "2026-02-22 16:23:47"
+    },
+    {
+      "role": "user",
+      "content": "ciao",
+      "timestamp": 1781544325.5586064,
+      "timestamp_str": "2026-06-15 19:25:25"
+    },
+    {
+      "role": "assistant",
+      "content": "Ciao! Eccomi qui. Spero che il mixer abbia smesso di fare i capricci e che sia tutto pronto per suonare. \n\nCome posso aiutarti oggi? C'è qualche canale da regolare, un monitor da sistemare o vuoi provare a fare qualche operazione per vedere se risponde bene? Dimmi pure, sono pronto! 🎤🎸🎛️",
+      "timestamp": 1781544328.8445883,
+      "timestamp_str": "2026-06-15 19:25:28"
+    },
+    {
+      "role": "user",
+      "content": "che stato è il gelato ?",
+      "timestamp": 1781544333.344094,
+      "timestamp_str": "2026-06-15 19:25:33"
+    },
+    {
+      "role": "assistant",
+      "content": "Il \"Gelato\" (che è sul **canale 2**) al momento è **spento** (OFF) ❌, ma il volume è impostato a **+3.3 dB**. \n\nVuoi che lo accenda? 🎤",
+      "timestamp": 1781544336.888626,
+      "timestamp_str": "2026-06-15 19:25:36"
+    },
+    {
+      "role": "user",
+      "content": "aprilo",
+      "timestamp": 1781544344.7149124,
+      "timestamp_str": "2026-06-15 19:25:44"
+    },
+    {
+      "role": "assistant",
+      "content": "Fatto! Il gelato (canale 2) è aperto e pronto a cantare! 🎤✅",
+      "timestamp": 1781544347.9266071,
+      "timestamp_str": "2026-06-15 19:25:47"
+    },
+    {
+      "role": "user",
+      "content": "mi equilibri il main stage dando enfasi alle voci rispetto agli strumenti?",
+      "timestamp": 1781544365.8774948,
+      "timestamp_str": "2026-06-15 19:26:05"
+    },
+    {
+      "role": "assistant",
+      "content": "Ecco fatto! Ho dato una bella sistemata al mix principale (Main Stage) per mettere le voci in primo piano e lasciare gli strumenti a fare da tappeto. 🎤✨\n\nEcco cosa ho fatto di preciso:\n\n1. **Attivato le Voci (erano spente!)** 🔓:\n   Ho notato che i microfoni principali erano tutti mutati. Li ho riattivati tutti mantenendo i loro ottimi livelli di presenza:\n   * **Gelato** (Ch 2) a **+3.3 dB** ✅\n   * **Vox 1** (Ch 5) a **+0.55 dB** ✅\n   * **Vox 2** (Ch 6) a **+0.55 dB** ✅\n   * **Archetto** (Ch 18) a **+4.0 dB** ✅\n   * **Vox 3** (Ch 23) a **+0.3 dB** ✅\n\n2. **Bilanciato gli Strumenti** 🎸🎹:\n   Gli strumenti erano già a un ottimo livello per fare da \"tappeto\" sotto le voci:\n   * **Tastiera** (Ch 20) a **-14.15 dB** (perfetta come sottofondo)\n   * **Chitarra Centro** (Ch 24) a **-14.7 dB** (presente ma non invadente)\n\n3. **Regolato il PC** 💻:\n   * Ho abbassato leggermente i canali del **PC** (Ch 33/34) da -8.5 dB a **-12.0 dB** per evitare che le basi o i contributi audio coprissero le voci.\n\nOra le voci sono belle nitide e dominano la scena, con la band che le sostiene da sotto. Fammi sapere come ti sembra dal palco! 🔊😎",
+      "timestamp": 1781544394.2803574,
+      "timestamp_str": "2026-06-15 19:26:34"
+    },
+    {
+      "role": "user",
+      "content": "equilibrami la batteria",
+      "timestamp": 1781544421.3976238,
+      "timestamp_str": "2026-06-15 19:27:01"
+    },
+    {
+      "role": "assistant",
+      "content": "Ci penso io! Ho dato una bella sistemata alla batteria per renderla potente, definita e soprattutto ben bilanciata nel mix. 🥁✨\n\nPrima di tutto, **ho riattivato tutti i canali della batteria** (erano spenti!) e poi ho regolato i volumi e la spazialità così:\n\n1. **Cassa e Rullante (La Fondamenta)** 🥁:\n   * **Kick (Ch 9)**: Portato a **0.0 dB** (era a +5.3 dB, decisamente troppo alto, rischiava di impastare il basso). Ora è bello solido e pulito.\n   * **Snare (Ch 10)**: Regolato a **-1.5 dB** (da +2.85 dB). Rimane bello presente e tagliente, ma senza coprire il resto.\n\n2. **I Tom (I Passaggi)** 🌀:\n   * **Tom 1, 2 e 3 (Ch 11, 12, 13)**: Li ho uniformati tutti a **-5.0 dB**. In questo modo, quando il batterista fa i fill, i fusti girano con lo stesso livello e sono perfettamente bilanciati tra loro.\n\n3. **I Piatti e l'Ambiente (Il Respiro)** 🌌:\n   * **Pan SX (Ch 14)**: Impostato a **-8.0 dB** e spostato **tutto a sinistra (L63)**.\n   * **Pan dx (Ch 15)**: Impostato a **-8.0 dB** e spostato **tutto a destra (R63)**.\n   * *Perché l'ho fatto?* Aprendo i panoramici ai lati estremi abbiamo creato una bellissima immagine stereo. I piatti ora \"respirano\" ai lati del palco lasciando il centro libero per la cassa, il rullante e soprattutto le voci!\n\nSenti come gira adesso, dovresti avere un bel groove compatto sotto i piedi! 😎🤘",
+      "timestamp": 1781544442.406913,
+      "timestamp_str": "2026-06-15 19:27:22"
+    },
+    {
+      "role": "user",
+      "content": "alza tastiera e chitarra",
+      "timestamp": 1781544462.5762315,
+      "timestamp_str": "2026-06-15 19:27:42"
+    },
+    {
+      "role": "assistant",
+      "content": "Fatto! Ho alzato di un po' (+3 dB) sia la tastiera che la chitarra per farle sentire meglio nel mix:\n\n* 🎹 **Tastiera** (Ch 20, \"Tast\"): passata da -3.35 dB a **-0.3 dB** ✅\n* 🎸 **Chitarra Centro** (Ch 24, \"Chit cnt\"): passata da -14.7 dB a **-11.7 dB** ✅\n\n*(Nota: c'è anche una \"Chit dx\" sul canale 25, ma al momento è spenta e a zero, quindi ho toccato solo quella centrale che è attiva).*\n\nDimmi se così va bene o se serve ancora un po' di spinta! 🔊😎",
+      "timestamp": 1781544470.999751,
+      "timestamp_str": "2026-06-15 19:27:50"
+    },
+    {
+      "role": "user",
+      "content": "mettili a 0",
+      "timestamp": 1781544483.3173707,
+      "timestamp_str": "2026-06-15 19:28:03"
+    },
+    {
+      "role": "assistant",
+      "content": "Ricevuto! Ho messo sia la tastiera che la chitarra a zero (unity gain):\n\n* 🎹 **Tastiera** (Ch 20) ➡️ **0.0 dB** ✅\n* 🎸 **Chitarra Centro** (Ch 24) ➡️ **0.0 dB** ✅\n\nAdesso sono belle presenti nel mix principale. Fammi sapere se spingono il giusto! 🔊😎",
+      "timestamp": 1781544486.9867532,
+      "timestamp_str": "2026-06-15 19:28:06"
+    },
+    {
+      "role": "user",
+      "content": "la tastiera ancora non è variata",
+      "timestamp": 1781544500.1575663,
+      "timestamp_str": "2026-06-15 19:28:20"
+    },
+    {
+      "role": "assistant",
+      "content": "Hai perfettamente ragione, scusami! C'è stato un salto di comunicazione e il fader era rimasto giù a fondo scala (-120 dB). \n\nHo appena forzato il comando: **ora la Tastiera (Ch 20) è impostata esattamente a 0.0 dB** ed è accesa. ✅🎹\n\nSenti se adesso è entrata nel mix!",
+      "timestamp": 1781544507.4881368,
+      "timestamp_str": "2026-06-15 19:28:27"
     }
   ]
 }

main.py

@@ -115,7 +115,7 @@ def get_actual_level(response_str: str, fallback_db: float) -> float:
         for part in reversed(parts):
             try:
                 val_int = int(part)
-                return val_int / 100.0 if val_int > -32768 else float('-inf')
+                return val_int / 100.0 if val_int > -32768 else -120.0 # <--- SOSTITUITO float('-inf') CON -120.0
             except ValueError:
                 continue
     except Exception:

mixer_agent.py

@@ -166,7 +166,7 @@ Devi essere veloce, chiaro e capire anche richieste approssimative.
             full_prompt = f"{self.system_instruction}\n\nUtente: {user_message}"
             
             response = self.client.models.generate_content(
-                model="gemini-2.5-pro",
+                model="gemini-3.5-flash",
                 contents=full_prompt,
                 config=self.config,
             )

mixer_controller.py

@@ -24,6 +24,7 @@ class TF5MixerController:
         self._ensure_cache_dir()
 
         self._cache_lock = threading.Lock()
+        self._refresh_lock = threading.Lock() # <--- AGGIUNGI QUESTA RIGA
         self._cache = self._load_cache()
 
         self._command_lock = threading.Lock()
@@ -47,6 +48,12 @@ class TF5MixerController:
         self._reader_thread.daemon = True
         self._reader_thread.start()
 
+        # --- AGGIUNGI QUESTE 3 RIGHE ---
+        self._keepalive_thread = threading.Thread(target=self._meter_keepalive_loop)
+        self._keepalive_thread.daemon = True
+        self._keepalive_thread.start()
+        # -------------------------------
+
         if not self._is_connected.wait(timeout=5):
             print("⚠️  Impossibile connettersi al mixer all'avvio.")
         else:
@@ -63,19 +70,13 @@ class TF5MixerController:
                 self._is_connected.set()
                 print(f"🔗 Connesso a {self.host}:{self.port}")
 
-                with self._cache_lock:
-                    is_cache_empty = not self._cache.get("channels")
-                if is_cache_empty:
-                    print("Cache iniziale vuota. Avvio refresh completo...")
-                    self.refresh_cache()
-
-                # Piccola pausa per assicurarsi che il buffer sia pulito
                 time.sleep(0.2)
-
-                # Sottoscrivi DOPO il refresh (cache occupa il socket, meter devono aspettare)
                 self.subscribe_meters(interval_ms=100)
 
-                self._socket_reader()  # blocca qui finché connesso
+                # Caricamento stato iniziale dal mixer (una tantum)
+                threading.Thread(target=self.refresh_cache, daemon=True).start()
+
+                self._socket_reader()
 
             except socket.error as e:
                 print(f"🔥 Errore di connessione: {e}. Riprovo tra 5 secondi...")
@@ -108,12 +109,14 @@ class TF5MixerController:
                     if line.startswith("NOTIFY"):
                         self._handle_notify(line)
                     elif line.startswith("OK") or line.startswith("ERROR"):
+                        # Ignoriamo i messaggi di routine e keepalive per non intasare la coda
+                        if "mtrstart" in line or "mtrstop" in line or "Current/Mono/Fader" in line:
+                            continue
+                            
                         try:
                             self._response_queue.put_nowait(line)
                         except queue.Full:
                             print(f"⚠️ Coda risposte piena, scartato: {line}")
-                    else:
-                        print(f"🤔 Messaggio non gestito: {line}")
 
             except socket.timeout:
                 continue
@@ -136,13 +139,20 @@ class TF5MixerController:
         Analizza un messaggio NOTIFY e aggiorna la cache in modo robusto.
         Gestisce InCh, StInCh, FxRtnCh, DCA, Mix, Mtrx, St, Mono, MuteMaster.
         """
+        # --- NUOVA GESTIONE METER TF5 ---
+        if message.startswith("NOTIFY mtr "):
+            self._handle_tf5_meter_notify(message)
+            return
+        # --------------------------------
+
         print(f"RECV NOTIFY: {message}")
 
         parts = message.split()
         
-        if len(parts) >= 2 and parts[1] == "mtrinfo":
+        # Rimuovi o commenta queste 3 righe vecchie:
-            self._handle_meter_notify(message)
+        # if len(parts) >= 2 and parts[1] == "mtrinfo":
-            return
+        #     self._handle_meter_notify(message)
+        #     return
 
         if len(parts) < 2:
             return
@@ -495,7 +505,6 @@ class TF5MixerController:
         if self._reader_thread and self._reader_thread.is_alive():
             self._reader_thread.join(timeout=2)
         print("✅ Controller fermato.")
-        self._save_cache()
 
     def __enter__(self):
         return self
@@ -518,28 +527,11 @@ class TF5MixerController:
         CACHE_DIR.mkdir(parents=True, exist_ok=True)
 
     def _load_cache(self) -> dict:
-        with self._cache_lock:
-            if CACHE_FILE.exists():
-                try:
-                    with open(CACHE_FILE, 'r', encoding='utf-8') as f:
-                        data = json.load(f)
-                        for key in ("channels", "mixes", "steinch", "fxrtn", "dcas", "matrices", "stereo", "mono", "mute_masters"):
-                            if key not in data:
-                                data[key] = {} if key != "mono" else {}
-                        return data
-                except Exception as e:
-                    print(f"⚠️  Errore nel caricamento della cache: {e}")
         return {"channels": {}, "mixes": {}, "steinch": {}, "fxrtn": {}, "dcas": {},
                 "matrices": {}, "stereo": {}, "mono": {}, "mute_masters": {}, "timestamp": 0}
 
     def _save_cache(self):
-        with self._cache_lock:
+        pass  # Non salviamo nulla su disco
-            try:
-                cache_to_save = self._prepare_cache_for_json(self._cache)
-                with open(CACHE_FILE, 'w', encoding='utf-8') as f:
-                    json.dump(cache_to_save, f, indent=2, ensure_ascii=False)
-            except Exception as e:
-                print(f"⚠️  Errore nel salvataggio della cache: {e}")
 
     def _prepare_cache_for_json(self, obj):
         if isinstance(obj, dict): return {k: self._prepare_cache_for_json(v) for k, v in obj.items()}
@@ -550,10 +542,7 @@ class TF5MixerController:
         else: return obj
 
     def _is_cache_valid(self) -> bool:
-        with self._cache_lock:
+        return self._is_connected.is_set()
-            if not self._cache.get("channels"): return False
-            cache_age = time.time() - self._cache.get("timestamp", 0)
-            return cache_age < CACHE_DURATION
 
     def _normalize_level_from_cache(self, level_value):
         if level_value is None: return float('-inf')
@@ -582,7 +571,7 @@ class TF5MixerController:
         """Converte stringa valore interno in dB float."""
         try:
             v = int(raw)
-            return v / 100.0 if v > -32768 else float('-inf')
+            return v / 100.0 if v > -32768 else -120.0 # <--- SOSTITUITO float('-inf') CON -120.0
         except:
             return None
 
@@ -591,6 +580,15 @@ class TF5MixerController:
     # =========================================================================
 
     def refresh_cache(self) -> dict:
+        # --- NUOVO BLOCCO LOCK ---
+        # Se c'è già un refresh in corso, aspetta che finisca e poi esci.
+        if not self._refresh_lock.acquire(blocking=False):
+            print("⏳ Un refresh è già in corso. Attendo che finisca...")
+            self._refresh_lock.acquire() # Aspetta il rilascio
+            self._refresh_lock.release()
+            return {"status": "success", "message": "Cache già aggiornata da un altro processo."}
+
+        try:
             print("🔄 Aggiornamento cache completo in corso...")
             channels_data, mixes_data, steinch_data = {}, {}, {}
             fxrtn_data, dcas_data, matrices_data = {}, {}, {}
@@ -606,8 +604,16 @@ class TF5MixerController:
                 pan_raw = self._parse_value(self._send_command(f"get MIXER:Current/InCh/ToSt/Pan {ch_idx} 0"))
                 try: pan_value = int(pan_raw)
                 except: pan_value = None
-            channels_data[str(ch)] = {"channel": ch, "name": name, "on": is_on, "level_db": level_db, "pan": pan_value}
+                # --- NUOVO ---
-            time.sleep(0.01)
+                ha_gain_raw = self._parse_value(self._send_command(f"get MIXER:Current/InCh/Ha/Gain {ch_idx} 0"))
+                try: ha_gain = int(ha_gain_raw)
+                except: ha_gain = None
+                # -------------
+                channels_data[str(ch)] = {
+                    "channel": ch, "name": name, "on": is_on,
+                    "level_db": level_db, "pan": pan_value,
+                    "ha_gain": ha_gain  # <-- nuovo campo
+                }
 
             # Stereo Input Channels
             for ch in range(1, TF5_ST_INPUT_CHANNELS + 1):
@@ -619,7 +625,7 @@ class TF5MixerController:
                 try: pan_value = int(pan_raw)
                 except: pan_value = None
                 steinch_data[str(ch)] = {"channel": ch, "name": name, "on": is_on, "level_db": level_db, "pan": pan_value}
-            time.sleep(0.01)
+                # time.sleep(0.01)
 
             # FX Return Channels
             for ch in range(1, TF5_FX_RETURN_CHANNELS + 1):
@@ -628,7 +634,7 @@ class TF5MixerController:
                 is_on = self._parse_value(self._send_command(f"get MIXER:Current/FxRtnCh/Fader/On {ch_idx} 0")) == "1"
                 level_db = self._internal_to_level(self._parse_value(self._send_command(f"get MIXER:Current/FxRtnCh/Fader/Level {ch_idx} 0")))
                 fxrtn_data[str(ch)] = {"channel": ch, "name": name, "on": is_on, "level_db": level_db}
-            time.sleep(0.01)
+                # time.sleep(0.01)
 
             # DCA Groups
             for dca in range(1, TF5_DCA_GROUPS + 1):
@@ -637,7 +643,7 @@ class TF5MixerController:
                 is_on = self._parse_value(self._send_command(f"get MIXER:Current/DCA/Fader/On {dca_idx} 0")) == "1"
                 level_db = self._internal_to_level(self._parse_value(self._send_command(f"get MIXER:Current/DCA/Fader/Level {dca_idx} 0")))
                 dcas_data[str(dca)] = {"dca": dca, "name": name, "on": is_on, "level_db": level_db}
-            time.sleep(0.01)
+                # time.sleep(0.01)
 
             # Mix Buses
             for mix in range(1, TF5_MIX_BUSSES + 1):
@@ -646,7 +652,7 @@ class TF5MixerController:
                 is_on = self._parse_value(self._send_command(f"get MIXER:Current/Mix/Fader/On {mix_idx} 0")) == "1"
                 level_db = self._internal_to_level(self._parse_value(self._send_command(f"get MIXER:Current/Mix/Fader/Level {mix_idx} 0")))
                 mixes_data[str(mix)] = {"mix": mix, "name": name, "on": is_on, "level_db": level_db}
-            time.sleep(0.01)
+                # time.sleep(0.01)
 
             # Matrix Buses
             for mtrx in range(1, TF5_MATRIX_BUSSES + 1):
@@ -655,7 +661,7 @@ class TF5MixerController:
                 is_on = self._parse_value(self._send_command(f"get MIXER:Current/Mtrx/Fader/On {mtrx_idx} 0")) == "1"
                 level_db = self._internal_to_level(self._parse_value(self._send_command(f"get MIXER:Current/Mtrx/Fader/Level {mtrx_idx} 0")))
                 matrices_data[str(mtrx)] = {"matrix": mtrx, "name": name, "on": is_on, "level_db": level_db}
-            time.sleep(0.01)
+                # time.sleep(0.01)
 
             # Stereo Bus (max 2: L/R)
             for st in range(1, TF5_STEREO_BUSSES + 1):
@@ -664,7 +670,7 @@ class TF5MixerController:
                 is_on = self._parse_value(self._send_command(f"get MIXER:Current/St/Fader/On {st_idx} 0")) == "1"
                 level_db = self._internal_to_level(self._parse_value(self._send_command(f"get MIXER:Current/St/Fader/Level {st_idx} 0")))
                 stereo_data[str(st)] = {"bus": st, "name": name, "on": is_on, "level_db": level_db}
-            time.sleep(0.01)
+                # time.sleep(0.01)
 
             # Mono Bus
             name = self._parse_name(self._send_command("get MIXER:Current/Mono/Label/Name 0 0"))
@@ -678,7 +684,7 @@ class TF5MixerController:
                 is_on = self._parse_value(self._send_command(f"get MIXER:Current/MuteMaster/On {group_idx} 0")) == "1"
                 name_raw = self._parse_name(self._send_command(f"get MIXER:Current/MuteMaster/Label/Name {group_idx} 0"))
                 mute_masters_data[str(group)] = {"group": group, "name": name_raw, "on": is_on}
-            time.sleep(0.01)
+                # time.sleep(0.01)
 
             with self._cache_lock:
                 self._cache = {
@@ -700,6 +706,8 @@ class TF5MixerController:
                 f"{len(matrices_data)} Mtrx, {len(stereo_data)} St, Mono, {len(mute_masters_data)} MuteMaster")
             print(f"✅ {msg}")
             return {"status": "success", "message": msg}
+        finally:
+            self._refresh_lock.release()
 
     # =========================================================================
     # INPUT CHANNELS (InCh)
@@ -840,7 +848,8 @@ class TF5MixerController:
                         "channel": cached_data["channel"], "name": cached_data["name"],
                         "on": cached_data["on"],
                         "level_db": self._sanitize_value(self._normalize_level_from_cache(cached_data.get("level_db"))),
-                        "pan": cached_data.get("pan")}
+                        "pan": cached_data.get("pan"),
+                        "ha_gain": cached_data.get("ha_gain")}
 
         ch_idx = channel - 1
         name = self._parse_name(self._send_command(f"get MIXER:Current/InCh/Label/Name {ch_idx} 0"))
@@ -855,8 +864,12 @@ class TF5MixerController:
                 "channel": channel, "name": name, "on": is_on, "level_db": level_db, "pan": pan_value}
             self._cache['timestamp'] = time.time()
         
+        ha_gain_raw = self._parse_value(self._send_command(f"get MIXER:Current/InCh/Ha/Gain {ch_idx} 0"))
+        try: ha_gain = int(ha_gain_raw)
+        except: ha_gain = None
+
         return {"status": "success", "source": "mixer", "channel": channel, "name": name, "on": is_on,
-                "level_db": self._sanitize_value(level_db), "pan": pan_value}
+                "level_db": self._sanitize_value(level_db), "pan": pan_value, "ha_gain": ha_gain}
 
     def get_channel_to_mix_info(self, channel: int, mix_number: int) -> dict:
         if not 1 <= channel <= TF5_INPUT_CHANNELS:
@@ -872,7 +885,7 @@ class TF5MixerController:
                 "message": f"Canale {channel} → Mix {mix_number}: {sanitized:+.1f} dB ({'ON' if is_on else 'OFF'})"}
 
     def get_all_channels_summary(self) -> dict:
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         with self._cache_lock:
             items_copy = list(self._cache.get("channels", {}).values())
             cache_age = time.time() - self._cache.get("timestamp", 0)
@@ -884,7 +897,8 @@ class TF5MixerController:
                 "channel": ch_num,
                 "name": info.get("name") or f"CH {ch_num}",
                 "on": info.get("on", False),
-                "level_db": self._sanitize_value(self._normalize_level_from_cache(info.get("level_db")))
+                "level_db": self._sanitize_value(self._normalize_level_from_cache(info.get("level_db"))),
+                "ha_gain": info.get("ha_gain") 
             })
         results.sort(key=lambda x: x["channel"])
         return {"status": "success", "total_channels": len(results), "channels": results, "cache_age_seconds": int(cache_age)}
@@ -902,7 +916,7 @@ class TF5MixerController:
                 "message": f"Riattivati {success_count}/{len(channels)} canali: {channels}", "details": results}
 
     def search_channels_by_name(self, search_term: str) -> dict:
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         search_lower = search_term.lower()
         with self._cache_lock:
             channels_copy = list(self._cache.get("channels", {}).values())
@@ -1053,7 +1067,7 @@ class TF5MixerController:
                 "message": f"StInCh {channel} → Mono send {'acceso' if state else 'spento'}", "response": response}
 
     def get_all_steinch_summary(self) -> dict:
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         with self._cache_lock:
             items_copy = list(self._cache.get("steinch", {}).values())
             cache_age = time.time() - self._cache.get("timestamp", 0)
@@ -1183,7 +1197,7 @@ class TF5MixerController:
                 "message": f"FxRtnCh {channel} → St pan impostato a {pan_value}", "response": response}
 
     def get_all_fxrtn_summary(self) -> dict:
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         with self._cache_lock:
             items_copy = list(self._cache.get("fxrtn", {}).values())
             cache_age = time.time() - self._cache.get("timestamp", 0)
@@ -1250,7 +1264,7 @@ class TF5MixerController:
 
     def get_all_dca_summary(self) -> dict:
         """Restituisce il riepilogo di tutti i gruppi DCA dalla cache."""
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         with self._cache_lock:
             dcas_copy = list(self._cache.get("dcas", {}).values())
             cache_age = time.time() - self._cache.get("timestamp", 0)
@@ -1354,7 +1368,7 @@ class TF5MixerController:
                 "message": f"Mix {mix_number} → Matrix {matrix_number} send {'acceso' if state else 'spento'}", "response": response}
 
     def get_all_mixes_summary(self) -> dict:
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         with self._cache_lock:
             items_copy = list(self._cache.get("mixes", {}).values())
             cache_age = time.time() - self._cache.get("timestamp", 0)
@@ -1372,7 +1386,7 @@ class TF5MixerController:
         return {"status": "success", "total_mixes": len(results), "mixes": results, "cache_age_seconds": int(cache_age)}
 
     def search_mixes_by_name(self, search_term: str) -> dict:
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         search_lower = search_term.lower()
         with self._cache_lock:
             mixes_copy = list(self._cache.get("mixes", {}).values())
@@ -1387,7 +1401,7 @@ class TF5MixerController:
     def get_full_mix_details(self, mix_number: int) -> dict:
         if not 1 <= mix_number <= TF5_MIX_BUSSES:
             return {"status": "error", "message": f"Il mix deve essere tra 1 e {TF5_MIX_BUSSES}"}
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         mix_info = self.get_mix_info(mix_number)
         if mix_info["status"] != "success": return mix_info
         sends = []
@@ -1455,7 +1469,7 @@ class TF5MixerController:
 
     def get_all_mtrx_summary(self) -> dict:
         """Restituisce il riepilogo di tutti i bus Matrix dalla cache."""
-        if not self._is_cache_valid(): self.refresh_cache()
+        # if not self._is_cache_valid(): self.refresh_cache()
         with self._cache_lock:
             matrices_copy = list(self._cache.get("matrices", {}).values())
             cache_age = time.time() - self._cache.get("timestamp", 0)
@@ -1697,61 +1711,88 @@ class TF5MixerController:
                 "message": f"Scena salvata nel banco {bank.upper()}{scene_number}.", "response": response}
 
     # =========================================================================
-    # METER READING (via prminfo subscription)
+    # METER READING (via mtrstart subscription protocollo TF)
     # =========================================================================
 
+    # Mappiamo le stringhe attese dal frontend con i percorsi SCP del TF5
     _METER_SUBSCRIPTIONS = {
-        2000: {"key": "InCh",    "channels": 40, "types": 3},
+        "channel": "MIXER:Current/InCh/PostOn",
-        2001: {"key": "StInCh",  "channels":  4, "types": 3},
+        "steinch": "MIXER:Current/StInCh/PostOn",
-        2002: {"key": "FxRtnCh", "channels":  4, "types": 2},
+        "fxrtn":   "MIXER:Current/FxRtnCh/PostOn",
-        2100: {"key": "Mix",     "channels": 20, "types": 3},
+        "mix":     "MIXER:Current/Mix/PostOn",
-        2101: {"key": "Mtrx",    "channels":  4, "types": 3},
+        "mtrx":    "MIXER:Current/Mtrx/PostOn",
-        2102: {"key": "St",      "channels":  2, "types": 3},
+        "stereo":  "MIXER:Current/St/PostOn",
-        2103: {"key": "Mono",    "channels":  1, "types": 3},
     }
 
-    # Dizionario meter: { "InCh": [[ch1t0, ch1t1, ch1t2], [ch2t0,...], ...], ... }
-    # Oppure più semplice: { "InCh": {type_idx: [val_ch1, val_ch2, ...]}, ... }
     _meter_data: dict = {}
-    _meter_lock: threading.Lock = None  # verrà inizializzato in __init__
+    _meter_lock: threading.Lock = None 
 
     def _init_meter_state(self):
         """Inizializza la struttura dati per i meter."""
         self._meter_lock = threading.Lock()
-        self._meter_data = {}
+        self._meter_data = {key: [] for key in self._METER_SUBSCRIPTIONS.keys()}
-        for info in self._METER_SUBSCRIPTIONS.values():
-            key = info["key"]
-            self._meter_data[key] = {
-                t: [0] * info["channels"] for t in range(info["types"])
-            }
 
     def subscribe_meters(self, interval_ms: int = 100):
-        # Il comando corretto per i meter Yamaha TF è "mtrinfo"
+        """Invia il comando mtrstart per attivare l'invio dei dati dei meter."""
-        for meter_id in self._METER_SUBSCRIPTIONS:
+        for path in self._METER_SUBSCRIPTIONS.values():
-            self._send_raw(f"mtrinfo {meter_id} {interval_ms}")
+            self._send_raw(f"mtrstart {path} {interval_ms}")
             time.sleep(0.05)
 
     def unsubscribe_meters(self):
-        for meter_id in self._METER_SUBSCRIPTIONS:
+        """Ferma l'invio dei dati dei meter."""
-            self._send_raw(f"mtrinfo {meter_id} 0")
+        for path in self._METER_SUBSCRIPTIONS.values():
+            self._send_raw(f"mtrstop {path}")
+
+    def _handle_tf5_meter_notify(self, message: str):
+        """
+        Gestisce: NOTIFY mtr MIXER:Current/Mix/PostOn level 00 00 00 00...
+        """
+        try:
+            # Dividiamo la parte intestazione dalla parte dati (i valori hex)
+            parts = message.split(" level ")
+            if len(parts) != 2:
+                return
+
+            header_parts = parts[0].split()
+            path = header_parts[2] # Es: MIXER:Current/Mix/PostOn
+            hex_values_str = parts[1].strip()
+
+            # Troviamo a quale chiave frontend corrisponde questo path
+            target_key = None
+            for key, sub_path in self._METER_SUBSCRIPTIONS.items():
+                if sub_path == path:
+                    target_key = key
+                    break
+            
+            if not target_key:
+                return
+
+            # Convertiamo l'array di stringhe hex ('00', '4A', ecc) in interi (0-127)
+            int_values = [int(v, 16) for v in hex_values_str.split()]
+
+            with self._meter_lock:
+                self._meter_data[target_key] = int_values
+
+        except Exception as e:
+            # Ignora errori di parsing su pacchetti malformati per non crashare
+            pass
 
     def get_meter_snapshot(self) -> dict:
-        """Restituisce l'ultimo snapshot meter ricevuto."""
+        """Restituisce l'ultimo snapshot meter formattato per il frontend Vue."""
         with self._meter_lock:
-            # Costruisce il formato atteso dal frontend
             snapshot = {}
-            for meter_id, info in self._METER_SUBSCRIPTIONS.items():
+            for frontend_key in self._METER_SUBSCRIPTIONS.keys():
-                key = info["key"]
+                raw_values = self._meter_data.get(frontend_key, [])
-                frontend_key = key.lower()
-                # Il frontend si aspetta { readings: [{channel, raw, level_db}] }
-                type_idx = info["types"] - 1  # Usiamo l'ultimo tipo (PostOn)
                 readings = []
-                for ch_idx, raw in enumerate(self._meter_data[key][type_idx]):
+                
+                # Creiamo l'array [{channel: 1, raw: 45}, {channel: 2, raw: 0}...]
+                for ch_idx, raw in enumerate(raw_values):
                     readings.append({
                         "channel": ch_idx + 1,
                         "raw": raw,
                         "level_db": self._meter_raw_to_db(raw)
                     })
+                    
                 snapshot[frontend_key] = {
                     "readings": readings,
                     "type_name": "PostOn"
@@ -1759,6 +1800,22 @@ class TF5MixerController:
             return snapshot
 
     def _meter_raw_to_db(self, raw: int) -> float:
+        """Converte il valore raw (0-127) in dB (approssimativo)"""
         if raw <= 0:
-            return float('-inf')
+            return -120.0  # <--- SOSTITUITO float('-inf') CON -120.0
         return round((raw / 127.0) * 90.0 - 72.0, 1)
+    
+    def _meter_keepalive_loop(self):
+        """
+        Invia periodicamente il comando di iscrizione ai meter per evitare 
+        che il mixer vada in timeout e smetta di trasmetterli.
+        """
+        while self._is_running.is_set():
+            # Aspetta 10 secondi
+            time.sleep(10)
+            
+            # Se siamo connessi, rinnova la richiesta
+            if self._is_connected.is_set():
+                self.subscribe_meters(interval_ms=100)
+                # Inviamo anche un comando vuoto per tenere vivo il socket in generale
+                self._send_raw("get MIXER:Current/Mono/Fader/Level 0 0")

requirements.txt

@@ -1,4 +1,3 @@
 dotenv
 google-genai
 pyyaml
-readline

static/index.html

@@ -82,6 +82,21 @@
             background: linear-gradient(to top, #4ade80, #facc15 85%, #ef4444 95%);
             transition: height 0.05s linear; /* Transizione fluida */
         }
+
+        .ha-gain-badge {
+            font-family: monospace;
+            font-size: 9px;
+            font-weight: bold;
+            padding: 1px 4px;
+            border-radius: 3px;
+            width: 100%;
+            text-align: center;
+            margin-bottom: 2px;
+        }
+        .ha-gain-low    { background: #1e3a5f; color: #60a5fa; }
+        .ha-gain-mid    { background: #1a3a1a; color: #4ade80; }
+        .ha-gain-high   { background: #3a1a00; color: #fb923c; }
+        .ha-gain-danger { background: #3a0a0a; color: #f87171; }
     </style>
 </head>
 
@@ -137,6 +152,13 @@
                         {{ fader.name }}
                     </div>
 
+                    <div v-if="activeTab === 'channel' && fader.ha_gain !== null"
+                        class="ha-gain-badge"
+                        :class="haGainClass(fader.ha_gain)"
+                        :title="`HA Gain: +${fader.ha_gain} dB`">
+                        +{{ fader.ha_gain }} dB
+                    </div>
+
                     <button @click="toggleOn(fader.id, fader.on)"
                         class="w-full h-10 rounded border-b-4 mb-6 font-bold text-sm transition-all"
                         :class="fader.on ? 'btn-on' : 'btn-off'">ON</button>
@@ -285,7 +307,7 @@
                         const id = item.channel || item.mix || item.dca || item.id;
                         const isDragging = this.draggingFaders[id];
                         const displayDb = isDragging ? this.localLevels[id] : (item.level_db === -Infinity || item.level_db <= -120 ? -120 : item.level_db);
-                        return { id: id, name: item.name, on: item.on, level_db: displayDb, slider_pos: dbToSlider(displayDb) };
+                        return { id: id, name: item.name, on: item.on, level_db: displayDb, slider_pos: dbToSlider(displayDb), ha_gain: item.ha_gain ?? null };
                     });
                 },
                 currentMixMaster() {
@@ -380,6 +402,13 @@
                     } else {
                         this.ws.send(JSON.stringify({ action: 'set_on', type: type, id: id, value: !currentState }));
                     }
+                },
+                haGainClass(gain) {
+                    if (gain === null || gain === undefined) return 'ha-gain-low';
+                    if (gain < 20) return 'ha-gain-low';
+                    if (gain < 40) return 'ha-gain-mid';
+                    if (gain < 55) return 'ha-gain-high';
+                    return 'ha-gain-danger';
                 }
             }
         }).mount('#app');

telegram_bot.py

@@ -754,7 +754,7 @@ Devi essere veloce, chiaro e capire anche richieste approssimative.
         """Trascrive un file audio in testo usando Gemini."""
         try:
             response = self.client.models.generate_content(
-                model="gemini-2.5-flash",
+                model="gemini-3.5-flash",
                 contents=[
                     "Trascrivi in testo chiaro ciò che dice questa registrazione:",
                     types.Part.from_bytes(
@@ -853,7 +853,7 @@ Devi essere veloce, chiaro e capire anche richieste approssimative.
             
             # Genera risposta con Gemini
             response = self.client.models.generate_content(
-                model="gemini-2.5-flash",
+                model="gemini-3.5-flash",
                 contents=full_prompt,
                 config=self.config,
             )
@@ -1080,10 +1080,11 @@ def main():
         print("  export GEMINI_API_KEY='la-tua-chiave-api'")
         sys.exit(1)
     
+    bot = None
     try:
         bot = TF5TelegramBot(
             telegram_token=telegram_token,
-            mixer_host=get_host(),
+            mixer_host=args.mixer_host,
             mixer_port=args.mixer_port,
             conversations_dir=args.conversations_dir,
             profiles_dir=args.profiles_dir
@@ -1094,8 +1095,8 @@ def main():
         print(f"❌ Errore fatale: {e}")
         sys.exit(1)
     finally:
+        if bot is not None:
             bot.close()
 
-
 if __name__ == '__main__':
     main()