@sailingrotevista/rotevista-dash 6.1.1 → 6.1.3

package/app.js

@@ -128,6 +128,7 @@ function safeSetText(el, text) {
 
 /**
  * Inserimento sicuro nel buffer con trigonometria precaricata e pruning automatico
+ * Mantiene sempre almeno 60 minuti di memoria locale per il calcolo della bussola meteo.
  */
 function safePush(buffer, val, time) {
     if (val === null || val === undefined || isNaN(val)) return;
@@ -139,7 +140,11 @@ function safePush(buffer, val, time) {
         cos: Math.cos(val)
     });
 
-    const maxHistoryMs = (CONFIG.graphs.historyMinutes * 60000 * 2) + 60000;
+    // Se stiamo spingendo nel buffer TWD, conserviamo sempre almeno 60 minuti in memoria locale
+    const isTwdBuffer = (buffer === store.longBuf.twd);
+    const limitMinutes = isTwdBuffer ? 60 : CONFIG.graphs.historyMinutes;
+    const maxHistoryMs = (limitMinutes * 60000 * 2) + 60000;
+
     while (buffer.length > 0 && (time - buffer[0].time) > maxHistoryMs) {
         buffer.shift();
     }
@@ -312,34 +317,61 @@ function updateLeewayDisplay(deg) {
     ui.leewayVal.textContent = `LEEWAY: ${deg.toFixed(1)}°`;
 }
 
-// ==========================================================================
-// 5. MOTORE DI CALCOLO VENTO E DATA ROUTING
-// ==========================================================================
+/**
+ * computeTrueWind: Calcola TWS, TWA e TWD strategico.
+ * Gestisce il fallback separato (Split-Fallback) in caso di dati parzialmente nativi di bordo.
+ */
 function computeTrueWind() {
     const aws = store.raw["environment.wind.speedApparent"], awa = store.raw["environment.wind.angleApparent"];
     const stw = store.raw["navigation.speedThroughWater"] || 0, sog = store.raw["navigation.speedOverGround"] || 0;
     const hdg = store.raw["navigation.headingTrue"] || 0, cog = store.raw["navigation.courseOverGroundTrue"] || 0;
     if (aws === undefined || awa === undefined) return;
 
-    const tw_water_x = aws * Math.cos(awa) - stw, tw_water_y = aws * Math.sin(awa);
-    const tws_water = Math.sqrt(tw_water_x * tw_water_x + tw_water_y * tw_water_y);
-
-    const drift = (cog - hdg + Math.PI * 3) % (2 * Math.PI) - Math.PI;
-    const tw_ground_x = aws * Math.cos(awa) - sog * Math.cos(drift), tw_ground_y = aws * Math.sin(awa) - sog * Math.sin(drift);
-    const tws_ground = Math.sqrt(tw_ground_x * tw_ground_x + tw_ground_y * tw_ground_y);
-
     // Usiamo il tempo esatto di arrivo del pacchetto del vento per la coerenza dei buffer
     const now = store.timestamps["environment.wind.speedApparent"] || Date.now();
-    store.raw["environment.wind.speedTrue"] = tws_water;
-    if (tws_water > 0.05) {
-        const twa = Math.atan2(tw_water_y, tw_water_x);
-        store.raw["environment.wind.angleTrueWater"] = twa;
-        safePush(store.smoothBuf.twa, twa, now); safePush(store.longBuf.twa, twa, now);
+
+    // ==========================================================================
+    // 1. GESTIONE TWS (NATIVO vs FALLBACK)
+    // ==========================================================================
+    const hasNativeTws = store.timestamps["environment.wind.speedTrue"] && (Date.now() - store.timestamps["environment.wind.speedTrue"] < 5000);
+    let tws_water = 0;
+
+    if (hasNativeTws) {
+        // Se la barca invia il TWS nativo, usiamo direttamente quello
+        tws_water = store.raw["environment.wind.speedTrue"] ? msToKts(store.raw["environment.wind.speedTrue"]) : 0;
+    } else {
+        // Altrimenti eseguiamo il calcolo vettoriale tattico sull'acqua
+        tws_water = Math.sqrt(aws * aws + stw * stw - 2 * aws * stw * Math.cos(awa));
+        store.raw["environment.wind.speedTrue"] = tws_water;
+        
+        if (tws_water > 0.05) {
+            const twa = Math.atan2(aws * Math.sin(awa), aws * Math.cos(awa) - stw);
+            store.raw["environment.wind.angleTrueWater"] = twa;
+            safePush(store.smoothBuf.twa, twa, now);
+            safePush(store.longBuf.twa, twa, now);
+        }
     }
-    if (tws_ground > 0.05) {
-        let twd = (hdg + Math.atan2(tw_ground_y, tw_ground_x) + 2 * Math.PI) % (2 * Math.PI);
-        store.raw["environment.wind.directionTrue"] = twd;
-        safePush(store.smoothBuf.twd, twd, now); safePush(store.longBuf.twd, twd, now);
+
+    // ==========================================================================
+    // 2. GESTIONE TWD (NATIVO vs FALLBACK)
+    // ==========================================================================
+    const hasNativeTwd = store.timestamps["environment.wind.directionTrue"] && (Date.now() - store.timestamps["environment.wind.directionTrue"] < 5000);
+
+    if (hasNativeTwd) {
+        // Se il TWD è nativo della centralina, lo lasciamo scorrere passivamente
+    } else {
+        // Altrimenti calcoliamo lo scarroccio e ricaviamo il TWD geografico sul fondo
+        const drift = (cog - hdg + Math.PI * 3) % (2 * Math.PI) - Math.PI;
+        const tw_ground_x = aws * Math.cos(awa) - sog * Math.cos(drift);
+        const tw_ground_y = aws * Math.sin(awa) - sog * Math.sin(drift);
+        const tws_ground = Math.sqrt(tw_ground_x * tw_ground_x + tw_ground_y * tw_ground_y);
+
+        if (tws_ground > 0.05) {
+            let twd = (hdg + Math.atan2(tw_ground_y, tw_ground_x) + 2 * Math.PI) % (2 * Math.PI);
+            store.raw["environment.wind.directionTrue"] = twd;
+            safePush(store.smoothBuf.twd, twd, now);
+            safePush(store.longBuf.twd, twd, now); // Alimenta la bussola meteo strategica!
+        }
     }
 }
 
@@ -436,16 +468,20 @@ function processIncomingData(path, val, source, timeMs) {
 
 // ==========================================================================
 // 6. TREND VENTO (Tattico 2s vs 10s | Strategico 1m vs 10m)
+// Sincronizzato sul tempo reale dei sensori per eliminare i conflitti di orologio.
 // ==========================================================================
 function updateWindTrend() {
-    const now = Date.now();
-
-    // --- 6.1 TREND TATTICO (AWA/TWA) ---
-    const twaNow = getCircularAverageFromBuffer(store.longBuf.twa, 2000, true);
-    const twaRef = getCircularAverageFromBuffer(store.longBuf.twa, 10000, true);
+    // --- RISOLUZIONE CLOCK DRIFT SUI PALLINI METEO ---
+    // Usiamo il tempo del sensore (l'ultimo dato del TWD in memoria) invece dell'orologio del tablet
+    const latestTwdPoint = store.longBuf.twd.length > 0 ? store.longBuf.twd[store.longBuf.twd.length - 1] : null;
+    const now = latestTwdPoint ? latestTwdPoint.time : Date.now();
+
+    // --- 6.1 TREND TATTICO (AWA/TWA Sintonizzato) ---
+    const twaNow = getCircularAverageFromBuffer(store.longBuf.twa, 2000, true, now);
+    const twaRef = getCircularAverageFromBuffer(store.longBuf.twa, 10000, true, now);
     const gaugeDots = { cw: document.getElementById('trend-gauge-cw'), ccw: document.getElementById('trend-gauge-ccw') };
 
-    // --- 6.2 ALLARME STRAMBATA CON ISTERESI (MACCHINA A STATI ANTI-BRANDEGGIO) ---
+    // --- 6.2 ALLARME STRAMBATA CON ISTERESI (MACCHINA A STATI ANTI-BRANDEGGIO Sintonizzato) ---
     const instTwaRad = store.raw["environment.wind.angleTrueWater"];
     let smoothedTwaDeg = null;
 
@@ -530,11 +566,15 @@ function updateWindTrend() {
         }
     }
 
-    // --- 6.3 TREND METEO STRATEGICO (TWD) ---
-    const twdNow = getCircularAverageFromBuffer(store.longBuf.twd, 60000, false);
-    const multiplier = isNavigating ? 1 : 2;
-    const strategicWindowMs = CONFIG.graphs.historyMinutes * 60000 * multiplier;
-    const twdRef = getCircularAverageFromBuffer(store.longBuf.twd, strategicWindowMs, false);
+    // --- 6.3 TREND METEO STRATEGICO (TWD PARAMETRIZZATO E SINTONIZZATO) ---
+    const twdNow = getCircularAverageFromBuffer(store.longBuf.twd, 60000, false, now); // 1 minuto fisso
+
+    // Parametrizzazione rigida nel codice: 15 minuti in navigazione, 60 minuti all'ancora
+    const fixedTwdMinutes = isNavigating ? 15 : 60;
+    const strategicWindowMs = fixedTwdMinutes * 60000;
+
+    const twdRef = getCircularAverageFromBuffer(store.longBuf.twd, strategicWindowMs, false, now);
+
     const compassDots = { cw: document.getElementById('trend-dot-cw'), ccw: document.getElementById('trend-dot-ccw') };
 
     if (twdNow && twdRef) {
@@ -894,11 +934,16 @@ async function fetchServerHistory() {
                 }
             }
             // --- SILLABAZIONE STRATEGICA DELLA BUSSOLA METEO (TWD) ---
-            // Se il server ci invia lo storico del TWD, lo inseriamo direttamente nella memoria a lungo termine
+            // Se il server ci invia lo storico del TWD, lo inseriamo calcolando i seni e coseni per i vettori
             if (data.twd && data.twd.length > 0) {
-                store.longBuf.twd = data.twd;
+                store.longBuf.twd = data.twd.map(p => ({
+                    val: p.val,
+                    time: p.time,
+                    sin: Math.sin(p.val),
+                    cos: Math.cos(p.val)
+                }));
                 console.log(`📈 Memoria strategica TWD sincronizzata dal server (${data.twd.length} punti).`);
-            }
+                }
             console.log("📈 Storico dei grafici pre-popolato caricato dal server.");
         }
     } catch (err) {

package/index.js

@@ -21,6 +21,9 @@ module.exports = function (app) {
       let graphTempBuf = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] };
       let lastUpdates = { stw: 0, sog: 0, depth: 0, tws: 0, vmg: 0, aws: 0, twd: 0 };
       let raw = {};
+    // Memoria temporale per rilevare la presenza di sensori nativi sul Cerbo
+      let lastNativeTwsTime = 0;
+      let lastNativeTwdTime = 0;
 
   /**
    * plugin.start: Inizializza il plugin.
@@ -98,14 +101,17 @@ module.exports = function (app) {
     app.debug(msg);
   };
 
-  /**
+/**
    * processIncomingDelta: Decodifica i dati dei sensori in Knots/Meters ed esegue l'aggregazione
+   * Gestisce l'architettura "Nativo Prima, Fallback Dopo" per il vento reale.
    */
   function processIncomingDelta(path, val) {
     if (val === null || val === undefined) return;
     raw[path] = val;
 
-    // Elaborazione e invio alla macchina a stati temporali dello storico
+    const now = Date.now();
+
+    // 1. Cattura dei dati nativi (Se presenti, li scrive direttamente nello storico)
     if (path === 'navigation.speedThroughWater') {
       manageHistory('stw', val * 1.94384);
     }
@@ -118,8 +124,16 @@ module.exports = function (app) {
     else if (path === 'environment.wind.speedApparent') {
       manageHistory('aws', val * 1.94384);
     }
+    else if (path === 'environment.wind.speedTrue') {
+      lastNativeTwsTime = now; // Rilevato TWS nativo della centralina!
+      manageHistory('tws', val * 1.94384);
+    }
+    else if (path === 'environment.wind.directionTrue') {
+      lastNativeTwdTime = now; // Rilevato TWD nativo della centralina!
+      manageHistory('twd', val);
+    }
 
-    // Calcolo combinato del Vento Reale (TWS) e della VMG a livello Server
+    // 2. Calcolo combinato di FALLBACK (Si attiva solo se la centralina non invia TWS/TWD nativi)
     const aws = raw["environment.wind.speedApparent"];
     const awa = raw["environment.wind.angleApparent"];
     const stw = raw["navigation.speedThroughWater"] || 0;
@@ -128,25 +142,29 @@ module.exports = function (app) {
     const cog = raw["navigation.courseOverGroundTrue"] || 0;
 
     if (aws !== undefined && awa !== undefined) {
-        const awsKts = aws * 1.94384;
-        const stwKts = stw * 1.94384;
-        const tw_water_x = awsKts * Math.cos(awa) - stwKts;
-        const tw_water_y = awsKts * Math.sin(awa);
-        const tws = Math.sqrt(tw_water_x * tw_water_x + tw_water_y * tw_water_y);
+      const awsKts = aws * 1.94384;
+      const stwKts = stw * 1.94384;
+      const tw_water_x = awsKts * Math.cos(awa) - stwKts;
+      const tw_water_y = awsKts * Math.sin(awa);
 
+      // Calcoliamo il TWS di fallback solo se non abbiamo visto dati nativi negli ultimi 5 secondi
+      if (now - lastNativeTwsTime > 5000) {
+        const tws = Math.sqrt(tw_water_x * tw_water_x + tw_water_y * tw_water_y);
         manageHistory('tws', tws);
+      }
 
-        const twa = Math.atan2(tw_water_y, tw_water_x);
-        const vmg = Math.abs(stwKts * Math.cos(twa));
-        manageHistory('vmg', vmg);
-
-        // --- CALCOLO TWD STRATEGICO SERVER-SIDE ---
-        if (hdg !== undefined) {
-          // Calcolo della direzione del vento reale rispetto al nord (TWD) in radianti
-          const twd = (hdg + twa + 2 * Math.PI) % (2 * Math.PI);
-          manageHistory('twd', twd);
-        }
+      const twa = Math.atan2(tw_water_y, tw_water_x);
+      
+      // La VMG viene sempre calcolata a livello server poiché raramente è nativa
+      const vmg = Math.abs(stwKts * Math.cos(twa));
+      manageHistory('vmg', vmg);
+
+      // Calcoliamo il TWD di fallback solo se non abbiamo visto dati nativi negli ultimi 5 secondi
+      if (hdg !== undefined && (now - lastNativeTwdTime > 5000)) {
+        const twd = (hdg + twa + 2 * Math.PI) % (2 * Math.PI);
+        manageHistory('twd', twd);
       }
+    }
   }
 
   /**
@@ -219,16 +237,18 @@ module.exports = function (app) {
     if (!isFinite(finalValue)) return;
     finalValue = Math.max(0, finalValue);
 
-    // Salvataggio nel ring buffer dello storico principale
-    histories[type].push({ val: finalValue, time: now });
+  // Salvataggio nel ring buffer dello storico principale
+      histories[type].push({ val: finalValue, time: now });
 
-    // Pruning automatico basato sulle impostazioni di timeline
-    const maxViewportMinutes = historyMinutes * 2;
-    const maxHistoryMs = (maxViewportMinutes * 60000) + 60000;
+      // Pruning automatico basato sulle impostazioni di timeline
+      // (Forziamo il server a conservare sempre almeno 60 minuti per il TWD!)
+      const limitMinutes = (type === 'twd') ? 60 : historyMinutes;
+      const maxViewportMinutes = limitMinutes * 2;
+      const maxHistoryMs = (maxViewportMinutes * 60000) + 60000;
 
-    while (histories[type].length > 0 && (now - histories[type][0].time) > maxHistoryMs) {
-      histories[type].shift();
-    }
+      while (histories[type].length > 0 && (now - histories[type][0].time) > maxHistoryMs) {
+        histories[type].shift();
+      }
 
   graphTempBuf[type] = [];
       // Spostiamo il timer esattamente al confine del secchiello assoluto appena concluso

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailingrotevista/rotevista-dash",
-  "version": "6.1.1",
+  "version": "6.1.3",
   "description": "Wind Dashboard with navigation and course aids",
   "main": "index.js",
   "publishConfig": {