signalk-mareas-ihm 2.0.2 → 2.1.0

package/dist/README.md

@@ -0,0 +1,215 @@
+# signalk-mareas-ihm
+
+🇪🇸 [Español](#español) · 🇬🇧 [English](#english)
+
+---
+
+## Español
+
+Plugin de Signal K que convierte tu OpenPlotter / Raspberry Pi en un **visor completo de fondeo**: mareas oficiales del **IHM (Instituto Hidrográfico de la Marina)**, previsión de abrigo, medición de olas a bordo, alarmas inteligentes y soporte para domótica.
+
+### Características principales
+
+#### Mareas
+- **Predicción de mareas** automática por GPS o selección manual entre 70 estaciones del IHM.
+- **Curvas de marea interactivas** con HAT/LAT anuales, cursor y etiquetas de pleamar/bajamar.
+- **Coeficientes oficiales IHM** con descarga automática.
+- **Caché offline** de al menos 2 meses de predicciones.
+- **Tendencia y coeficiente** visibles en la barra superior del visor.
+
+#### Previsión de abrigo
+- **Rosa de 16 sectores** con detección automática del abrigo según la costa (OpenStreetMap).
+- **Grado A-F y porcentaje de protección** combinando viento y olas previstos.
+- **Strip de exposición** próximas 12 h con previsión hora a hora.
+- **Resumen "AHORA / PREDICCIÓN"** con datos en tiempo real de sensores y previsión.
+- **Edición manual** de sectores cuando el detector automático no convence.
+
+#### Medición de olas en fondeo
+- **Dirección, período y altura** de ola calculados a bordo desde sensores de actitud y aceleración (pypilot IMU u otros compatibles).
+- **Historial de las últimas 24 h** en barras de 15 minutos.
+- **El grado de abrigo se ajusta automáticamente** cuando la ola medida supera la prevista.
+
+#### Visor de fondeo
+- **Mapa Leaflet** con posición GPS en tiempo real y capas múltiples (ESRI, Bing, Google, IHM S-52, SonarChart, MBTiles offline).
+- **Anchor Watch** con alarma de garreo visual y sonora.
+- **Cadena largada** con slider bidireccional y cálculo automático (métodos tradicional y Vicente).
+- **Radio de borneo y alarma** con etiquetas en la carta y predicción según marea.
+- **Sincronización multi-dispositivo** en tiempo real (SSE).
+- **Cartas náuticas locales** vía servidor MBTiles integrado.
+
+#### Sensores en tiempo real
+- Lectura directa de **viento (veleta)**, **temperatura aire/agua** y **presión atmosférica** de Signal K.
+- Etiquetas **"Veleta"** y **"Sensor"** distinguen datos reales de previsión.
+- **Fallback automático a Open-Meteo** cuando un sensor falla.
+- **Sonda inteligente**: detecta congelación / spikes / valores absurdos y deja de mostrar lecturas inventadas.
+
+#### AIS inteligente
+- **Detección de colisión** con targets AIS en zona de borneo.
+- **ACK por target individual** — silencia alarma de un barco sin desactivar la alarma general.
+- **Detección de garreo ajeno** — si un target ACKed se acerca >2 m/min, la alarma se reactiva.
+- **Estimación de ancla** de otros barcos mediante análisis de track (centroide + radio máximo).
+
+#### Alarmas y audio
+- **Alarmas independientes**: garreo, varada, AIS y sonda con control individual.
+- **Voces pregrabadas (OGG)** por idioma — más naturales que el sintetizador.
+- **Detección automática** de la salida de audio del Raspberry Pi (USB → analog → HDMI).
+- **Soporte móvil** fiable (audio funciona incluso con la pestaña en segundo plano).
+- **Patrones distintos** por evento ("tuc tuc tuc" para AIS, sirena para garreo, etc.).
+
+#### Domótica / KIP
+- **Botones KIP** para fondear/levar y activar/desactivar alarmas.
+- **Endpoints REST** para Alexa, Google Home, Node-RED, MQTT.
+- **Endpoint toggle** para mandos a distancia con un solo botón.
+
+#### Bilingüe completo
+- Interfaz en **español e inglés** en todas las vistas.
+- Compass cardinal en español correcto (N/NE/E/SE/S/SO/O/NO).
+- Banderas de idioma en la barra inferior del visor.
+
+### URLs
+
+| URL | Función |
+|-----|---------|
+| `/signalk-mareas-ihm/` | Landing — selector Mareas / Visor de Fondeo |
+| `/signalk-mareas-ihm/mareas` | Vista de Mareas (directo) |
+| `/signalk-mareas-ihm/visorfondeo` | Visor de Fondeo (directo) |
+
+### Domótica — Endpoints REST
+
+```bash
+# Fondear/Levar con un solo botón
+curl -X POST http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/toggle
+
+# Fondear en posición GPS actual
+curl -X POST http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/drop
+
+# Levar ancla
+curl -X POST http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/lift
+
+# Estado simple (para monitorización)
+curl http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/simple
+```
+
+### KIP — Paths para Boolean Control
+
+| Path | Función |
+|------|---------|
+| `environment.anchor.mareasIhm.anchorCommand` | Fondear (true) / Levar (false) |
+| `environment.anchor.mareasIhm.garreoAlarmCommand` | Alarma garreo ON/OFF |
+| `environment.anchor.mareasIhm.aisAlarmCommand` | Alarma AIS ON/OFF |
+
+### Instalación
+
+Desde el **Signal K Appstore**: buscar `signalk-mareas-ihm` e instalar.
+
+O por línea de comandos:
+
+```bash
+cd ~/.signalk
+npm install signalk-mareas-ihm@latest --save
+sudo systemctl restart signalk
+```
+
+---
+
+## English
+
+Signal K plugin that turns your OpenPlotter / Raspberry Pi into a **complete anchor watch viewer**: official Spanish tides from **IHM (Instituto Hidrográfico de la Marina)**, shelter forecast, on-board wave measurement, smart alarms and home automation support.
+
+### Main Features
+
+#### Tides
+- **Automatic tide prediction** by GPS or manual selection among 70 IHM stations.
+- **Interactive tide curves** with annual HAT/LAT, cursor and high/low tide labels.
+- **Official IHM coefficients** with automatic download.
+- **Offline cache** of at least 2 months of predictions.
+- **Tendency and coefficient** visible in the viewer's top bar.
+
+#### Shelter forecast
+- **16-sector rose** with automatic shelter detection from coastline (OpenStreetMap).
+- **Grade A-F and protection percentage** combining forecast wind and waves.
+- **12 h exposure strip** with hourly forecast.
+- **"NOW / FORECAST" summary** with real-time sensor and forecast data.
+- **Manual sector override** when the automatic detector is wrong.
+
+#### On-board wave measurement
+- **Direction, period and height** of waves computed on board from attitude and acceleration sensors (pypilot IMU or compatible).
+- **24 h history** in 15-minute bars.
+- **Shelter grade auto-adjusts** when measured wave exceeds forecast.
+
+#### Anchor watch viewer
+- **Leaflet map** with real-time GPS position and multiple layers (ESRI, Bing, Google, IHM S-52, SonarChart, offline MBTiles).
+- **Anchor Watch** with visual and audible drag alarm.
+- **Chain deployed** with bidirectional slider and automatic calculation (traditional and Vicente methods).
+- **Swing and alarm radius** with chart labels and tide-aware prediction.
+- **Multi-device real-time sync** (SSE).
+- **Local nautical charts** via integrated MBTiles server.
+
+#### Real-time sensors
+- Direct reading of **wind (anemometer)**, **air/water temperature** and **atmospheric pressure** from Signal K.
+- **"Veleta"** and **"Sensor"** badges distinguish real data from forecast.
+- **Automatic Open-Meteo fallback** when a sensor drops.
+- **Smart depth sounder**: detects frozen / spike / absurd values and stops showing made-up readings.
+
+#### Smart AIS
+- **Collision detection** with AIS targets in swing zone.
+- **Per-target ACK** — silence alarm for one boat without disabling the general alarm.
+- **External dragging detection** — if an ACKed target approaches >2 m/min, alarm reactivates.
+- **Anchor estimation** for other boats via track analysis (centroid + max radius).
+
+#### Alarms and audio
+- **Independent alarms**: drag, grounding, AIS and depth with individual control.
+- **Pre-recorded voices (OGG)** per language — more natural than synthesizer.
+- **Automatic detection** of Raspberry Pi audio output (USB → analog → HDMI).
+- **Reliable mobile support** (audio works even when the tab is in background).
+- **Distinct patterns** per event (rapid beep for AIS, siren for drag, etc.).
+
+#### Home Automation / KIP
+- **KIP buttons** for drop/lift and alarm enable/disable.
+- **REST endpoints** for Alexa, Google Home, Node-RED, MQTT.
+- **Toggle endpoint** for single-button remote controls.
+
+#### Full Bilingual
+- Interface in **Spanish and English** across all views.
+- Correct Spanish cardinal compass (N/NE/E/SE/S/SO/O/NO).
+- Language flags in the viewer's bottom bar.
+
+### URLs
+
+| URL | Function |
+|-----|----------|
+| `/signalk-mareas-ihm/` | Landing — Tides / Anchor Watch selector |
+| `/signalk-mareas-ihm/mareas` | Tides view (direct) |
+| `/signalk-mareas-ihm/visorfondeo` | Anchor Watch Viewer (direct) |
+
+### Home Automation — REST Endpoints
+
+```bash
+# Drop/Lift with single button
+curl -X POST http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/toggle
+
+# Drop anchor at current GPS
+curl -X POST http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/drop
+
+# Lift anchor
+curl -X POST http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/lift
+
+# Simple status (for monitoring)
+curl http://openplotter.local:3000/signalk-mareas-ihm/api/anchor-watch/simple
+```
+
+### Installation
+
+From the **Signal K Appstore**: search `signalk-mareas-ihm` and install.
+
+Or via command line:
+
+```bash
+cd ~/.signalk
+npm install signalk-mareas-ihm@latest --save
+sudo systemctl restart signalk
+```
+
+---
+
+© IHM — Official data from Spain's Instituto Hidrográfico de la Marina

package/dist/build-info.json

@@ -1,7 +1,7 @@
 {
-  "version": "2.0.2",
-  "timestamp": "20260523-1548",
+  "version": "2.1.0",
+  "timestamp": "20260602-0142",
   "gitHash": null,
   "gitDirty": true,
-  "builtAt": "2026-05-23T13:48:04.276Z"
+  "builtAt": "2026-06-01T23:42:06.561Z"
 }

package/dist/imu/manager.js

@@ -0,0 +1,300 @@
+/**
+ * Rev147 — ImuManager.
+ *
+ * Orquesta las fuentes IMU según un orden profesional:
+ *   A. Signal K existente (paths attitude/heading ya publicados por otro plugin).
+ *   B. Pypilot local (localhost:23322).
+ *   C. Pypilot remoto (host configurado, o lista candidata).
+ *   D. MacArthur HAT — asumido por pypilot, no acceso I2C directo.
+ *   E. Raw I2C (último recurso, sólo si `imu.rawI2c.enabled === true`).
+ *
+ * Reglas:
+ *   - `preferredSource` manual fijado por usuario gana mientras esté sano.
+ *   - Auto-detect respeta `imu.autoDetect`. Si false, sólo arranca la fuente
+ *     fijada (o todas las habilitadas por config y deja al manager elegir).
+ *   - Si la fuente activa pasa a stale durante `staleAfterSeconds`, busca
+ *     fallback dentro de las disponibles y loguea la transición.
+ *   - El manager NO publica datos a SK — los consumers (wave detection, etc.)
+ *     reciben muestras vía callback `onSample`.
+ *   - El manager NO compite con plugins que ya emiten attitude — la
+ *     fuente SignalKAttitudeSource simplemente LEE de SK, no escribe.
+ *
+ * Robustez:
+ *   - Timeouts cortos en probes (3 s).
+ *   - Errores de conexión NO lanzan excepciones — se reflejan como `status`.
+ *   - El manager corre un tick periódico (100 ms) que poll-ea la fuente activa
+ *     y, si está stale, intenta failover.
+ */
+import { SignalKAttitudeSource } from "./sources/signalk.js";
+import { PypilotKeyValueSource } from "./sources/pypilot.js";
+import { RawI2cImuSource } from "./sources/rawi2c.js";
+import { IMU_LOG_MESSAGES, DEFAULT_IMU_CONFIG, } from "./types.js";
+export class ImuManager {
+    app;
+    config;
+    tickMs;
+    onSample;
+    onSourceChange;
+    /** Todas las fuentes registradas (algunas pueden estar disabled). */
+    sources = [];
+    /** Fuente activa actualmente entregando muestras al consumer. */
+    active = null;
+    tickTimer = null;
+    bootstrapDone = false;
+    lastFailoverLogMs = 0;
+    constructor(opts) {
+        this.app = opts.app;
+        this.config = { ...DEFAULT_IMU_CONFIG, ...opts.config };
+        this.tickMs = opts.tickMs ?? 100;
+        this.onSample = opts.onSample;
+        this.onSourceChange = opts.onSourceChange;
+    }
+    /**
+     * Inicializa: construye las fuentes según config, ejecuta auto-detect si
+     * está habilitado, y arranca el tick.
+     */
+    async start() {
+        if (this.bootstrapDone)
+            return;
+        // A. Signal K (siempre disponible — es sólo lectura)
+        const skSource = new SignalKAttitudeSource(this.app, {
+            staleAfterMs: this.config.staleAfterSeconds * 1000,
+        });
+        this.sources.push(skSource);
+        // B. Pypilot local
+        const localPypilot = new PypilotKeyValueSource({
+            app: this.app,
+            host: "localhost",
+            port: this.config.pypilot.port,
+            isLocal: true,
+            staleAfterMs: this.config.staleAfterSeconds * 1000,
+        });
+        this.sources.push(localPypilot);
+        // C. Pypilot remoto (host configurado + lista candidata)
+        const remoteHosts = new Set();
+        if (this.config.pypilot.host && this.config.pypilot.host !== "localhost" && this.config.pypilot.host !== "127.0.0.1") {
+            remoteHosts.add(this.config.pypilot.host);
+        }
+        for (const h of this.config.pypilot.remoteHosts || []) {
+            if (h && h !== "localhost")
+                remoteHosts.add(h);
+        }
+        for (const host of remoteHosts) {
+            this.sources.push(new PypilotKeyValueSource({
+                app: this.app,
+                host,
+                port: this.config.pypilot.port,
+                isLocal: false,
+                staleAfterMs: this.config.staleAfterSeconds * 1000,
+            }));
+        }
+        // D. MacArthur HAT — sin acción directa, asumido vía pypilot.
+        //    Solo log para que el usuario vea que lo conocemos.
+        if (this._looksLikeMacArthur()) {
+            this.app.debug?.(IMU_LOG_MESSAGES.macarthurAssumed);
+        }
+        // E. Raw I2C — siempre instanciado, pero arranca disabled salvo opt-in
+        const rawI2c = new RawI2cImuSource({
+            app: this.app,
+            bus: this.config.rawI2c.bus,
+            enabled: this.config.rawI2c.enabled,
+            allowedModels: this.config.rawI2c.allowedModels,
+        });
+        this.sources.push(rawI2c);
+        if (!this.config.rawI2c.enabled) {
+            this.app.debug?.(IMU_LOG_MESSAGES.rawI2cDisabled);
+        }
+        // Iniciar la fuente SK siempre (es barata y solo lee).
+        skSource.start();
+        // Si autoDetect, probar fuentes pypilot en orden de prioridad.
+        if (this.config.autoDetect) {
+            await this._autoDetect();
+        }
+        else {
+            // Sin auto-detect: arrancar solo la fuente que coincida con preferredSource.
+            this._startPreferredOnly();
+        }
+        // Tick periódico
+        this.tickTimer = setInterval(() => this._tick(), this.tickMs);
+        this.bootstrapDone = true;
+    }
+    async stop() {
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+        for (const s of this.sources) {
+            try {
+                await s.stop();
+            }
+            catch { /* defensive */ }
+        }
+        this.active = null;
+        this.bootstrapDone = false;
+    }
+    /** Estado para el endpoint /api/imu/status. */
+    status() {
+        return {
+            active: this.active
+                ? { id: this.active.id, type: this.active.type, ageMs: this.active.quality.ageMs }
+                : null,
+            available: this.sources.map((s) => ({
+                id: s.id,
+                type: s.type,
+                status: s.status,
+                priority: s.priority,
+                ageMs: s.quality.ageMs,
+                sampleRateHz: s.quality.sampleRateHz,
+                provides: s.provides,
+                host: s.host,
+                port: s.port,
+                lastError: s.lastError,
+            })),
+            config: this.config,
+        };
+    }
+    /**
+     * Lanza auto-detect manual desde la UI (botón "Buscar IMU"). Re-prueba
+     * pypilot local + remoto y re-selecciona la mejor fuente.
+     */
+    async triggerAutoDetect() {
+        await this._autoDetect();
+    }
+    // ─────────────────────────── internals ───────────────────────────
+    async _autoDetect() {
+        // A. SK: ya arrancada. Esperamos un tick por si llega data inmediata.
+        await this._sleep(200);
+        const skSource = this.sources.find((s) => s.type === "signalk");
+        if (skSource) {
+            skSource.poll(); // refresca estado
+            if (skSource.quality.coherent) {
+                this.app.debug?.(IMU_LOG_MESSAGES.usingSignalK);
+                this._setActive(skSource);
+                return;
+            }
+        }
+        // B+C. Probar pypilot local + remotos en paralelo (3 s timeout cada uno)
+        const pypilots = this.sources.filter((s) => s instanceof PypilotKeyValueSource);
+        const probes = await Promise.all(pypilots.map(async (p) => ({ src: p, ok: await p.probe() })));
+        // Local gana sobre remoto. Dentro de cada grupo, primer host que responde.
+        const localOk = probes.find((p) => p.src.type === "pypilot-local" && p.ok);
+        if (localOk) {
+            this.app.debug?.(IMU_LOG_MESSAGES.usingPypilotLocal);
+            localOk.src.start();
+            this._setActive(localOk.src);
+            return;
+        }
+        const remoteOk = probes.find((p) => p.src.type === "pypilot-network" && p.ok);
+        if (remoteOk) {
+            this.app.debug?.(`${IMU_LOG_MESSAGES.usingPypilotRemote} @ ${remoteOk.src.host}:${remoteOk.src.port}`);
+            remoteOk.src.start();
+            this._setActive(remoteOk.src);
+            return;
+        }
+        // E. Raw I2C como último recurso (sólo si enabled — y aun así es stub).
+        const rawi2c = this.sources.find((s) => s.type === "raw-i2c");
+        if (rawi2c && this.config.rawI2c.enabled) {
+            rawi2c.start();
+            // No lo marcamos como activo — el stub no entrega samples.
+        }
+        // Nada disponible
+        if (!this.active) {
+            this.app.debug?.(IMU_LOG_MESSAGES.noSource);
+        }
+    }
+    _startPreferredOnly() {
+        const pref = this.config.preferredSource;
+        if (pref === "auto" || pref === "none")
+            return;
+        const src = this.sources.find((s) => s.type === pref);
+        if (!src)
+            return;
+        src.start();
+        this._setActive(src);
+    }
+    /** Tick: poll de la fuente activa; si stale, intenta failover. */
+    _tick() {
+        if (this.active) {
+            const sample = this.active.poll();
+            if (sample) {
+                try {
+                    this.onSample?.(sample, this.active);
+                }
+                catch { /* never propagate */ }
+            }
+            else {
+                // Activa cayó a stale/error: failover
+                const now = Date.now();
+                if (now - this.lastFailoverLogMs > 5_000) {
+                    this.app.debug?.(IMU_LOG_MESSAGES.sourceStale);
+                    this.lastFailoverLogMs = now;
+                }
+                const fallback = this._chooseBestSource(this.active);
+                if (fallback && fallback !== this.active) {
+                    this._setActive(fallback);
+                }
+            }
+        }
+        else {
+            // Sin fuente activa — intentamos elegir una entre las disponibles
+            const cand = this._chooseBestSource(null);
+            if (cand)
+                this._setActive(cand);
+        }
+    }
+    /** Elige la mejor fuente disponible distinta de `exclude`. */
+    _chooseBestSource(exclude) {
+        const candidates = this.sources
+            .filter((s) => s !== exclude)
+            .filter((s) => s.status === "available" || s.status === "active")
+            .filter((s) => {
+            if (this.config.minQuality === "ok")
+                return s.quality.coherent;
+            return true;
+        })
+            .sort((a, b) => b.priority - a.priority);
+        return candidates[0] ?? null;
+    }
+    _setActive(src) {
+        const prev = this.active;
+        if (prev === src)
+            return;
+        if (prev)
+            prev.status = prev.status === "active" ? "available" : prev.status;
+        src.status = "active";
+        this.active = src;
+        try {
+            this.onSourceChange?.(src, prev);
+        }
+        catch { /* ignore */ }
+    }
+    /**
+     * Heurística simple: si /sys/firmware/devicetree/base/model contiene la
+     * cadena "MacArthur" (o "OpenPlotter"), consideramos MacArthur HAT
+     * probable. Tomar como hint, no como hecho.
+     */
+    _looksLikeMacArthur() {
+        try {
+            // Sólo en Linux/Pi; cualquier error → asume no.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const fs = require("fs");
+            const candidates = [
+                "/sys/firmware/devicetree/base/model",
+                "/proc/device-tree/model",
+            ];
+            for (const p of candidates) {
+                try {
+                    const txt = fs.readFileSync(p, "utf-8");
+                    if (/macarthur|openplotter/i.test(txt))
+                        return true;
+                }
+                catch { /* path missing */ }
+            }
+        }
+        catch { /* fs missing */ }
+        return false;
+    }
+    _sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}