@sailingrotevista/rotevista-dash 7.0.29 → 7.0.31

package/app.js

@@ -348,15 +348,17 @@ function processIncomingData(path, val, source, timeMs) {
     } else {
         const currentLock = sourceLocks[path];
         const isSameSource = (currentLock.label === source);
-        const isLockExpired = (now - currentLock.lastSeen > 12000); // Scadenza a 12 secondi per tollerare il GPS dello Yacht Devices
+        const isLockExpired = (now - currentLock.lastSeen > 12000); // Scadenza a 12 secondi
         const hasHigherPriority = (score > currentLock.score);
+        // Consente lo switch tra dispositivi di pari priorità (es. AP e YD) se la sorgente precedente è inattiva da > 1.5s
+        const isSamePriorityStale = (score === currentLock.score && (now - currentLock.lastSeen > 1500));
 
         if (isSameSource) {
             // Stessa sorgente: aggiorna il timestamp e mantiene il blocco
             currentLock.lastSeen = now;
             currentLock.score = score;
-        } else if (isLockExpired || hasHigherPriority) {
-            // Ruba il blocco se la sorgente precedente è scaduta o se questa ha priorità superiore
+        } else if (isLockExpired || hasHigherPriority || isSamePriorityStale) {
+            // Ruba il blocco se la sorgente precedente è scaduta, ha priorità superiore o è inattiva da 1.5s a pari priorità
             sourceLocks[path] = { label: source, score: score, lastSeen: now };
             console.log(`🔌 [Smart Lock] Path "${path}" switched to: ${source} (Score: ${score})`);
         } else {
@@ -410,19 +412,21 @@ function processIncomingData(path, val, source, timeMs) {
     
     // --- GESTIONE PRUA VERA / MAGNETICA CON AUTODIVIAZIONE ---
     if (path === "navigation.headingTrue") {
+        store.timestamps["navigation.headingTrueNative"] = now; // Marca la presenza di un sensore nativo di prua vera
+        store.timestamps["navigation.headingTrue"] = now;
         safePush(store.smoothBuf.hdg, val, now);
         safePush(store.longBuf.hdg, val, now);
     }
     else if (path === "navigation.headingMagnetic") {
-        // Se non abbiamo ricevuto una prua vera negli ultimi 5 secondi, convertiamo quella magnetica!
-        const hasTrueHdg = store.timestamps["navigation.headingTrue"] && (now - store.timestamps["navigation.headingTrue"] < 5000);
-        if (!hasTrueHdg) {
+        // Se non c'è una prua vera NATIVA negli ultimi 5 secondi, converte e registra ad ogni secondo la prua magnetica
+        const hasNativeTrueHdg = store.timestamps["navigation.headingTrueNative"] && (now - store.timestamps["navigation.headingTrueNative"] < 5000);
+        if (!hasNativeTrueHdg) {
             const variation = store.raw["navigation.magneticVariation"] || 0; // Legge la declinazione magnetica del GPS
             const calculatedTrueHdg = (val + variation + 2 * Math.PI) % (2 * Math.PI);
             
-            // Registriamo il valore calcolato come Prua Vera temporanea e aggiorniamo il timestamp per evitare i timeout del watchdog
+            // Registra il valore calcolato mantenendo attivo il watchdog senza bloccare i successivi pacchetti magnetici
             store.raw["navigation.headingTrue"] = calculatedTrueHdg;
-            store.timestamps["navigation.headingTrue"] = now; // (AGGIUNTO - RISOLVE IL LOCKOUT)
+            store.timestamps["navigation.headingTrue"] = now;
             safePush(store.smoothBuf.hdg, calculatedTrueHdg, now);
             safePush(store.longBuf.hdg, calculatedTrueHdg, now);
         }

package/gauge.js

@@ -55,10 +55,10 @@ function updateCentralGauge(store, ui, now, isNavigating, sogKts, stwKts, rawAws
     }
 
     // B. Rotazione dei puntatori analogici di AWA (Apparent) e TWA (True)
-    const smAwa = getCircularAverageFromBuffer(store.smoothBuf.awa, 2000, true);
-    const smTwa = getCircularAverageFromBuffer(store.smoothBuf.twa, 2000, true);
-    if (smAwa) ui.awa.setAttribute('transform', `rotate(${curAwaRot = getShortestRotation(curAwaRot, radToDeg(smAwa.val))}, 200, 200)`);
-    if (smTwa) ui.twa.setAttribute('transform', `rotate(${curTwaRot = getShortestRotation(curTwaRot, radToDeg(smTwa.val))}, 200, 200)`);
+        const smAwa = getCircularAverageFromBuffer(store.smoothBuf.awa, 2000, true);
+        const smTwa = getCircularAverageFromBuffer(store.smoothBuf.twa, 2000, true);
+        if (smAwa) ui.awa.setAttribute('transform', `rotate(${curAwaRot = getShortestRotation(curAwaRot, radToDeg(smAwa.val))}, 200, 200)`);
+        if (smTwa) ui.twa.setAttribute('transform', `rotate(${curTwaRot = getShortestRotation(curTwaRot, radToDeg(smTwa.val))}, 200, 200)`);
     
     // C. Calcolo dello Scarroccio (Leeway) e orientamento del vettore Track
     if (store.raw["navigation.courseOverGroundTrue"] !== undefined && store.raw["navigation.headingTrue"] !== undefined) {

package/index.js

@@ -38,6 +38,7 @@ module.exports = function (app) {
     // Memoria temporale per rilevare la presenza di sensori nativi sul Cerbo
     let lastNativeTwsTime = 0;
     let lastNativeTwdTime = 0;
+    let lastNativeHeadingTrueTime = 0; // Traccia la presenza di bussola vera nativa
     
     // Monitoraggio dello scorrere dei blocchi da 30 minuti
     let lastFrozen30mSlot = 0;
@@ -248,10 +249,14 @@ module.exports = function (app) {
             lastNativeTwsTime = now; // Rilevato TWS nativo della centralina!
             manageHistory('tws', smoothedVal * 1.94384);
         }
+        else if (path === 'navigation.headingTrue') {
+            lastNativeHeadingTrueTime = now; // Rilevata prua vera nativa dalla rete NMEA
+        }
         // --- DECODIFICA PRUA MAGNETICA SERVER-SIDE ---
         else if (path === 'navigation.headingMagnetic') {
-            const hasTrueHdg = raw['navigation.headingTrue'] !== undefined;
-            if (!hasTrueHdg) {
+            // Converte in prua vera solo se non c'è una bussola vera nativa attiva negli ultimi 5s
+            const hasNativeTrueHdg = (now - lastNativeHeadingTrueTime < 5000);
+            if (!hasNativeTrueHdg) {
                 const variation = raw['navigation.magneticVariation'] || 0;
                 raw['navigation.headingTrue'] = (smoothedVal + variation + 2 * Math.PI) % (2 * Math.PI);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailingrotevista/rotevista-dash",
-  "version": "7.0.29",
+  "version": "7.0.31",
   "description": "Wind Dashboard with navigation and course aids",
   "main": "index.js",
   "publishConfig": {
@@ -13,6 +13,7 @@
   "author": "Sailing Rotevista",
   "license": "MIT",
   "signalk": {
-    "displayName": "Rotevista Wind Dashboard"
+    "displayName": "Rotevista Wind Dashboard",
+    "appIcon": "icons/dash.png"
   }
 }

package/style.css

@@ -612,3 +612,29 @@ body.night-mode {
 }
 
 */
+
+/* ==========================================================================
+   14. POSIZIONAMENTO SOVRAPPOSTO LAYERED COMPASS (0% CARICO CPU)
+   ========================================================================== */
+
+/* Contenitore padre relativo */
+.wind-gauge-container {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    max-height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+/* Sovrapposizione assoluta perfetta del livello lancette sopra lo sfondo */
+#wind-gauge-pointers {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    object-fit: contain;
+    pointer-events: none; /* Permette al tocco del mouse di passare sotto al centro interattivo */
+}

package/utils.js

@@ -33,10 +33,13 @@ function safeSetText(el, text) {
 
 // --- 2. MOTORE MATEMATICO: MEDIA CIRCOLARE VETTORIALE ---
 function getCircularAverageFromBuffer(bufferArray, windowMs, signed = false, now, stabilityThreshold = 0.95, stabilityBreakout = 15) {
-    now = now || Date.now();
     const len = bufferArray.length;
     if (len === 0) return null;
 
+    // RIFERIMENTO TEMPORALE IMMUNE DA DESINCRONIZZAZIONE:
+    // Usiamo come 'ora attuale' l'ultimo timestamp presente nel buffer stesso,
+    // garantendo che la finestra di 2s sia sempre calcolata sui dati NMEA reali arrivati.
+    const referenceTime = bufferArray[len - 1].time;
     let sSin = 0, sCos = 0, count = 0;
     let newestTime = 0, oldestTime = 0;
 
@@ -51,7 +54,7 @@ function getCircularAverageFromBuffer(bufferArray, windowMs, signed = false, now
 
     for (let i = len - 1; i >= 0; i--) {
         const item = bufferArray[i];
-        if ((now - item.time) > windowMs) break;
+        if ((referenceTime - item.time) > windowMs) break; // Usa referenceTime invece di 'now'
 
         let diffRad = Math.atan2(Math.sin(item.val - pilotRad), Math.cos(item.val - pilotRad));
         let finalSin, finalCos;