@sailingrotevista/rotevista-dash 6.1.4 → 6.2.3

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,61 @@ module.exports = function (app) {
       }
     }
 
-    if (!isFinite(finalValue)) return;
-    finalValue = Math.max(0, finalValue);
+      // 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 });
 
-  // Salvataggio nel ring buffer dello storico principale
-      histories[type].push({ val: finalValue, time: now });
+            // EMISSIONE DEL DELTA: Se abbiamo calcolato il TWS di fallback, lo trasmettiamo a Signal K
+            if (type === 'tws' && (now - lastNativeTwsTime > 5000)) {
+              emitDelta('environment.wind.speedTrue', finalValue / 1.94384); // Converte nodi in m/s
+            }
+          } 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
+            });
+
+            // EMISSIONE DEL DELTA: Se abbiamo calcolato il TWD di fallback, lo trasmettiamo a Signal K
+            if (now - lastNativeTwdTime > 5000) {
+              emitDelta('environment.wind.directionTrue', {
+                val: finalValue.val,
+                min: finalValue.min,
+                max: finalValue.max
+              });
+            }
 
-      // 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;
+            // --- 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;
+            }
+          }
 
-      while (histories[type].length > 0 && (now - histories[type][0].time) > maxHistoryMs) {
-        histories[type].shift();
-      }
+    // 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;
 
-  graphTempBuf[type] = [];
-      // Spostiamo il timer esattamente al confine del secchiello assoluto appena concluso
-      lastUpdates[type] = Math.floor(now / bucketIntervalMs) * bucketIntervalMs;
+    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 +555,218 @@ 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');
+    }
+  }
+    /**
+       * emitDelta: Scrive ed emette un aggiornamento di rotta direttamente nel
+       * server principale di Signal K per renderlo disponibile a tutti i client WebSocket.
+       */
+      function emitDelta(path, value) {
+        if (typeof app.handleMessage === 'function') {
+          app.handleMessage(plugin.id, {
+            updates: [
+              {
+                source: { label: 'rotevista-dash-plugin' },
+                timestamp: new Date().toISOString(),
+                values: [
+                  {
+                    path: path,
+                    value: value
+                  }
+                ]
+              }
+            ]
+          });
+        }
+      }
+    
+    
   return plugin;
 };

package/package.json

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