signalk-racer 1.0.0 → 1.1.0

package/README.md

@@ -24,6 +24,8 @@ This plugin calculates and publishes the following Signal K paths:
 | `navigation.racing.`<br/>`nextLegHeading`       | True heading for the next leg of the course            | `rad`                  |     |
 | `navigation.racing.`<br/>`nextLegTrueWindAngle` | True Wind Angle for the next leg of the course         | `rad`                  |     |
 | `navigation.racing.`<br/>`timeToStart`          | Period of time until the race start                    | `s`                    | Y   |
+| `navigation.racing.`<br/>`timeToLine`           | Period of time to sail to the line at best VMG         | `s`                    |     |
+| `navigation.racing.`<br/>`timeToBurn`           | Period of time delay before sailing to the at best VMG | `s`                    |     |
 | `navigation.racing.`<br/>`startTime`            | The start time as an ISO timestamp                     | `rfc3339`              |     |
 
 These values can be displayed in KIP widgets, Freeboard-SK, or other Signal K clients.  
@@ -51,6 +53,7 @@ You can configure the plugin via the Signal K web interface or by editing `setti
 | `period`                  | How often to update values (in milliseconds)                            | `1000`        |
 | `updateStartLineWaypoint` | Should the waypoints be updated if the line is set/adjusted             | `true`        |
 | `createStartLineWaypoint` | Should the waypoints be created if the line is set                      | `true`        |
+| `lines`                   | Array of named lines                                                    | null          |
 
 ---
 
@@ -66,13 +69,16 @@ If `navigation.headingTrue` is not available, then `navigation.courseOverGroundT
 
 ### Distance to Start Line (`navigation.racing.distanceStartline`)
 
-- Computes the **signed minimum distance** from the **bow** of the boat to the configured start line.
+![Distance to Start Line](racer-line.png)
+
+- Computes the distance from the **bow** of the boat to the configured start line.  
+- For boats within the start zone (defined as with a 45 degree bearing to each end of the line), the perpendicular distance to the line is used.
+- For boats outside of the start zone, the distance parallel to the line to reach the zone is added to their perpendicular distance to the line.
 - Uses `sensors.gps.fromBow` and `sensors.gps.fromCenter` offsets to calculate the actual bow position.
-- Normally uses the **perpendicular projection** from the bow to the line.
-- However, if the bow is located within a **45° sector** off either end of the line, the plugin adds the distance back to that diagonal to perpendicular distance.
 - The result is:
     - **Negative** when the bow is **over the line (OCS)**
     - **Positive** when the bow is **behind the line**
+- If the boat is navigating a route and the next waypoint is beyond the second in the route, then the distance to line is not calculated.
 
 ### Start Line Bias (`navigation.racing.stbLineBias`)
 
@@ -80,6 +86,20 @@ If `navigation.headingTrue` is not available, then `navigation.courseOverGroundT
 - The `environment.wind.directionTrue` is used as well as the calculated line length and bearing.
 - A **positive value** means the **pin end is more downwind**, implying the **starboard (boat) end is favored** for upwind starts.
 
+### Time To Line (`navigation.racing.timeToLine`)
+
+ - Uses the effective VMG as the maximum VMG of either the current COG/SOG or the 90th percentile of the VMG recently achieved (approx in the last 10 minutes).
+   This allows a boat to luff / delay without changing the time to line.
+ - A boat within the start zone has the time calculated by the perpendicular distance to the line divided by their effective VMG to the line.
+ - A boat outside the start zone also has the perpendicular time plus the time calculated by the parallel distance to the zone divided by their effective VMG in that direction.
+ - If the line is changed, then the samples used to calculate the effective VMGs are cleared.
+ - If the boat is navigating a route and the next waypoint is beyond the second in the route, then the time to line is not calculated.
+
+
+### Time To Burn (`navigation.racing.timeToBurn`)
+ - If the start timer is running and the boat is not OCS, then the time to burn is calculated by subtracting the time to line from the remaining start time. 
+ - If the boat is navigating a route and the next waypoint is beyond the second in the route, then the time to line is not calculated.
+
 ### Line Coordinates & Length
 
 - The plugin reads Signal K `waypoints` resources for the names you configure.
@@ -152,7 +172,7 @@ KIP components for `racer-timer` and `racer-line` have been developed and are av
 ## 🧪 Future Plans
 
 - Add calculations for:
-- **Time to line** (using STW and heading or polar speeds)
+- **Time to burn**
 - **Laylines** and distance/time to them
 
 --- 
@@ -160,3 +180,13 @@ KIP components for `racer-timer` and `racer-line` have been developed and are av
 
 Bug reports and suggestions are welcome at  
 [https://github.com/gregw/signalk-racer](https://github.com/gregw/signalk-racer)
+
+
+---
+## Development
+```text
+npm install
+npm link
+cd ~/.signalk
+npm link signalk-racer
+```

package/ReleaseNotes.md

@@ -1,3 +1,12 @@
+## 1.1.0 Named lines
++ Added Named lines support
++ Refactored distance to line calculations
++ Added timeToStart and timeToBurn (experimental at this stage)
++ Minor bug fixes
+
+## 1.0.1 Fix initial configuration
+ + Fixed default values of initial configuration
+
 ## 1.0.0 GA Release with KIP Widgets
  + Fixed bias to be towards wind
 

package/index.js

@@ -1,5 +1,13 @@
 module.exports = (app) => {
-    const state = {};
+    const state = {
+        startLineName: null,
+        startLine: null,
+
+        vmgToLinePos: [],  // VMG towards the line (not OCS to line)
+        vmgToLineNeg: [],  // VMG away from the line (OCS to line)
+        vmgToZonePort: [], // Motion along the line towards the PORT end (pin)
+        vmgToZoneStb: [],  // Motion along the line towards the STARBOARD end (boat)
+    };
     const geolib = require('geolib')
     const racerSchema = {
         title: 'Signalk Racer Configuration',
@@ -7,23 +15,23 @@ module.exports = (app) => {
         properties: {
             startLineStb: {
                 type: 'string',
-                title: 'The start line starboard end (boat) waypoint name',
+                title: 'Start line starboard-end (boat) waypoint name',
                 default: 'startBoat'
             },
             startLinePort: {
                 type: 'string',
-                title: 'The start line port end (pin) waypoint name',
+                title: 'Start line port-end (pin) waypoint name',
                 default: 'startPin'
             },
             updateStartLineWaypoint: {
                 type: 'boolean',
                 title: 'Update the start line waypoints if the startLine is updated',
-                default: 'true'
+                default: true
             },
             createStartLineWaypoint: {
                 type: 'boolean',
                 title: 'Create the start line waypoints if the startLine is updated and the waypoint does not exist',
-                default: 'true'
+                default: true
             },
             period: {
                 type: 'number',
@@ -35,6 +43,45 @@ module.exports = (app) => {
                 title: 'Start Timer default initial period in seconds',
                 default: 300
             },
+
+            lines: {
+                type: 'array',
+                title: 'Named lines',
+                description: 'Add zero or more named start lines',
+                items: {
+                    type: 'object',
+                    title: 'Named line',
+                    properties: {
+                        startLineName: {
+                            type: 'string',
+                            title: 'Line name',
+                        },
+                        startLineStb: {
+                            type: 'string',
+                            title: 'Start line starboard-end (boat) waypoint name'
+                        },
+                        startLinePort: {
+                            type: 'string',
+                            title: 'Start line port-end (pin) waypoint name'
+                        },
+                        updateStartLineWaypoint: {
+                            type: 'boolean',
+                            title: 'Update the start line waypoints if the startLine is updated',
+                            default: true
+                        },
+                        createStartLineWaypoint: {
+                            type: 'boolean',
+                            title: 'Create the start line waypoints if the startLine is updated and the waypoint does not exist',
+                            default: true
+                        },
+                        startLineDescription: {
+                            type: 'string',
+                            title: 'Optional description'
+                        }
+                    },
+                    required: ['startLineName', 'startLineStb', 'startLinePort']
+                }
+            }
         }
     }
     const { v4: uuidv4 } = require('uuid')
@@ -100,6 +147,26 @@ module.exports = (app) => {
                             "shortName": "StartTime",
                         }
                     },
+                    {
+                        "path": "navigation.racing.timeToLine",
+                        "value": {
+                            "type": "number",
+                            "units": "s",
+                            "description": "Time to sail to the the line at best VMG",
+                            "displayName": "Time to line",
+                            "shortName": "TTS"
+                        }
+                    },
+                    {
+                        "path": "navigation.racing.timeToBurn",
+                        "value": {
+                            "type": "number",
+                            "units": "s",
+                            "description": "Time to delay before sailing to the the start line",
+                            "displayName": "Time to burn",
+                            "shortName": "TTB"
+                        }
+                    }
                 ]
             }
         ]
@@ -144,11 +211,13 @@ module.exports = (app) => {
     }
 
     function toDegrees(rad) {
-        return rad ? rad * (180 / Math.PI) : null;
+        if (rad === null || rad === undefined) return null;
+        return rad * (180 / Math.PI);
     }
 
     function toRadians(degrees) {
-        return degrees ? degrees * (Math.PI / 180) : null;
+        if (degrees === null || degrees === undefined) return null;
+        return degrees * (Math.PI / 180);
     }
 
     function toOtherEnd(end) {
@@ -170,17 +239,12 @@ module.exports = (app) => {
             return position
 
         headingTrue = toDegrees(headingTrue.value);
-        app.debug('headingTrue:' + headingTrue);
-        app.debug('position:' + JSON.stringify(position));
-        app.debug('gpsFromBow:' + JSON.stringify(state.gpsFromBow));
-        app.debug('gpsFromCenter:' + JSON.stringify(state.gpsFromCenter));
 
         let bow = position;
         if (state.gpsFromBow)
             bow = geolib.computeDestinationPoint(bow, state.gpsFromBow, headingTrue);
         if (state.gpsFromCenter)
             bow = geolib.computeDestinationPoint(bow, state.gpsFromCenter, headingTrue + 90);
-        app.debug('bowPosition:' + JSON.stringify(bow));
         return bow;
     }
 
@@ -194,6 +258,32 @@ module.exports = (app) => {
         return result;
     }
 
+    function publishLineList() {
+        const lines = Array.isArray(state.options.lines) ? state.options.lines : [];
+
+        const payload = {
+            startLineName: state.startLineName ?? null,
+            lines: lines.map(l => ({
+                startLineName: l.startLineName,
+                startLineDescription: l.startLineDescription || null
+            }))
+        };
+
+        app.handleMessage('vessels.self', {
+            context: "vessels.self",
+            updates: [
+                {
+                    values: [
+                        {
+                            path: 'navigation.racing.lines',
+                            value: payload
+                        }
+                    ]
+                }
+            ]
+        });
+    }
+    
     // Put an absolute position
     async function putStartLineEnd(end, position, callback, updateWaypoint) {
         app.debug(`putStartLineEnd: ${end} ${JSON.stringify(position)}`);
@@ -257,11 +347,12 @@ module.exports = (app) => {
             }
 
             // Set/create the waypoint if we are configured to do so
-            if (state.options.updateStartLineWaypoint || updateWaypoint) {
+            const startLineOptions = getStartLineOptions();
+            if (startLineOptions.updateStartLineWaypoint || updateWaypoint) {
                 try {
                     const waypointConfig = `startLine${camelCase(end)}`;
                     app.debug(`waypointConfig: ${waypointConfig}`);
-                    const waypointName = state.options[waypointConfig];
+                    const waypointName = getStartLineOptions()[waypointConfig];
                     app.debug(`waypointName: ${waypointName}`);
                     let waypointId = startLine ? startLine[end + 'Id'] : null;
                     app.debug(`waypointId: ${waypointId}`);
@@ -300,7 +391,7 @@ module.exports = (app) => {
 
                     app.debug(`waypoint: ${waypointId} -> ${end}/${waypointName} : ${JSON.stringify(waypoint)}`);
 
-                    if (!waypointId && state.options.createStartLineWaypoint)
+                    if (!waypointId && startLineOptions.createStartLineWaypoint)
                         waypointId = uuidv4();
                     if (waypointId)
                         await app.resourcesApi.setResource('waypoints', waypointId, waypoint);
@@ -324,6 +415,24 @@ module.exports = (app) => {
         }
     }
 
+    async function setStartLineName(context, path, args, callback) {
+        try {
+            app.debug('setStartLineName:', JSON.stringify(args));
+            if (!args || args.startLineName != null && typeof args.startLineName !== 'string') {
+                return complete(callback, 400, 'Failed to set the startLine name!');
+            }
+            if (state.startLineName !== args.startLineName) {
+                state.startLineName = args.startLineName;
+                state.startLine = null;
+                findLineAndThenProcess(null, true);
+            }
+            publishLineList();
+            return complete(callback, 200, 'Put start line name: OK');
+        } catch (err) {
+            return complete(callback, 500, 'Put start line name: Failed ' + err);
+        }
+    }
+
     async function setStartLine(context, path, args, callback) {
         try {
             app.debug('setStartLine:', JSON.stringify(args));
@@ -356,7 +465,8 @@ module.exports = (app) => {
                 const initialBearing = geolib.getRhumbLineBearing(otherEnd, thisEnd);
                 const currentDistance = geolib.getDistance(otherEnd, thisEnd);
 
-                const newDistance = args.delta && typeof args.delta === 'number' ? (currentDistance + args.delta) : currentDistance;
+                const delta = (args.delta && typeof args.delta === 'number' && end === 'stb') ? -args.delta : args.delta;
+                const newDistance = delta && typeof delta === 'number' ? (currentDistance + args.delta) : currentDistance;
                 const newBearing = args.rotate && typeof args.rotate === 'number' ? (initialBearing + toDegrees(args.rotate)) : initialBearing;
 
                 const newPosition = geolib.computeDestinationPoint(otherEnd, newDistance, newBearing);
@@ -365,7 +475,7 @@ module.exports = (app) => {
             }
 
             if (position)
-                return putStartLineEnd(end, position, callback, args.updateWaypoint === true);
+                return putStartLineEnd(end, position, callback, getStartLineOptions().updateStartLineWaypoint);
             return complete(callback, 500, 'Failed to set the startLine: No position');
         } catch (err) {
             return complete(callback, 500, 'Failed to set the startLine: ' + err);
@@ -535,16 +645,18 @@ module.exports = (app) => {
                     length: null,
                     bearing: null,
                 }
+                const startLineOptions = getStartLineOptions();
+                app.debug(`Start Line Options [${state.startLineName}]:`, JSON.stringify(startLineOptions));
                 for (const [key, value] of Object.entries(data)) {
                     app.debug(`WAYPOINT: ${key}, Value:`, JSON.stringify(value));
-                    if (value.name === state.options.startLinePort) {
+                    if (value.name === startLineOptions.startLinePort) {
                         let pos = waypointToPosition(value);
                         if (pos) {
                             startLine.portId = key;
                             startLine.port = pos;
                         }
                     }
-                    if (value.name === state.options.startLineStb) {
+                    if (value.name === startLineOptions.startLineStb) {
                         let pos = waypointToPosition(value);
                         if (pos) {
                             startLine.stbId = key;
@@ -553,21 +665,31 @@ module.exports = (app) => {
                     }
                 }
 
+                let deltas;
                 if (startLine.port && startLine.stb) {
                     startLine.length = geolib.getPreciseDistance(startLine.port, startLine.stb, 0.1);
                     startLine.bearing = geolib.getRhumbLineBearing(startLine.stb, startLine.port);
 
                     app.debug(`STARTLINE: startLinePort: ${JSON.stringify(startLine)}`);
                     state.startLine = startLine;
+                    state.vmgToLineNeg = [];
+                    state.vmgToLinePos = [];
+                    state.vmgToZoneStb = [];
+                    state.vmgToZonePort = [];
+                    deltas = [
+                        {path: 'navigation.racing.startLinePort', value: startLine.port},
+                        {path: 'navigation.racing.startLineStb', value: startLine.stb},
+                        {path: 'navigation.racing.startLineLength', value: startLine.length},
+                    ].filter(entry => entry.value !== null && entry.value !== undefined);
                 } else {
                     app.debug(`STARTLINE: undefined`);
                     state.startLine = null;
+                    deltas = [
+                        {path: 'navigation.racing.startLinePort', value: null},
+                        {path: 'navigation.racing.startLineStb', value: null},
+                        {path: 'navigation.racing.startLineLength', value: null},
+                    ];
                 }
-                const deltas = [
-                    {path: 'navigation.racing.startLinePort', value: startLine.port},
-                    {path: 'navigation.racing.startLineStb', value: startLine.stb},
-                    {path: 'navigation.racing.startLineLength', value: startLine.length},
-                ].filter(entry => entry.value !== null && entry.value !== undefined);
                 if (deltas.length > 0) {
                     sendDeltas(deltas);
                     processPosition(position);
@@ -616,52 +738,205 @@ module.exports = (app) => {
             const toPort = geolib.getPreciseDistance(bow, startLine.port, 0.1);
             const toStb = geolib.getPreciseDistance(bow, startLine.stb, 0.1);
 
+            // which is the closest end
             const closest = toPort < toStb ? startLine.port : startLine.stb;
             let toEnd;
-            let ocs;
+            let bearingToEnd;
             let angle;
+            let closestEnd;
             if (closest === state.startLine.port) {
+                closestEnd = 'port';
                 toEnd = toPort;
                 app.debug('closest to Port(pin):' + toPort);
-                const toBowBearing = geolib.getRhumbLineBearing(startLine.port, bow);
-                app.debug('toBowBearing:' + toBowBearing);
-                angle = toBowBearing - (startLine.bearing + 180) % 360;
+                bearingToEnd = geolib.getRhumbLineBearing(bow, startLine.port);
+                angle = bearingToEnd - startLine.bearing;
             } else {
+                closestEnd = 'stb';
                 toEnd = toStb;
                 app.debug('closest to Stb(boat):' + toStb);
-                const toBowBearing = geolib.getRhumbLineBearing(startLine.stb, bow);
-                app.debug('toBowBearing:' + toBowBearing);
-                angle = startLine.bearing - toBowBearing;
+                bearingToEnd = geolib.getRhumbLineBearing(bow, startLine.stb);
+                angle = 180 - (bearingToEnd - startLine.bearing);
             }
             angle = ((angle + 180) % 360 + 360) % 360 - 180;
-            app.debug('angle:' + angle);
-            app.debug('toEnd:' + toEnd);
-            ocs = angle < 0;
-            app.debug('ocs:' + ocs);
-
-            let absAngle = Math.abs(angle);
-            const farFromLine = absAngle > 135;
-            app.debug('farFromLine:' + farFromLine);
-            const perpendicularToLine = toEnd * Math.sin(toRadians(absAngle));
-            app.debug('perpendicularToLine:' + perpendicularToLine);
-            let toLine = farFromLine ? Math.sqrt(toEnd * toEnd - perpendicularToLine * perpendicularToLine) : perpendicularToLine;
-            toLine = Math.round(10 * toLine) / 10;
-            app.debug('toLine:' + toLine);
+            const ocs = angle < 0;
+
+            // We define a start zone which includes a 45° wedge off each end of the line.
+            // - If the boat is inside the start zone, distanceToLine = perpendicular to line (or extension).
+            // - If the boat is outside the start zone, distanceToLine = distance parallel to the line to enter the zone +
+            //   perpendicular distance to the line (or extension).
+            // This is illustrated for the starboard closest end of the line below:
+            //     \                                     /
+            //      \                                   /
+            //       P---------------------------------B - - - - - -x-
+            //      /135                         PBz=135\' , VBx    .
+            //     /                                     \   ' ,    .
+            //    /                                       \      ' ,.
+            //   /                                     b   z - - - -V
+            //  /                                           \
+            //
+            // P=pin; B=boat; x=extension; b=perpToBoat; z=zoneEntry; V=vessel; N=north
+            // bearing = NBP
+            // PBz == 135
+            // bBz == zBx == 45
+            // Bb == bz == Vx == perpendicular distance to the line or extension.
+            // PBV = abs(angle)
+            // VBx = 180 - PBV
+            // Vx = toEnd * sin (VBx)
+            // bBV = 90 - VBx
+            // Vb = toEnd * sin (bBV)
+            // zb = sqrt((Vx * Vx) / 2)
+            // Vz = Vb - zb
+            const anglePBV = Math.abs(angle);
+            const inStartZone = anglePBV <= 135;
+            const angleVBx = 180 - anglePBV;
+            const perpToLineVx = toEnd * Math.sin(toRadians(angleVBx));
+            let toZoneVz = inStartZone ? 0 : ( toEnd * Math.sin(toRadians(90 - angleVBx)) - Math.sqrt(perpToLineVx * perpToLineVx / 2.0));
+            const toLine = Math.round( 10 * (toZoneVz + perpToLineVx)) / 10;
             const distanceToLine = ocs ? -toLine : toLine;
             app.debug('distanceToLine:' + distanceToLine);
             state.distanceToLine = distanceToLine;
+
+            // Collect VMG samples
+            const cog = app.getSelfPath("navigation.courseOverGroundTrue")?.value;
+            const sog = app.getSelfPath("navigation.speedOverGround")?.value;
+            if (cog != null && sog != null) {
+                collectVmgSamples(cog, sog, startLine.bearing, toZoneVz, perpToLineVx);
+            }
+            const ttl = computeTimeToLine(cog, sog, startLine.bearing, toZoneVz, perpToLineVx, ocs, closestEnd);
+            const ttb = !ocs && state.timerRunning && state.timeToStart > 0 ? Math.max(0, state.timeToStart - ttl) : null;
+
             sendDeltas([
                 {path: 'navigation.racing.distanceStartline', value: distanceToLine},
+                {path: "navigation.racing.timeToLine", value: ttl},
+                {path: "navigation.racing.timeToBurn", value: ttb}
             ]);
+
         } else if (state.distanceToLine) {
             state.distanceToLine = null;
             sendDeltas([
                 {path: 'navigation.racing.distanceStartline', value: null},
                 {path: 'navigation.racing.startLineBias', value: null},
+                {path: 'navigation.racing.timeToLine', value: null},
+                {path: 'navigation.racing.timeToBurn', value: null},
             ]);
         }
     }
 
+    function collectVmgSamples(cog, sog, lineBearing, toZoneVz, perpToLineVx) {
+        try {
+            // TODO configure these rejection values
+            if (sog < 1.0) return;   // ignore drifting / tacking stalls
+            if (toZoneVz > 1000 || perpToLineVx > 1000) return; // to far away from the line
+
+            // Compute angle boatDir-relative to line bearing
+            let angleRad = cog - toRadians(lineBearing);
+
+            // VMG components
+            const vmgNormal = sog * Math.sin(angleRad);  // +ve = towards line, -ve = away
+            const vmgTangent = sog * Math.cos(angleRad); // +ve = towards pin, -ve = towards stb
+
+            // Insert vmg arrays
+            insertSample(state.vmgToLinePos, vmgNormal);
+            insertSample(state.vmgToLineNeg, -vmgNormal);
+            insertSample(state.vmgToZonePort, vmgTangent);
+            insertSample(state.vmgToZoneStb, -vmgTangent);
+        } catch (err) {
+            app.error(err);
+        }
+    }
+
+    function insertSample(arr, value) {
+        if (value <= 1.0) return; // reject low VMGs
+        if (arr.length >= 600) arr.shift(); // Keep up to 10 minutes at 1Hz
+
+        let lo = 0, hi = arr.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (arr[mid] < value) lo = mid + 1;
+            else hi = mid;
+        }
+        arr.splice(lo, 0, value);
+    }
+
+    function computeTimeToLine(cog, sog, lineBearing, toZoneVz, perpToLineVx, ocs, closestEnd) {
+
+        let vmgNormalSigned = 0;
+        let vmgTangentSigned = 0;
+
+        if (cog != null && sog != null) {
+            const lineBearingRad = toRadians(lineBearing);
+            if (lineBearingRad === null) {
+                return 0;
+            }
+
+            // Angle between boat COG and line bearing
+            const angleRad = cog - lineBearingRad;
+
+            // Signed VMG components from *current* COG/SOG
+            vmgNormalSigned = sog * Math.sin(angleRad); // normal to line
+            vmgTangentSigned = sog * Math.cos(angleRad); // along line (stb->port is +)
+        }
+
+        // 1. Effective VMG normal (perpendicular to line)
+        //
+        // History:
+        //  - if OCS, use vmgToLineNeg (away from line => back towards line in this case)
+        //  - otherwise, use vmgToLinePos
+        const histNormal = percentileFromSorted(ocs ? state.vmgToLineNeg : state.vmgToLinePos, 0.9);
+
+        // Instantaneous VMG in the *required* direction
+        // if we are OCS, then the required direction is the opposite of the effective direction
+        let vmgInstNormal = ocs ? -vmgNormalSigned : vmgNormalSigned;
+        const vmgEffNormal = Math.max(histNormal || 0, vmgInstNormal || 0);
+
+        // 2. Effective VMG along the line (towards the chosen zone entry)
+        let vmgHistParallel = 0;
+        let vmgInstParallel = 0;
+
+        if (toZoneVz > 0) {
+            if (closestEnd === 'port') {
+                // Coming from the pin end, we will sail from PORT towards STB
+                // => use STB-direction samples.
+                vmgHistParallel = percentileFromSorted(state.vmgToZoneStb, 0.9);
+                if (vmgTangentSigned < 0) {
+                    vmgInstParallel = -vmgTangentSigned; // towards stb
+                }
+            } else {
+                // Coming from the boat end, we will sail from STB towards PORT
+                // => use PORT-direction samples.
+                vmgHistParallel = percentileFromSorted(state.vmgToZonePort, 0.9);
+                if (vmgTangentSigned > 0) {
+                    vmgInstParallel = vmgTangentSigned; // towards port
+                }
+            }
+        }
+
+        const vmgEffectParallel = Math.max(vmgHistParallel || 0, vmgInstParallel || 0);
+
+        // 3. Combine legs: along to zone, then perpendicular to line
+        let ttl = 0;
+
+        // Outside the start zone: first go along the line (or zone boundary)
+        if (toZoneVz > 0 && vmgEffectParallel > 0) {
+            ttl += toZoneVz / vmgEffectParallel;
+        }
+
+        // Then go perpendicular to the line to actually hit it
+        if (perpToLineVx > 0 && vmgEffNormal > 0) {
+            ttl += perpToLineVx / vmgEffNormal;
+        }
+
+        app.debug(`computeTimeToLine: ${closestEnd} ${toZoneVz} ${perpToLineVx} ${vmgEffectParallel} ${vmgEffNormal} = ${ttl}`);
+        // If we still somehow have zero (no speed or distances), just return time to start so TTB logic doesn't explode.
+        return ttl <= 0 ? state.timeToStart : ttl;
+    }
+
+    function percentileFromSorted(arr, p) {
+        if (!arr || !arr.length) return 0;
+        const idx = Math.floor(p * (arr.length - 1));
+        return arr[idx];
+    }
+
     function processWind(twd) {
         if (!twd) {
             twd = app.getSelfPath('environment.wind.directionTrue');
@@ -689,7 +964,7 @@ module.exports = (app) => {
         sendDeltas([
             {path: 'navigation.racing.stbLineBias', value: bias},
             {path: 'navigation.racing.nextLegTrueWindAngle', value: toRadians(nextTwa)},
-        ]);
+        ].filter(entry => entry.value !== null && entry.value !== undefined));
     }
 
     function processRoute(activeRoute) {
@@ -762,12 +1037,24 @@ module.exports = (app) => {
             processPosition(null);
         }
     }
+    
+    function getStartLineOptions() {
+        app.debug("getStartLineOptions for ", state.startLineName);
+        for (const lineOption of state.options.lines) {
+            if (lineOption.startLineName === state.startLineName) {
+                app.debug("lineOption: ", JSON.stringify(lineOption));
+                return lineOption;
+            }
+        }
+        app.debug("lineOption: ", JSON.stringify(state.options));
+        return state.options;
+    }
 
     function getStartLine() {
         const stbEnd = app.getSelfPath(`navigation.racing.startLineStb`);
         const portEnd = app.getSelfPath(`navigation.racing.startLinePort`);
         if (stbEnd && stbEnd.value && portEnd && portEnd.value) {
-            startLine = { stb: stbEnd.value, port: portEnd.value};
+            let startLine = { stb: stbEnd.value, port: portEnd.value};
             startLine.length = geolib.getPreciseDistance(startLine.port, startLine.stb, 0.1);
             startLine.bearing = geolib.getRhumbLineBearing(startLine.stb, startLine.port);
             state.startLine = startLine;
@@ -780,7 +1067,7 @@ module.exports = (app) => {
     // Return the plugin
     return {
         id: 'signalk-racer',
-        name: 'SignalK Racing Plugin',
+        name: 'SignalK Racer',
         start: (options) => {
             if (!options.startLinePort || !options.startLineStb) {
                 app.error('Missing waypoint names: startLinePort and/or startLineStb not configured.');
@@ -798,6 +1085,7 @@ module.exports = (app) => {
             state.gpsFromCenter = fromCenter ? fromCenter.value : null;
             state.timeToStart = options.timer;
             state.startLine = getStartLine();
+            publishLineList();
 
             // Is the timer already started
             {
@@ -968,7 +1256,7 @@ module.exports = (app) => {
                                             });
                                             break;
                                         case 'navigation.racing.startLineStb' :
-                                            putStartLineEnd('port', v.value, ignored => {
+                                            putStartLineEnd('stb', v.value, ignored => {
                                             }, false).then(ignored => {
                                             });
                                             break;
@@ -985,6 +1273,7 @@ module.exports = (app) => {
             app.registerPutHandler('vessels.self', 'navigation.racing.startLineStb', (ctx, path, value, callback) => putStartLineEnd('stb', value, callback));
 
             // register to API paths for this plugin
+            app.registerPutHandler('vessels.self', 'navigation.racing.setStartLineName', setStartLineName);
             app.registerPutHandler('vessels.self', 'navigation.racing.setStartLine', setStartLine);
             app.registerPutHandler('vessels.self', 'navigation.racing.setStartTime', startTimeCommand);
         },

package/openapi.json

@@ -69,6 +69,80 @@
           }
         }
       }
+    },
+
+    "/signalk/v1/api/vessels/self/navigation/racing/lines": {
+      "get": {
+        "summary": "List available named start lines",
+        "description": "Returns the currently active start line and a list of configured line names with optional descriptions.",
+        "responses": {
+          "200": {
+            "description": "List of line names",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "startLineName": {
+                      "type": "string",
+                      "nullable": true,
+                      "description": "Currently selected line name, or null for default"
+                    },
+                    "lines": {
+                      "type": "array",
+                      "items": {
+                        "type": "object",
+                        "properties": {
+                          "startLineName": { "type": "string" },
+                          "startLineDescription": {
+                            "type": "string",
+                            "nullable": true
+                          }
+                        },
+                        "required": ["startLineName"]
+                      }
+                    }
+                  },
+                  "required": ["startLineName", "lines"]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+
+    "/signalk/v1/api/vessels/self/navigation/racing/setStartLineName": {
+      "put": {
+        "summary": "Select a named start line to use",
+        "description": "Set the active start line by name, or set null to revert to the default line.",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "startLineName": {
+                    "type": "string",
+                    "nullable": true,
+                    "description": "Line name to activate, or null to use the default"
+                  }
+                },
+                "required": ["startLineName"]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Active line updated"
+          },
+          "400": {
+            "description": "Invalid line name (not found)"
+          }
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "signalk-racer",
-  "version": "1.0.0",
-  "description": "Signalk plugin to calculate values of interest to sail racers: such as Time to Start, Time of Start, Distance to Line; Next leg TWA.",
+  "version": "1.1.0",
+  "description": "Signalk plugin to calculate values of interest to sail racers, such as: Time to Start; Time of Start, Time to Burn; Distance to Line; Next leg TWA.",
   "main": "index.js",
   "repository": {
     "type": "git",

package/public/index.html

@@ -10,8 +10,9 @@
             color: white; /* optional for visibility */
         }
 
-        .button-timer-command    { background-color: #041b8e; color: white; font-size: 1em; font-weight: bold; }
-        .button-timer-adjust   { background-color: #2196F3; color: white; }
+        .button-timer-command { background-color: #041b8e; color: white; font-size: 1em; font-weight: bold; }
+        .button-timer-adjust  { background-color: #2196F3; color: white; }
+
         button {
             padding: 1em 1em;
             font-size: 1em;
@@ -26,16 +27,13 @@
             margin: 1em auto;
             text-align: center;
         }
-        button {
-            padding: 1em 1em;
-            font-size: 1em;
-            cursor: pointer;
-        }
+
         input[readonly] {
             background: #eee;
             border: 1px solid #ccc;
             padding: 0.3em;
         }
+
         #status {
             margin-top: 1em;
             font-size: 1em;
@@ -49,6 +47,12 @@
         .stb-move    { background-color: #080; color: white;}
         .stb-rotate  { background-color: #080; color: white; }
 
+        #startLineSelect {
+            font-size: 1em;
+            padding: 0.3em;
+            margin-left: 0.5em;
+        }
+
     </style>
 </head>
 <body>
@@ -57,8 +61,10 @@
     let socket;
     let statusTimer;
     let startTime;
+
     function updateStatus(message) {
         const status = document.getElementById('status');
+        if (!status) return;
         status.textContent = message;
         if (statusTimer) clearTimeout(statusTimer);
         statusTimer = setTimeout(() => {
@@ -103,10 +109,10 @@
                     if (update.values) {
                         update.values.forEach(value => {
                             switch (value.path) {
-                                case "navigation.racing.startLineLength" :
+                                case "navigation.racing.startLineLength":
                                     // document.getElementById("lineLength").value = value.value.toFixed(1);
                                     break;
-                                case "navigation.racing.stbLineBias" :
+                                case "navigation.racing.stbLineBias":
                                     // document.getElementById("lineBias").value = value.value.toFixed(1);
                                     break;
                                 case "navigation.racing.timeToStart":
@@ -172,7 +178,98 @@
         updateStatus(`Sent ${delta}m ${rotate}° request for ${end}`);
     }
 
+    function loadStartLines() {
+        const url = window.location.origin +
+            '/signalk/v1/api/vessels/self/navigation/racing/lines';
+
+        fetch(url)
+            .then(res => {
+                if (!res.ok) {
+                    throw new Error('HTTP ' + res.status);
+                }
+                return res.json();
+            })
+            .then(data => {
+                const select = document.getElementById('startLineSelect');
+                if (!select) return;
+
+                // Clear existing options
+                select.innerHTML = '';
+
+                // Default option = "no named line"
+                const defaultOpt = document.createElement('option');
+                defaultOpt.value = '';
+                defaultOpt.textContent = 'Default line';
+                select.appendChild(defaultOpt);
+
+                const payload = data && data.value ? data.value : { lines: [], startLineName: null };
+                if (Array.isArray(payload.lines)) {
+                    payload.lines.forEach(line => {
+                        const opt = document.createElement('option');
+                        opt.value = line.startLineName;
+                        opt.textContent = line.startLineDescription
+                            ? `${line.startLineName} – ${line.startLineDescription}`
+                            : line.startLineName;
+                        select.appendChild(opt);
+                    });
+                }
+
+                // Preselect active
+                if (!payload.startLineName) {
+                    select.value = '';
+                } else {
+                    select.value = payload.startLineName;
+                    if (select.value !== payload.startLineName) {
+                        // In case active name not in the list
+                        select.value = '';
+                    }
+                }
+
+                updateStatus('Loaded start lines: ' + payload.lines.length + ' lines');
+            })
+            .catch(err => {
+                console.error('Failed to load start lines:', err);
+                updateStatus('Failed to load start lines: ' + err.message);
+            });
+    }
+
+    function setStartLineName(startLineName) {
+        const url = window.location.origin +
+            '/signalk/v1/api/vessels/self/navigation/racing/setStartLineName';
+
+        const body = {
+            value: {
+                startLineName: startLineName === '' ? null : startLineName
+            }
+        };
+
+        fetch(url, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        })
+            .then(res => {
+                if (!res.ok) {
+                    throw new Error('HTTP ' + res.status);
+                }
+                return res.json().catch(() => ({}));
+            })
+            .then(() => {
+                updateStatus(
+                    startLineName
+                        ? `Active line set to: ${startLineName}`
+                        : 'Active line set to Default'
+                );
+            })
+            .catch(err => {
+                console.error('Failed to set active line:', err);
+                updateStatus('Failed to set active line: ' + err.message);
+            });
+    }
+
+    // connect WS and load lines once the page is running
     connectWebSocket();
+    loadStartLines();
 
     function formatTimeToMMSS(seconds) {
         const mm = Math.floor(seconds / 60);
@@ -225,7 +322,7 @@
                     }
                 }
             }));
-            updateStatus(`Sent start time: ${startTime}`);
+            updateStatus(`Sent start time: ${date.toLocaleTimeString()}`);
         } catch (err) {
             console.log('Could not set start at ', err);
         }
@@ -278,10 +375,11 @@
     </div>
 </div>
 
-<!-- Timer Display -->
-<!-- div style="margin-top: 2em;">
-    <div id="timeToStart" style="font-size: 4em; font-weight: bold;">00:00</div>
-</div -->
+<!-- Start-line selector -->
+<div style="margin-top: 1em;">
+    <label for="startLineSelect">Start line:</label>
+    <select id="startLineSelect" onchange="setStartLineName(this.value)"></select>
+</div>
 
 <!-- Start Time Row -->
 <div style="margin-top: 1em; display: flex; justify-content: center; align-items: center; gap: 0.5em;">