@sailingrotevista/rotevista-dash 6.1.4 → 6.2.2

package/app.js

@@ -79,7 +79,7 @@ const store = {
     herculesScales: {},          // Memoria per i limiti attivi della modalità Hercules
     smoothBuf: { hdg: [], cog: [], awa: [], twa: [], twd: [] },
     longBuf: { hdg: [], cog: [], awa: [], twa: [], twd: [] },
-    histories: { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [] },
+    histories: { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] },
     graphTempBuf: { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [] },
     lastUpdates: { stw: 0, sog: 0, depth: 0, tws: 0, vmg: 0, aws: 0 }
 };
@@ -121,8 +121,12 @@ function getShortestRotation(curr, target) {
  */
 function safeSetText(el, text) {
     if (!el) return;
-    if (el.innerHTML !== text) {
-        el.innerHTML = text;
+    // Se l'elemento è parte di un SVG, usiamo textContent, altrimenti innerHTML
+    const isSVG = el instanceof SVGElement;
+    if (isSVG) {
+        if (el.textContent !== text) el.textContent = text;
+    } else {
+        if (el.innerHTML !== text) el.innerHTML = text;
     }
 }
 
@@ -182,7 +186,8 @@ function getCircularAverageFromBuffer(bufferArray, windowMs, signed = false, now
             const clampedDiff = Math.sign(diffRad) * limitRad;
             const clampedRad = pilotRad + clampedDiff;
             finalSin = Math.sin(clampedRad);
-            finalCos = Math.cos(clampedRad);
+            const relativeCos = Math.cos(clampedRad);
+            finalCos = relativeCos;
         } else {
             finalSin = item.sin;
             finalCos = item.cos;
@@ -343,13 +348,14 @@ function computeTrueWind() {
         // 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);
-        }
+    }
+    
+    // BUG RISOLTO: Calcoliamo il TWA sempre, indipendentemente dal TWS nativo!
+    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);
     }
 
     // ==========================================================================
@@ -441,6 +447,19 @@ function processIncomingData(path, val, source, timeMs) {
         safePush(store.smoothBuf.awa, val, now);
         safePush(store.longBuf.awa, val, now);
     }
+
+    // BUG RISOLTO: Intercetta il TWD nativo e lo spinge nei buffer della bussola radar
+    if (path === "environment.wind.directionTrue") {
+        let directionVal = (val && typeof val === 'object' && val.val !== undefined) ? val.val : val;
+        safePush(store.smoothBuf.twd, directionVal, now);
+        safePush(store.longBuf.twd, directionVal, now);
+    }
+
+    // BUG RISOLTO: Intercetta il TWS nativo e lo memorizza in tempo reale
+    if (path === "environment.wind.speedTrue") {
+        let speedVal = (val && typeof val === 'object' && val.val !== undefined) ? val.val : val;
+        store.raw["environment.wind.speedTrue"] = speedVal;
+    }
     
     // --- GESTIONE PRUA VERA / MAGNETICA CON AUTODIVIAZIONE ---
     if (path === "navigation.headingTrue") {
@@ -713,7 +732,7 @@ function startDisplayLoop() {
                     else if (drift > 0.3) ui.sog.style.setProperty('color', '#00C851', 'important'); // Favore
                     else ui.sog.style.setProperty('color', '#ffbb33', 'important'); // Neutro SOG
                 } else {
-                    ui.sog.style.color = "";
+                    ui.sog.style.removeProperty('color');
                 }
             }
         }
@@ -1274,7 +1293,7 @@ function drawGraph(d, id, min, max, isTws, isHercules) {
     if (visibleData.length < 2) return;
 
     const colDanger  = "#ff3b30", colWarning = "#ff9800", colTws = "#2c3e50", colAws = "#5c6bc0";
-    const colDepth   = "#0088cc", colStw = "#00C851", colSog = "#ffbb33", colVmg = "#00b8d4";
+    const colDepth   = "#0088cc", colStw = "#00C851", colStwBorder = "#007a3d", colSog = "#ffbb33", colVmg = "#00b8d4";
 
     const getColorProps = (val) => {
         // Se siamo in Dual Screen (focus), aumentiamo lo spessore base della curva di un filino (da 1.6 a 2.2)
@@ -1589,6 +1608,27 @@ async function init() {
     }
 }
 
+// Watchdog per il risveglio dallo stato di sospensione / cambio scheda
+document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') {
+        console.log("🔌 [Watchdog] Tab ritornato visibile. Verifica connessione...");
+        
+        // Se il socket esiste ma non è attivo o se vogliamo forzare la pulizia delle connessioni fantasma:
+        if (socket) {
+            if (socket.readyState !== WebSocket.OPEN) {
+                // Se era già chiuso o in errore, proviamo a riconnettere subito
+                connect();
+            } else {
+                // Se risulta "OPEN" ma potrebbe essere una connessione fantasma,
+                // la chiudiamo forzatamente per scatenare la riconnessione pulita e il download della cronologia
+                console.log("🔌 [Watchdog] Riavvio precauzionale del WebSocket per evitare connessioni fantasma.");
+                socket.close();
+            }
+        } else {
+            connect();
+        }
+    }
+});
 
 window.addEventListener('load', init);
 window.addEventListener('pagehide', saveDashboardState);

package/index.html

@@ -12,7 +12,6 @@
         
         <!-- Icona per Bookmark e schermata Home su Apple iPad, iPhone e Mac -->
         <link rel="apple-touch-icon" href="icons/dash.png">
-        
         <title>Sailing Dashboard Pro</title>
         <link rel="stylesheet" href="style.css">
     </head>

package/index.js

@@ -5,6 +5,7 @@
  * Definisce l'interfaccia di configurazione in Signal K Admin e crea
  * gli endpoint pubblici per la Dashboard, mantenendo lo storico in RAM.
  */
+const https = require('https'); // Importazione del modulo HTTPS nativo di Node.js
 
 module.exports = function (app) {
   const plugin = {};
@@ -16,43 +17,70 @@ module.exports = function (app) {
   let routeRegistered = false;
   let unsubscribes = [];
 
-    // Database dello storico in RAM sul server (Sintonizzato Pro v6.0)
-      let histories = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] };
-      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;
+  // ==========================================================================
+  // COSTANTI DI SVILUPPO (DEVELOPER CONFIG)
+  // ==========================================================================
+  const CALM_THRESHOLD_KTS = 1.5;      // Soglia di calma piatta (anello a 360°)
+  const PRESSURE_FILTER_RATIO = 0.40;  // Filtro di pressione dinamico (40% del picco per ignorare i cali)
+
+  // Database dello storico in RAM sul server (Sintonizzato Pro v6.0)
+  let histories = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] };
+  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 = {};
+  
+  // Nuovo database dedicato per gli archi storici della bussola (6 ore = 12 slot)
+  let windRadarSlots = [];
+  
+  // Memoria temporale per rilevare la presenza di sensori nativi sul Cerbo
+  let lastNativeTwsTime = 0;
+  let lastNativeTwdTime = 0;
+  
+  // Monitoraggio dello scorrere dei blocchi da 30 minuti
+  let lastFrozen30mSlot = 0;
+  
+  // Variabili dedicate al recupero e calcolo previsioni meteo future
+  let futureForecast = null;       // Memorizza la previsione futura { timestamp, tws, twd }
+  let lastForecast30mSlot = 0;    // Orario dell'ultimo blocco orologio scaricato con successo (es. 15:30)
 
   /**
    * plugin.start: Inizializza il plugin.
-   * Viene chiamato all'avvio e OGNI VOLTA che clicchi "Save" nelle impostazioni.
+   * Viene chiamato all'avvio e OGNI VOLTA che si salva nella configurazione.
    */
   plugin.start = function (options) {
     // 1. Aggiorna la configurazione in memoria
     currentConfig = options;
     app.debug(`${plugin.name} started/updated with new options`);
 
-  // Reset dello storico al riavvio del plugin per evitare incoerenze (Sintonizzato Pro v6.0)
-      histories = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] };
-      graphTempBuf = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] };
-      lastUpdates = { stw: 0, sog: 0, depth: 0, tws: 0, vmg: 0, aws: 0, twd: 0 };
-      raw = {};
-
-  // 2. Registra le rotte API solo la prima volta (Abilitate per CORS remoto)
-      if (!routeRegistered) {
-        app.get('/rotevista-config', (req, res) => {
-          res.header("Access-Control-Allow-Origin", "*"); // Sblocca la Dashboard locale su Mac
-          res.json(currentConfig);
-        });
-        app.get('/rotevista-history', (req, res) => {
-          res.header("Access-Control-Allow-Origin", "*"); // Sblocca la Dashboard locale su Mac
-          res.json(histories);
-        });
-        routeRegistered = true;
-        app.debug('Public API endpoints registered at /rotevista-config and /rotevista-history');
-      }
+    // Reset dello storico al riavvio del plugin per evitare incoerenze (Sintonizzato Pro v6.0)
+    histories = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] };
+    graphTempBuf = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [], twd: [] };
+    lastUpdates = { stw: 0, sog: 0, depth: 0, tws: 0, vmg: 0, aws: 0, twd: 0 };
+    raw = {};
+    windRadarSlots = [];        // Reset degli archi storici della bussola
+    lastFrozen30mSlot = 0;      // Reset del monitor temporale della bussola
+    futureForecast = null;      // Reset della previsione meteo futura
+    lastForecast30mSlot = 0;    // Reset del monitor temporale di scaricamento meteo
+      
+    // 2. Registra le rotte API solo la prima volta (Abilitate per CORS remoto)
+    if (!routeRegistered) {
+      app.get('/rotevista-config', (req, res) => {
+        res.header("Access-Control-Allow-Origin", "*"); // Sblocca la Dashboard locale su Mac
+        res.json(currentConfig);
+      });
+      app.get('/rotevista-history', (req, res) => {
+        res.header("Access-Control-Allow-Origin", "*"); // Sblocca la Dashboard locale su Mac
+        // Costruiamo un pacchetto unificato che unisce i grafici classici, i dati radar e il futuro
+        const responseData = {
+          ...histories,
+          windRadarSlots: windRadarSlots,
+          futureForecast: futureForecast
+        };
+        res.json(responseData);
+      });
+      routeRegistered = true;
+      app.debug('Public API endpoints registered at /rotevista-config and /rotevista-history');
+    }
 
     // 3. Iscrizione ai dati dei sensori di bordo tramite Signal K
     const localSubscription = {
@@ -63,6 +91,8 @@ module.exports = function (app) {
         { path: 'environment.depth.belowTransducer' },
         { path: 'environment.wind.speedApparent' },
         { path: 'environment.wind.angleApparent' },
+        { path: 'environment.wind.speedTrue' },      // Aggiunto chirurgicamente
+        { path: 'environment.wind.directionTrue' },  // Aggiunto chirurgicamente
         { path: 'navigation.headingTrue' },
         { path: 'navigation.headingMagnetic' },
         { path: 'navigation.magneticVariation' },
@@ -103,7 +133,7 @@ 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.
    */
@@ -114,7 +144,17 @@ module.exports = function (app) {
     const now = Date.now();
 
     // 1. Cattura dei dati nativi (Se presenti, li scrive direttamente nello storico)
-    if (path === 'navigation.speedThroughWater') {
+    if (path === 'navigation.position') {
+      // Trigger allineato all'orologio: calcoliamo il confine della mezz'ora corrente dell'orologio
+      if (val && val.latitude !== undefined && val.longitude !== undefined) {
+        const current30mSlot = Math.floor(Date.now() / 1800000) * 1800000;
+        // Se siamo entrati in una nuova mezz'ora di orologio dall'ultimo download, avviamo il fetch
+        if (current30mSlot > lastForecast30mSlot) {
+          fetchOpenMeteoForecast(val, current30mSlot);
+        }
+      }
+    }
+    else if (path === 'navigation.speedThroughWater') {
       manageHistory('stw', val * 1.94384);
     }
     else if (path === 'navigation.speedOverGround') {
@@ -126,6 +166,9 @@ module.exports = function (app) {
     else if (path === 'environment.wind.speedApparent') {
       manageHistory('aws', val * 1.94384);
     }
+    else if (path === 'environment.wind.angleApparent') {
+      raw[path] = val; // BUG RISOLTO: Acquisizione dell'AWA mancante inserita!
+    }
     else if (path === 'environment.wind.speedTrue') {
       lastNativeTwsTime = now; // Rilevato TWS nativo della centralina!
       manageHistory('tws', val * 1.94384);
@@ -172,6 +215,7 @@ module.exports = function (app) {
       // 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);
+        twd = (twd + 2 * Math.PI) % (2 * Math.PI); // Sicurezza extra
         manageHistory('twd', twd);
       }
     }
@@ -188,15 +232,15 @@ module.exports = function (app) {
     const samples = 60;
     const bucketIntervalMs = (historyMinutes * 60000) / samples;
 
-      if (!graphTempBuf[type]) graphTempBuf[type] = [];
-      if (!histories[type]) histories[type] = [];
+    if (!graphTempBuf[type]) graphTempBuf[type] = [];
+    if (!histories[type]) histories[type] = [];
       
-      // SINTONIZZAZIONE DI FASE LATO SERVER (UTC Snap)
-      if (lastUpdates[type] === undefined || lastUpdates[type] === 0) {
-        lastUpdates[type] = Math.floor(now / bucketIntervalMs) * bucketIntervalMs;
-      }
+    // SINTONIZZAZIONE DI FASE LATO SERVER (UTC Snap)
+    if (lastUpdates[type] === undefined || lastUpdates[type] === 0) {
+      lastUpdates[type] = Math.floor(now / bucketIntervalMs) * bucketIntervalMs;
+    }
 
-      const tempBuf = graphTempBuf[type];
+    const tempBuf = graphTempBuf[type];
 
     // Anti-dropout dinamico sul vento forte
     if ((type === 'tws' || type === 'aws') && value < 0.05 && tempBuf.length > 0) {
@@ -206,17 +250,67 @@ module.exports = function (app) {
       if (lastPoint && lastPoint.val > glitchThreshold) return;
     }
 
-    tempBuf.push({ val: value, time: now });
+    // Cattura la velocità del vento corrente (in m/s) al momento della lettura
+    const currentTws = raw['environment.wind.speedTrue'] || 0;
+    tempBuf.push({ val: value, tws: currentTws, time: now });
 
     // Controllo avanzamento del secchiello temporale (Bucket)
     const bucketReady = (now - lastUpdates[type] > bucketIntervalMs) || histories[type].length === 0;
     if (!bucketReady) return;
 
     let finalValue = value;
+    let isTwdType = (type === 'twd');
 
     if (tempBuf.length > 0) {
-      // A. VENTO -> SUSTAINED PEAK (EMA Time-Aware)
-      if (type === 'tws' || type === 'aws') {
+      // ==========================================================================
+      // CASO PARTICOLARE: DIREZIONE VENTO (TWD) -> MEDIA PESATA E LIMITI MIN/MAX
+      // ==========================================================================
+      if (isTwdType) {
+        // 1. Identifica il vento massimo del minuto (in m/s)
+        const twsVals = tempBuf.map(p => p.tws || 0);
+        const maxTwsInMinute = Math.max(...twsVals, 0);
+
+        // 2. Calcola la soglia dinamica di pressione: max tra 40% del picco e soglia di calma piatta (in m/s)
+        const calmThresholdMs = CALM_THRESHOLD_KTS / 1.94384;
+        const pressureThreshold = Math.max(maxTwsInMinute * PRESSURE_FILTER_RATIO, calmThresholdMs);
+
+        // 3. Esclude le direzioni registrate quando il vento era debole (sotto la soglia di pressione)
+        const activePoints = tempBuf.filter(p => (p.tws || 0) >= pressureThreshold);
+        const pointsToUse = activePoints.length > 0 ? activePoints : tempBuf; // Fallback se tutto è calma piatta
+
+        // 4. Media Vettoriale Pesata (TWS * sin, TWS * cos)
+        let sumSin = 0;
+        let sumCos = 0;
+        let totalWeight = 0;
+        pointsToUse.forEach(p => {
+          const weight = Math.max(p.tws || 0.1, 0.05); // Evita pesi a zero
+          sumSin += weight * Math.sin(p.val);
+          sumCos += weight * Math.cos(p.val);
+          totalWeight += weight;
+        });
+        const avgAngle = Math.atan2(sumSin, sumCos);
+        const finalAvg = (avgAngle + Math.PI * 2) % (Math.PI * 2);
+
+        // 5. Calcolo di Min e Max angolare del minuto (rispetto alla media per gestire l'oltrepasso di 0/360°)
+        let diffs = pointsToUse.map(p => {
+          let diff = p.val - finalAvg;
+          return Math.atan2(Math.sin(diff), Math.cos(diff)); // Srotolamento tra -PI e +PI
+        });
+
+        const minDiff = Math.min(...diffs);
+        const maxDiff = Math.max(...diffs);
+
+        const finalMin = (finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2);
+        const finalMax = (finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2);
+
+        finalValue = {
+          val: finalAvg,
+          min: finalMin,
+          max: finalMax
+        };
+      }
+      // A. VENTO VELOCITÀ -> SUSTAINED PEAK (EMA Time-Aware)
+      else if (type === 'tws' || type === 'aws') {
         const tauMs = 2500;
         let ema = tempBuf[0].val;
         let maxSustained = ema;
@@ -234,7 +328,7 @@ module.exports = function (app) {
         const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
         if (vals.length > 0) finalValue = Math.min(...vals);
       }
-      // C. VELOCITÀ -> MEDIA
+      // C. VELOCITÀ BARCA / ALTRO -> MEDIA
       else {
         const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
         if (vals.length > 0) {
@@ -244,27 +338,47 @@ module.exports = function (app) {
       }
     }
 
-    if (!isFinite(finalValue)) return;
-    finalValue = Math.max(0, finalValue);
-
-  // Salvataggio nel ring buffer dello storico principale
+    // Validazione e clamping di sicurezza (non si applica all'oggetto TWD)
+    if (!isTwdType) {
+      if (!isFinite(finalValue)) return;
+      finalValue = Math.max(0, finalValue);
       histories[type].push({ val: finalValue, time: now });
-
-      // 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();
+    } else {
+      // Salvataggio specifico del TWD contenente l'oggetto { val, min, max, time }
+      histories['twd'].push({
+        val: finalValue.val,
+        min: finalValue.min,
+        max: finalValue.max,
+        time: now
+      });
+
+      // --- TRIGGER DI CONGELAMENTO ARCO (Ogni :00 e :30 dell'orologio) ---
+      const current30mSlot = Math.floor(now / 1800000) * 1800000;
+      if (lastFrozen30mSlot === 0) {
+        lastFrozen30mSlot = current30mSlot; // Inizializzazione al primo avvio
+      } else if (current30mSlot > lastFrozen30mSlot) {
+        // Lo slot da 30 minuti precedente (lastFrozen30mSlot) si è appena concluso!
+        // Avviamo la procedura di compressione e congelamento dei dati di quel periodo
+        freeze30mSlot(lastFrozen30mSlot);
+        lastFrozen30mSlot = current30mSlot;
       }
+    }
 
-  graphTempBuf[type] = [];
-      // Spostiamo il timer esattamente al confine del secchiello assoluto appena concluso
-      lastUpdates[type] = Math.floor(now / bucketIntervalMs) * bucketIntervalMs;
+    // 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();
     }
 
+    graphTempBuf[type] = [];
+    // Spostiamo il timer esattamente al confine del secchiello assoluto appena concluso
+    lastUpdates[type] = Math.floor(now / bucketIntervalMs) * bucketIntervalMs;
+  }
+
   /**
    * plugin.schema: Definisce l'interfaccia grafica in Signal K Admin.
    */
@@ -427,6 +541,195 @@ module.exports = function (app) {
       }
     }
   };
+    
+  /**
+   * freeze30mSlot: Consolida e congela i dati di una specifica mezz'ora.
+   * Raccoglie i 30 record da 1 minuto, estrae i picchi, unisce gli angoli
+   * e applica la scrematura del percentile al 5% prima di salvare lo slot.
+   */
+  function freeze30mSlot(slotTimestamp) {
+    const startTime = slotTimestamp;
+    const endTime = slotTimestamp + 1800000; // 30 minuti in millisecondi
+
+    // 1. Estrae i record storici del TWD e del TWS che ricadono in quella mezz'ora
+    const twdPoints = histories['twd'].filter(p => p.time >= startTime && p.time < endTime);
+    const twsPoints = histories['tws'].filter(p => p.time >= startTime && p.time < endTime);
+
+    if (twdPoints.length === 0) return; // Se non ci sono dati, salta lo slot
+
+    // 2. Calcola il vento massimo sostenuto (in nodi) registrato nel periodo
+    const twsVals = twsPoints.map(p => p.val).filter(v => isFinite(v));
+    const maxTws = twsVals.length > 0 ? Math.max(...twsVals) : 0;
+
+    // 3. Estrae tutti gli estremi angolari catturati minuto per minuto
+    let allAngles = [];
+    twdPoints.forEach(p => {
+      allAngles.push(p.val);
+      allAngles.push(p.min);
+      allAngles.push(p.max);
+    });
+
+    // 4. Calcola la direzione media vettoriale complessiva della mezz'ora per srotolare gli angoli
+    let sumSin = 0;
+    let sumCos = 0;
+    allAngles.forEach(a => {
+      sumSin += Math.sin(a);
+      sumCos += Math.cos(a);
+    });
+    const avgAngle = Math.atan2(sumSin, sumCos);
+    const finalAvg = (avgAngle + Math.PI * 2) % (Math.PI * 2);
+
+    // 5. Srotola gli angoli rispetto alla direzione media per gestire l'oltrepasso dello 0/360°
+    let diffs = allAngles.map(a => {
+      let diff = a - finalAvg;
+      return Math.atan2(Math.sin(diff), Math.cos(diff)); // Mappa tra -PI e +PI
+    });
+
+    // 6. ORDINA LE DIFFERENZE ED APPLICA IL TAGLIO PERCENTILE DEL 5% PER LATO (TRIM)
+    diffs.sort((a, b) => a - b);
+    const trimCount = Math.floor(diffs.length * 0.05); // Scarta il 5% dei disturbi a sinistra e a destra
+    const activeDiffs = diffs.slice(trimCount, diffs.length - trimCount);
+
+    // Fallback se ci sono pochissimi campioni
+    const finalDiffs = activeDiffs.length > 0 ? activeDiffs : diffs;
+
+    const minDiff = Math.min(...finalDiffs);
+    const maxDiff = Math.max(...finalDiffs);
+
+    const finalMin = (finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2);
+    const finalMax = (finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2);
+
+    // 7. Salva l'arco compresso e pulito nello store dedicato
+    windRadarSlots.push({
+      timestamp: startTime,
+      twdMin: finalMin,
+      twdMax: finalMax,
+      twsPeak: maxTws
+    });
+
+    // Pruning: manteniamo in RAM solo le ultime 6 ore (12 slot)
+    while (windRadarSlots.length > 12) {
+      windRadarSlots.shift();
+    }
+
+    app.debug(`💨 [Wind Radar] Locked 30m slot at ${new Date(startTime).toLocaleTimeString()}: TWD ${Math.round(finalMin * 180 / Math.PI)}°-${Math.round(finalMax * 180 / Math.PI)}°, TWS Peak ${maxTws.toFixed(1)} kts`);
+  }
+
+  /**
+   * fetchOpenMeteoForecast: Recupera le previsioni orarie accoppiate (Seamless) da Open-Meteo.
+   * Utilizza il modello integrato /forecast per evitare zone d'ombra in rada, con tempo forzato in UTC.
+   */
+  function fetchOpenMeteoForecast(position, current30mSlot) {
+    if (!position || position.latitude === undefined || position.longitude === undefined) return;
+
+    const lat = position.latitude;
+    const lon = position.longitude;
+    
+    // Modello accoppiato Seamless basato su forecast, con vento espresso in nodi e orario in UTC (GMT)
+    const url = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&hourly=wind_speed_10m,wind_direction_10m&wind_speed_unit=kn&timezone=GMT&forecast_days=2`;
+
+    lastForecast30mSlot = current30mSlot; // Aggiorna preventivamente lo slot per evitare chiamate simultanee in caso di rallentamento di rete
+
+    https.get(url, (res) => {
+      if (res.statusCode !== 200) {
+        app.error(`[Open-Meteo] HTTP Error: ${res.statusCode}`);
+        lastForecast30mSlot = 0; // Reset in caso di errore per permettere un tentativo al prossimo pacchetto GPS
+        return;
+      }
+
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (!parsed.hourly || !parsed.hourly.time) {
+            app.error('[Open-Meteo] Invalid API response format');
+            lastForecast30mSlot = 0;
+            return;
+          }
+
+          const times = parsed.hourly.time;
+          const speeds = parsed.hourly.wind_speed_10m;
+          const directions = parsed.hourly.wind_direction_10m;
+
+          // Costruiamo la serie storica delle previsioni in formato UTC
+          const forecastList = [];
+          for (let i = 0; i < times.length; i++) {
+            // Forziamo il parsing UTC aggiungendo la dicitura 'Z' alla stringa ISO prodotta da Open-Meteo
+            const epoch = Date.parse(times[i] + "Z");
+            if (isNaN(epoch)) continue;
+
+            // Convertiamo la direzione del vento da gradi (0-360) a radianti (0-2PI)
+            const twdRad = (directions[i] * Math.PI) / 180;
+
+            forecastList.push({
+              time: epoch,
+              tws: speeds[i], // Già in nodi grazie ai parametri della chiamata
+              twd: twdRad
+            });
+          }
+
+          // Calcola l'interpolazione per la mezz'ora futura basandosi sullo slot corrente dell'orologio
+          calculateInterpolatedFuture(forecastList);
 
+        } catch (err) {
+          app.error(`[Open-Meteo] Error parsing JSON: ${err.message}`);
+          lastForecast30mSlot = 0;
+        }
+      });
+    }).on('error', (err) => {
+      app.error(`[Open-Meteo] Network Error: ${err.message}`);
+      lastForecast30mSlot = 0;
+    });
+  }
+
+  /**
+   * calculateInterpolatedFuture: Esegue l'interpolazione lineare e vettoriale circolare
+   * per trovare la previsione del vento tra 30 minuti esatti.
+   */
+  function calculateInterpolatedFuture(forecastList) {
+    if (forecastList.length < 2) return;
+
+    const now = Date.now();
+    const targetTime = now + 1800000; // Calcoliamo la proiezione a +30 minuti nel futuro
+
+    let s1 = null;
+    let s2 = null;
+
+    // Individuiamo i due segmenti orari che racchiudono la nostra mezz'ora futura
+    for (let i = 0; i < forecastList.length; i++) {
+      const f = forecastList[i];
+      if (f.time <= targetTime) {
+        s1 = f;
+      }
+      if (f.time > targetTime) {
+        s2 = f;
+        break; // Trovato il limite superiore, usciamo
+      }
+    }
+
+    if (s1 && s2) {
+      const ratio = (targetTime - s1.time) / (s2.time - s1.time);
+
+      // 1. Interpolazione Lineare Velocità (TWS)
+      const interpolatedTws = s1.tws + (s2.tws - s1.tws) * ratio;
+
+      // 2. Interpolazione Circolare Vettoriale Direzione (TWD) per evitare l'effetto sfasamento a 0/360°
+      const diff = Math.atan2(Math.sin(s2.twd - s1.twd), Math.cos(s2.twd - s1.twd));
+      const interpolatedTwd = (s1.twd + diff * ratio + Math.PI * 2) % (Math.PI * 2);
+
+      // Salviamo le previsioni future nel server
+      futureForecast = {
+        timestamp: targetTime,
+        tws: interpolatedTws,
+        twd: interpolatedTwd
+      };
+
+      app.debug(`🔮 [Open-Meteo] Target forecast interpolated for ${new Date(targetTime).toLocaleTimeString()}: TWD ${Math.round(interpolatedTwd * 180 / Math.PI)}°, TWS ${interpolatedTws.toFixed(1)} kts`);
+    } else {
+      app.error('[Open-Meteo] Forecast matching slots not found for target time');
+    }
+  }
+    
   return plugin;
 };

package/package.json

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