signalk-racer 0.9.5 → 0.9.6

package/README.md

@@ -1,6 +1,6 @@
 # Signal K Racing Plugin
 
-This PROTOTYPPE plugin adds sail racing-relevant data calculations to a Signal K server. It focuses on real-time information useful during the start of a race, such as distance to the line, start line bias, and geographic position of the line ends.
+This PROTOTYPE plugin adds sail racing-relevant data calculations to a Signal K server. It focuses on real-time information useful during the start of a race, such as distance to the line, start line bias, and geographic position of the line ends.
 
 GitHub repository: [https://github.com/gregw/signalk-racer](https://github.com/gregw/signalk-racer)
 
@@ -10,17 +10,19 @@ GitHub repository: [https://github.com/gregw/signalk-racer](https://github.com/g
 
 This plugin calculates and publishes the following Signal K paths:
 
-| Path                                        | Description                                             | Units   | Schema |
-|---------------------------------------------|---------------------------------------------------------|---------|--------|
-| `navigation.racing.`<br/>`distanceStartline`       | Signed minimum distance from the bow to the start line  | `m`     | Y      |
-| `navigation.racing.`<br/>`startLineLength`         | Total length of the start line                          | `m`     |        |
-| `navigation.racing.`<br/>`stbLineBias`             | Bias of the start line toward the starboard end         | `m`     |        |
-| `navigation.racing.`<br/>`startLinePort.latitude`  | Latitude of the port (pin) end of the start line        | `deg`   | Y      |
-| `navigation.racing.`<br/>`startLinePort.longitude` | Longitude of the port (pin) end of the start line       | `deg`   | Y      |
-| `navigation.racing.`<br/>`startLineStb.latitude`   | Latitude of the starboard (boat) end of the start line  | `deg`   | Y      |
-| `navigation.racing.`<br/>`startLineStb.longitude`  | Longitude of the starboard (boat) end of the start line | `deg`   | Y      |
-| `navigation.racing.`<br/>`nextLegHeading`          | True heading for the next leg of the course             | `deg`   |        |
-| `navigation.racing.`<br/>`nextLegTWA`              | True Wind Angle for the next leg of the course          | `deg`   |        |
+| Path                                               | Description                                             | Units | Std |
+|----------------------------------------------------|---------------------------------------------------------|-------|-----|
+| `navigation.racing.`<br/>`distanceStartline`       | Signed minimum distance from the bow to the start line  | `m`   | Y   |
+| `navigation.racing.`<br/>`startLineLength`         | Total length of the start line                          | `m`   |     |
+| `navigation.racing.`<br/>`stbLineBias`             | Bias of the start line toward the starboard end         | `m`   |     |
+| `navigation.racing.`<br/>`startLinePort.latitude`  | Latitude of the port (pin) end of the start line        | `deg` | Y   |
+| `navigation.racing.`<br/>`startLinePort.longitude` | Longitude of the port (pin) end of the start line       | `deg` | Y   |
+| `navigation.racing.`<br/>`startLineStb.latitude`   | Latitude of the starboard (boat) end of the start line  | `deg` | Y   |
+| `navigation.racing.`<br/>`startLineStb.longitude`  | Longitude of the starboard (boat) end of the start line | `deg` | Y   |
+| `navigation.racing.`<br/>`nextLegHeading`          | True heading for the next leg of the course             | `deg` |     |
+| `navigation.racing.`<br/>`nextLegTWA`              | True Wind Angle for the next leg of the course          | `deg` |     |
+| `navigation.racing.`<br/>`timeToStart`             | Period of time until the race start                     | `s`   | Y   |
+| `navigation.racing.`<br/>`startTime`               | The start time as an ISO timestamp                      | `iso` |     |
 
 These values can be displayed in KIP, Freeboard-SK, or other Signal K clients.
 
@@ -28,18 +30,17 @@ These values can be displayed in KIP, Freeboard-SK, or other Signal K clients.
 
 ---
 
-
 ## ⚙️ Configuration
 
 You can configure the plugin via the Signal K web interface or by editing `settings.json` manually.
 
 ### Parameters:
 
-| Parameter          | Description                                                                           | Default       |
-|--------------------|---------------------------------------------------------------------------------------|---------------|
-| `startLineStb`     | Name of the waypoint for the starboard (committee boat) end of the line               | `"startBoat"` |
-| `startLinePort`    | Name of the waypoint for the port (pin) end of the line                               | `"startPin"`  |
-| `period`           | How often to update values (in milliseconds)                                          | `1000`        |
+| Parameter       | Description                                                              | Default       |
+|----------------|--------------------------------------------------------------------------|---------------|
+| `startLineStb`  | Name of the waypoint for the starboard (committee boat) end of the line | `"startBoat"` |
+| `startLinePort` | Name of the waypoint for the port (pin) end of the line                 | `"startPin"`  |
+| `period`        | How often to update values (in milliseconds)                            | `1000`        |
 
 ---
 
@@ -83,26 +84,48 @@ If `navigation.headingTrue` is not available, then `navigation.courseOverGroundT
 
 ---
 
-## 🌐 Start Line REST API
+## 🌐 API Access
+
+This plugin uses WebSocket-based PUT requests to Signal K model paths.
+
+### `navigation.racing.setStartLine`
 
-The plugin provides a REST API that allows external clients (e.g. KIP dashboards, mobile apps, or scripts) to **set or query the start line ends**. This can be used to "ping" the boat or pin end by calling a simple HTTP POST with or without a position.
+Used to **set** or **adjust** either end of the start line.
 
-The plugin supports **partial line configuration**: you can set just one end (port or starboard), and it will store and emit that end's position immediately. Once both ends are defined, the full line geometry (length, bearing, bias) will be calculated.
+#### Payload:
+```json
+{
+  "end": "port" | "stb",             
+  "position": "bow" | { "latitude": ..., "longitude": ... },  
+  "delta": 10,                       
+  "rotate": 0.1                      
+}
+```
 
-### 📮 API Endpoints
+- `end`: which end to modify.
+- `position`: `"bow"` or `{ latitude, longitude }`.
+- `delta`: distance in meters along bearing.
+- `rotate`: angle in radians.
+
+---
 
-| Method | Endpoint                                | Description                                                                                          |
-|--------|-----------------------------------------|------------------------------------------------------------------------------------------------------|
-| `GET`  | `/plugins/signalk-racer/startline/port` | Get the last known **port (pin)** end position                                                       |
-| `PUT`  | `/plugins/signalk-racer/startline/port` | Set the **port (pin)** end of the start line to the current position of the boat plus the bow offset |
-| `GET`  | `/plugins/signalk-racer/startline/stb`  | Get the last known **starboard (boat)** end position                                                 |
-| `PUT`  | `/plugins/signalk-racer/startline/stb`  | Set the **starboard (boat)** end of the line to the current position of the boat plus the bow offset |
-| `PUT`  | `/plugins/signalk-racer/timeToStart`    | Set the **timeToStart** in seconds and receive the current **distanceToLine**                        |
+### `navigation.racing.setStartTime`
 
+Used to **start**, **sync**, **reset**, or **set a fixed start time**.
+
+#### Payload:
+```json
+{
+  "command": "start" | "reset" | "sync" | "adjust" | "set",
+  "delta": 30,
+  "startTime": "2025-06-18T04:15:00Z"
+}
+```
+---
 
 ## 🔄 Dependencies
 
-- [geolib](https://github.com/manuelbieh/geolib): Used for all geospatial math, including distances, bearings, and projections.
+- `geolib`: for distance and bearing calculations.
 
 ---
 
@@ -111,11 +134,10 @@ The plugin supports **partial line configuration**: you can set just one end (po
 - Add calculations for:
 - **Time to line** (using STW and heading or polar speeds)
 - **Laylines** and distance/time to them
-- Include webapp UI for on-deck ease of "pinging" the line
+- A KIP widget as well as the webapp.
 - Better integration with **Freeboard-SK** and **KIP** dashboards
 
----
-
+--- 
 ## 📬 Feedback
 
 Bug reports and suggestions are welcome at  

package/ReleaseNotes.md

@@ -10,4 +10,9 @@
 ## 0.9.4 Trivial rename
  + Renamed README.md for npmjs
 ## 0.9.5 Restructured
- + Restructured the plugin to avoid initialization problem in new server
+ + Restructured the plugin to avoid initialization problem in new server
+## 0.9.6 V2 API and Timer
+ + Added new API V2 methods
+ + Removed V1 methods
+ + Webapp uses websocket
+ + Server side timer 

package/index.js

@@ -1,9 +1,8 @@
-const geolib = require("geolib");
 module.exports = (app) => {
     const state = {};
     const geolib = require('geolib')
     const racerSchema = {
-        title: 'Set System Time with sudo',
+        title: 'Signalk Racer Configuration',
         type: 'object',
         properties: {
             startLineStb: {
@@ -21,23 +20,11 @@ module.exports = (app) => {
                 title: 'Update period in micro seconds',
                 default: 1000
             },
-            /* TODO
-            speedToLine: {
+            timer: {
                 type: 'number',
-                title: 'The percentage of the best STW seen during the start period to use when calculating the time to the start line. This assumes the boat can sail slower than its best speed at most wind angles. Or -1 to use the current STW',
-                default: 80
+                title: 'Timer default period in seconds',
+                default: 300
             },
-            twaUpToLine: {
-                type: 'number',
-                title: 'The upwind TWA to use when calculating the time to the line, or -1 to use the best achieved during the start period',
-                default: 45
-            },
-            twaDownToLine: {
-                type: 'number',
-                title: 'The downwind TWA to use when calculating the time to the line, or -1 to use the best achieved during the start period',
-                default: 155
-            },
-             */
         }
     }
 
@@ -159,108 +146,277 @@ module.exports = (app) => {
         return bow;
     }
 
-    async function setTimeToStart(req, res) {
-        try {
-            const body = req.body;
-            if (!body || typeof body.timeToStart !== 'number') {
-                res.status(400).json({ error: 'Missing or invalid `timeToStart`' });
-                return;
-            }
-
-            const timeToStart = body.timeToStart; // value in seconds, or whatever unit you agree on
-            app.debug(`Setting timeToStart to ${timeToStart}`);
-
-            sendDeltas([
-                {path: 'navigation.racing.timeToStart', value: timeToStart},
-            ]);
-
-            res.json({
-                message: 'OK',
-                timeToStart,
-                distanceToLine: state.distanceToLine ? state.distanceToLine : null,
-            });
-        } catch (err) {
-            app.error('Failed to set time to start:', err);
-            res.status(500).json({ error: 'Failed to set time to start' });
-        }
+    function camelCase(name) {
+        return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
     }
 
-    async function setStartLineEnd(req, res) {
+    async function setStartLine(context, path, value, cb) {
         try {
-            const end = req.params.end;  // "port" or "stb"
+            app.debug('setStartLine:', JSON.stringify(value));
+            if (!value || !value.end || typeof value.end !== 'string') {
+                app.error('Failed to set start line: !value.end');
+                cb(null, {state: 'FAILED'});
+            }
+            const end = value.end.toLowerCase();
             if (end !== 'port' && end !== 'stb') {
-                res.status(400).send({error: 'End must be "port" or "stb"'});
-                return;
+                app.error('Failed to set start line: unknown end');
+                cb(null, {state: 'FAILED'});
             }
 
-            let position = app.getSelfPath('navigation.position');
-            if (position)
-                position = position.value;
-            else {
-                res.status(500).send({error: 'No valid position available'});
-                return;
+            // Get the position either as arg or of the current bow postion
+            let position = value.position;
+            if (position === 'bow') {
+                position = app.getSelfPath('navigation.position');
+                if (position)
+                    position = bowPosition(position.value);
             }
-            const bow = bowPosition(position);
+
+            app.debug(`setStartLine[${end}] = ${JSON.stringify(position)} before translation/rotation`);
             const startLine = state.startLine;
-            const waypointName = state.options[`startLine${end.charAt(0).toUpperCase() + end.slice(1)}`];
-
-            let waypointId = startLine ? startLine[end + 'Id'] : null;
-            if (!waypointId) {
-                // Get the ID of the last existing waypoint with the given name.
-                const waypoints = await app.resourcesApi.listResources('waypoints', {});
-                for (const [id, resource] of Object.entries(waypoints)) {
-                    if (resource.name === waypointName) {
-                        waypointId = id;
-                        // don't break here as we want the last waypoint with the given name
-                    }
-                }
+
+            // Do any rotations or length changes
+            if (startLine && (value.delta || value.rotate)) {
+                app.debug(`setStartLine[${end}] translate ${value.delta} and rotate ${value.rotate} of ${JSON.stringify(startLine)}`);
+                const fixedEnd = startLine[end === 'port' ? 'stb' : 'port'];
+                const movingEnd = position ? position : startLine[end];
+                app.debug(`fixedEnd: ${JSON.stringify(fixedEnd)} movingEnd: ${JSON.stringify(movingEnd)}`);
+
+                const initialBearing = geolib.getRhumbLineBearing(fixedEnd, movingEnd);
+                const currentDistance = geolib.getDistance(fixedEnd, movingEnd);
+                app.debug(`initialBearing: ${initialBearing} currentDistance: ${currentDistance}`);
+
+                const newDistance = value.delta && typeof value.delta === 'number' ? (currentDistance + value.delta) : currentDistance;
+                const newBearing = value.rotate && typeof value.rotate === 'number'? (initialBearing + toDegrees(value.rotate)) : initialBearing;
+                app.debug(`newDistance: ${newDistance} newBearing: ${newBearing}`);
+
+                const newPosition = geolib.computeDestinationPoint(fixedEnd, newDistance, newBearing);
+                app.debug(`Moved/Rotated ${end} from ${JSON.stringify(position)} to ${JSON.stringify(newPosition)}`);
+                position = newPosition;
             }
 
-            app.debug(`POSITION to set ${end}(${waypointName}/${waypointId}): ${JSON.stringify(bow)}`);
+            if (position) {
+                app.debug('position:' + JSON.stringify(position));
+                const waypointConfig =`startLine${camelCase(end)}`;
+                app.debug(`waypointConfig: ${waypointConfig}`);
+                const waypointName = state.options[waypointConfig];
+                app.debug(`waypointName: ${waypointName}`);
+                let waypointId = startLine ? startLine[end + 'Id'] : null;
+                app.debug(`waypointId: ${waypointId}`);
+
+                if (!waypointId) {
+                    // Get the ID of the last existing waypoint with the given name.
+                    const waypoints = await app.resourcesApi.listResources('waypoints', {});
+                    for (const [id, resource] of Object.entries(waypoints)) {
+                        if (resource.name === waypointName) {
+                            waypointId = id;
+                            // don't break here as we want the last waypoint with the given name
+                        }
+                    }
+                    app.debug(`waypointId: ${waypointId}`);
+                }
 
-            const waypoint = {
-                name: waypointName,
-                feature: {
-                    type: 'Feature',
-                    geometry: {
-                        type: 'Point',
-                        coordinates: [bow.longitude, bow.latitude]
-                    },
-                    properties: {}
+                app.debug(`POSITION to set ${end}(${waypointName}/${waypointId}): ${JSON.stringify(position)}`);
+
+                const waypoint = {
+                    name: waypointName,
+                    feature: {
+                        type: 'Feature',
+                        geometry: {
+                            type: 'Point',
+                            coordinates: [position.longitude, position.latitude]
+                        },
+                        properties: {}
+                    }
                 }
-            }
 
-            app.debug(`waypoint: ${waypointId} -> ${end}/${waypointName} : ${JSON.stringify(waypoint)}`);
+                app.debug(`waypoint: ${waypointId} -> ${end}/${waypointName} : ${JSON.stringify(waypoint)}`);
 
-            if (waypointId)
-                await app.resourcesApi.setResource('waypoints', waypointId, waypoint);
-            else
-                await app.resourcesApi.createResource('waypoints', waypoint);
+                if (waypointId)
+                    await app.resourcesApi.setResource('waypoints', waypointId, waypoint);
+                else
+                    await app.resourcesApi.createResource('waypoints', waypoint);
+            }
 
-            res.json({
-                message: 'OK'
+            cb(null, {
+                state: 'COMPLETED',
+                result: {
+                    distanceToStart: state.distanceToLine ? state.distanceToLine : null,
+                }
             });
 
-            if (startLine)
-            {
-                const newStartLine = { ...state.startLine };
+            if (startLine) {
+                const newStartLine = {...state.startLine};
                 newStartLine[end + 'Id'] = waypointId;
-                newStartLine[end] = bow;
+                newStartLine[end] = position;
                 startLine.length = geolib.getPreciseDistance(newStartLine.port, newStartLine.stb, 0.1);
                 startLine.bearing = geolib.getRhumbLineBearing(newStartLine.stb, newStartLine.port);
                 state.startLine = newStartLine;
                 sendDeltas([
-                    { path: `navigation.racing.startLine${end.charAt(0).toUpperCase() + end.slice(1)}`, value: bow },
-                    { path: 'navigation.racing.startLineLength', value: newStartLine.length },
+                    {path: `navigation.racing.startLine${end.charAt(0).toUpperCase() + end.slice(1)}`, value: position},
+                    {path: 'navigation.racing.startLineLength', value: newStartLine.length},
                 ]);
 
-                processPosition(position);
+                processPosition(null);
             } else {
-                findLineAndThenProcess(position, true);
+                findLineAndThenProcess(null, true);
+            }
+        } catch (err) {
+            app.error('Failed to set start line end:', JSON.stringify(err));
+            cb(null, {state: 'FAILED'});
+            throw err;
+        }
+    }
+
+    async function startTimeCommand(context, path, value, cb) {
+        // start / reset / sync
+        try {
+            app.debug('startTimerCommand:', JSON.stringify(value));
+            if (!value || !value.command || typeof value.command !== 'string') {
+                app.error('Failed to command start timer: ' + JSON.stringify(value));
+                cb(null, {state: 'FAILED'});
+            }
+            const command = value.command.toLowerCase();
+
+            switch (command)
+            {
+                case 'start': {
+                    const now = new Date();
+                    const timeToStart = state.timeToStart ?? state.options.timer ?? 300;
+                    const startTimestamp = new Date(now.getTime() + timeToStart * 1000).toISOString();
+
+                    state.timerRunning = true;
+                    state.startTime = startTimestamp;
+                    state.timeToStart = timeToStart;
+
+                    sendDeltas([
+                        {path: 'navigation.racing.startTime', value: startTimestamp},
+                        {path: 'navigation.racing.timeToStart', value: timeToStart}
+                    ]);
+
+                    if (state.timerInterval) clearInterval(state.timerInterval);
+                    state.timerInterval = setInterval(() => {
+                        if (!state.timerRunning || state.timeToStart <= 0) {
+                            clearInterval(state.timerInterval);
+                            return;
+                        }
+                        state.timeToStart--;
+                        sendDeltas([{path: 'navigation.racing.timeToStart', value: state.timeToStart}]);
+                    }, 1000);
+                    cb(null, {state: 'COMPLETED'});
+                    break;
+                }
+                case 'reset': {
+                    state.timerRunning = false;
+                    state.timeToStart = state.options.timer ?? 300;
+                    if (state.timerInterval) clearInterval(state.timerInterval);
+
+                    sendDeltas([
+                        {path: 'navigation.racing.timeToStart', value: state.timeToStart},
+                        {path: 'navigation.racing.startTime', value: null}
+                    ]);
+                    cb(null, {state: 'COMPLETED'});
+                    break;
+                }
+
+                case 'sync': {
+                    if (!state.timerRunning || state.timeToStart == null) {
+                        cb(null, { state: 'FAILED', message: 'Timer not running' });
+                        return;
+                    }
+
+                    const rounded = Math.round(state.timeToStart / 60) * 60;
+                    state.timeToStart = rounded;
+                    state.startTime = new Date(Date.now() + rounded * 1000).toISOString();
+
+                    sendDeltas([
+                        { path: 'navigation.racing.timeToStart', value: state.timeToStart },
+                        { path: 'navigation.racing.startTime', value: state.startTime }
+                    ]);
+                    cb(null, { state: 'COMPLETED' });
+                    break;
+                }
+
+                case 'set': {
+                    const input = value.startTime;
+                    if (!input) {
+                        cb(null, { state: 'FAILED', message: 'Missing startTime' });
+                        return;
+                    }
+
+                    const inputTime = new Date(input);
+                    if (isNaN(inputTime)) {
+                        cb(null, { state: 'FAILED', message: 'Invalid startTime format' });
+                        return;
+                    }
+
+                    const now = new Date();
+                    const diff = Math.floor((inputTime - now) / 1000);
+
+                    if (diff <= 0) {
+                        state.timerRunning = false;
+                        state.timeToStart = 0;
+                        state.startTime = null;
+                        sendDeltas([
+                            { path: 'navigation.racing.timeToStart', value: 0 },
+                            { path: 'navigation.racing.startTime', value: null }
+                        ]);
+                        cb(null, { state: 'COMPLETED' });
+                        return;
+                    }
+
+                    state.timerRunning = true;
+                    state.timeToStart = diff;
+                    state.startTime = inputTime.toISOString();
+
+                    sendDeltas([
+                        { path: 'navigation.racing.timeToStart', value: state.timeToStart },
+                        { path: 'navigation.racing.startTime', value: state.startTime }
+                    ]);
+
+                    if (state.timerInterval) clearInterval(state.timerInterval);
+                    state.timerInterval = setInterval(() => {
+                        if (!state.timerRunning || state.timeToStart <= 0) {
+                            clearInterval(state.timerInterval);
+                            return;
+                        }
+                        state.timeToStart--;
+                        sendDeltas([{ path: 'navigation.racing.timeToStart', value: state.timeToStart }]);
+                    }, 1000);
+                    cb(null, { state: 'COMPLETED' });
+                    break;
+                }
+
+                case 'adjust': {
+                    const delta = Number(value.delta);
+                    if (isNaN(delta) || state.timeToStart == null || !state.startTime) {
+                        cb(null, { state: 'FAILED', message: 'Cannot adjust: invalid state or delta' });
+                        return;
+                    }
+
+                    state.timeToStart += delta;
+                    if (state.timeToStart < 0) state.timeToStart = 0;
+
+                    const adjustedStart = new Date(Date.now() + state.timeToStart * 1000).toISOString();
+                    state.startTime = adjustedStart;
+
+                    sendDeltas([
+                        { path: 'navigation.racing.timeToStart', value: state.timeToStart },
+                        { path: 'navigation.racing.startTime', value: adjustedStart }
+                    ]);
+                    cb(null, { state: 'COMPLETED' });
+                    break;
+                }
+
+                default : {
+                    app.error('Unknown command to start timer: ' + command);
+                    cb(null, {state: 'FAILED'});
+                    return;
+                }
             }
         } catch (err) {
-            app.error('Failed to set start line end:', err);
-            res.status(500).json({ error: 'Failed to set start line end' });
+            app.error('Failed to set start line end:', JSON.stringify(err));
+            cb(null, {state: 'FAILED'});
+            throw err;
         }
     }
 
@@ -474,6 +630,9 @@ module.exports = (app) => {
             state.wayPointsScanned = false;
             state.gpsFromBow = fromBow ? fromBow.value : null;
             state.gpsFromCenter = fromCenter ? fromCenter.value : null;
+            state.timeToStart = options.timer;
+
+            sendDeltas([{path: 'navigation.racing.timeToStart', value: state.timeToStart}]);
 
             // Subscribe to position updates.
             app.subscriptionmanager.subscribe(
@@ -598,6 +757,9 @@ module.exports = (app) => {
                         processRoute(route);
                 }
             );
+
+            app.registerPutHandler('vessels.self', 'navigation.racing.setStartLine', setStartLine);
+            app.registerPutHandler('vessels.self', 'navigation.racing.setStartTime', startTimeCommand);
         },
 
         stop: () => {
@@ -607,13 +769,6 @@ module.exports = (app) => {
 
         schema: () => racerSchema,
 
-        registerWithRouter: (router) => {
-            router.get('/startline/port', (req, res) => res.json(state.startLine ? state.startLine.port : null));
-            router.get('/startline/stb', (req, res) => res.json(state.startLine ? state.startLine.stb : null));
-            router.put('/startline/:end', setStartLineEnd);
-            router.put('/timeToStart', setTimeToStart);
-        },
-
         getOpenApi: () => require('./openapi.json'),
     };
 };

package/openapi.json

@@ -1,39 +1,49 @@
 {
-  "openapi": "3.0.0",
-  "info": {
-    "version": "0.0.1",
-    "title": "Signal K Demo/Test Plugin OpenApi",
-    "license": {
-      "name": "Apache 2.0",
-      "url": "http://www.apache.org/licenses/LICENSE-2.0.html"
-    }
-  },
   "paths": {
-    "/startline/port": {
-      "get": {
-        "summary": "Set the port end of the start line",
-        "responses": {
-          "200": {
-            "description": "Port end set"
-          }
-        }
-      }
-    },
-    "/startline/stb": {
+    "/signalk/v1/api/vessels/self/navigation/racing/setStartLine": {
       "put": {
-        "summary": "Set the starboard end of the start line",
-        "description": "Set the starboard end of the start line to the boats position plus the bow offset.",
+        "summary": "Set or Adjust Start Line End",
+        "description": "Set or adjust the port/stb end of the line. Provide `end`, optionally `position`, `delta`, and/or `rotate`.",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "end": { "type": "string", "enum": ["port", "stb"] },"position": {
+                    "oneOf": [
+                      { "type": "string", "enum": ["bow"] },
+                      {
+                        "type": "object",
+                        "properties": {
+                          "latitude": { "type": "number" },
+                          "longitude": { "type": "number" }
+                        },
+                        "required": ["latitude", "longitude"]
+                      }
+                    ],
+                    "description": "Either the string 'bow', or an object with latitude/longitude"
+                  },
+                  "delta": { "type": "number", "description": "Distance in meters to move the end along line bearing" },
+                  "rotate": { "type": "number", "description": "Angle in radians to rotate end around the opposite end" }
+                },
+                "required": ["end"]
+              }
+            }
+          }
+        },
         "responses": {
           "200": {
-            "description": "Starboard end set"
+            "description": "Start line modified"
           }
         }
       }
     },
-    "/timeToStart": {
+    "/signalk/v1/api/vessels/self/navigation/racing/setStartTime": {
       "put": {
-        "summary": "Set time to start",
-        "description": "Update the countdown timer value used for start line calculations.",
+        "summary": "Set, Adjust or Command the Timer",
+        "description": "Set start time or send commands to the timer ('start', 'reset', 'sync', or 'adjust').",
         "requestBody": {
           "required": true,
           "content": {
@@ -41,43 +51,24 @@
               "schema": {
                 "type": "object",
                 "properties": {
-                  "timeToStart": {
-                    "type": "number",
-                    "description": "Time to start in seconds"
-                  }
+                  "command": {
+                    "type": "string",
+                    "enum": ["start", "reset", "sync", "adjust", "set"]
+                  },
+                  "delta": { "type": "number", "description": "Time offset in seconds (for adjust)" },
+                  "startTime": { "type": "string", "format": "date-time", "description": "ISO start time (for set)" }
                 },
-                "required": [
-                  "timeToStart"
-                ]
+                "required": ["command"]
               }
             }
           }
         },
         "responses": {
           "200": {
-            "description": "Time to start set",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "message": { "type": "string" },
-                    "timeToStart": {
-                      "type": "number",
-                      "description": "Time to start in seconds"
-                    },
-                    "distanceToLine": {
-                      "type": "number",
-                      "description": "Distance to the line in meters"
-                    }
-                  },
-                  "required": ["message", "timeToStart"]
-                }
-              }
-            }
+            "description": "Timer command executed"
           }
         }
       }
     }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-racer",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Signalk plugin to calculate values of interest to sail racers: such as Distance to Line; Next leg TWA.",
   "main": "index.js",
   "scripts": {

package/public/index.html

@@ -2,8 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <title>SignalK Racer</title>
+    <title>SignalK Racer Control</title>
     <style>
+        .button-timer-command    { background-color: #041b8e; color: white; }
+        .button-timer-adjust   { background-color: #2196F3; color: white; }
+        button {
+            padding: 1em 1.5em;
+            font-size: 1em;
+            cursor: pointer;
+            border: none;
+            border-radius: 4px;
+        }
+
         body {
             font-family: sans-serif;
             max-width: 100%;
@@ -11,43 +21,301 @@
             text-align: center;
         }
         button {
-            padding: 1em 2em;
-            margin: 1em;
-            font-size: 1.2em;
+            padding: 1em 1.5em;
+            font-size: 1em;
             cursor: pointer;
         }
+        input[readonly] {
+            background: #eee;
+            border: 1px solid #ccc;
+            padding: 0.3em;
+        }
         #status {
             margin-top: 2em;
             font-size: 1em;
             color: green;
         }
+
+        .port-set    { background-color: #f88; color: black; }
+        .port-move   { background-color: #a00; color: white; }
+        .port-tweak   { background-color: #f44; color: white; }
+        .port-rotate { background-color: #a00; color: white; }
+        .stb-set     { background-color: #8f8; color: black; }
+        .stb-move    { background-color: #080; color: white; }
+        .stb-tweak    { background-color: #4c4; color: white; }
+        .stb-rotate  { background-color: #080; color: white; }
+
     </style>
 </head>
 <body>
-<h1>Set Start Line Ends</h1>
-<div id="buttons">
-  <button onclick="setEnd('port')">Set Port End (Pin)</button><button onclick="setEnd('stb')">Set Starboard End (Boat)</button>
-</div>
-<div id="status"></div>
 
 <script>
-    async function setEnd(end) {
-        const url = `/plugins/signalk-racer/startline/${end}`;
-        document.getElementById('status').textContent = `Sending request to ${url}...`;
-
-        try {
-            const res = await fetch(url, { method: 'PUT' });
-            if (res.ok) {
-                const data = await res.json();
-                document.getElementById('status').textContent = `✅ ${end.toUpperCase()} set at bow position.`;
-            } else {
-                const err = await res.text();
-                throw new Error(`Error ${res.status}: ${err}`);
+    let socket;
+    let statusTimer;
+    let startTime;
+    function updateStatus(message) {
+        const status = document.getElementById('status');
+        status.textContent = message;
+        if (statusTimer) clearTimeout(statusTimer);
+        statusTimer = setTimeout(() => {
+            if (status.textContent === message) {
+                status.textContent = '-';
+            }
+        }, 10000);
+    }
+
+    function toRadians(degrees) {
+        return degrees ? degrees * (Math.PI / 180) : null;
+    }
+
+    function connectWebSocket() {
+        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const socketUrl = protocol + '//' + window.location.host + '/signalk/v1/stream?subscribe=none';
+        socket = new WebSocket(socketUrl);
+
+        socket.onopen = () => {
+            updateStatus('✅ Connected to Signal K server');
+            socket.send(JSON.stringify({
+                context: "vessels.self",
+                subscribe: [
+                    {
+                        path: "navigation.racing.*",
+                        policy: "instant"
+                    }
+                ]
+            }));
+        };
+
+        socket.onerror = (err) => updateStatus('❌ WebSocket error: ' + err.message);
+        socket.onclose = () => {
+            updateStatus('❌ Disconnected. Retrying in 5s...');
+            setTimeout(connectWebSocket, 5000);
+        };
+
+        socket.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            if (data.updates) {
+                data.updates.forEach(update => {
+                    if (update.values) {
+                        update.values.forEach(value => {
+                            if (value.path === "navigation.racing.startLineLength") {
+                                document.getElementById("lineLength").value = value.value.toFixed(1);
+                            } else if (value.path === "navigation.racing.stbLineBias") {
+                                document.getElementById("lineBias").value = value.value.toFixed(1);
+                            } else if (value.path === "navigation.racing.timeToStart") {
+                                document.getElementById('timeToStart').textContent = formatTimeToMMSS(value.value);
+                            } else if (value.path === "navigation.racing.startTime") {
+                                if (!value.value) {
+                                    document.getElementById('startTime').value = "HH:MM:SS";
+                                } else {
+                                    startTime = new Date(value.value); // handles ISO 8601 format
+                                    document.getElementById('startTime').value =
+                                        startTime.toLocaleTimeString([], {
+                                            hour: '2-digit',
+                                            minute: '2-digit',
+                                            second: '2-digit'
+                                        });
+                                }
+                            } else {
+                                console.log("Received value: " + value.path + " = " + JSON.stringify(value.value));
+                            }
+                        });
+                    }
+                });
             }
-        } catch (e) {
-            document.getElementById('status').textContent = `❌ Failed: ${e.message}`;
+        };
+    }
+
+    function sendSetStartLine(end) {
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            updateStatus('❌ WebSocket not connected.');
+            return;
         }
+        let message = JSON.stringify({
+            context: 'vessels.self',
+            put: {
+                path: 'navigation.racing.setStartLine',
+                value: { end, position : 'bow'}
+            }
+        });
+        console.log("sendSetStartLine: " + message);
+        socket.send(message);
+        updateStatus(`⏳ Sent request to set ${end}`);
     }
+
+    function sendAdjustStartLine(end, delta, rotate) {
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            updateStatus('❌ WebSocket not connected.');
+            return;
+        }
+        const message = JSON.stringify({
+            context: 'vessels.self',
+            put: {
+                path: 'navigation.racing.setStartLine',
+                value: { end, delta, rotate : rotate ? toRadians(rotate) : null }
+            }
+        });
+        console.log("sendAdjustStartLine: " + message);
+        socket.send(message);
+        updateStatus(`⏳ Sent ${delta}m ${rotate}° request for ${end}`);
+    }
+
+    connectWebSocket();
+
+    function formatTimeToMMSS(seconds) {
+        const mm = Math.floor(seconds / 60);
+        const ss = Math.floor(seconds % 60);
+        return `${mm.toString().padStart(2, '0')}:${ss.toString().padStart(2, '0')}`;
+    }
+
+    function adjustStartTime(deltaSeconds) {
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            updateStatus('❌ WebSocket not connected.');
+            return;
+        }
+        socket.send(JSON.stringify({
+            context: 'vessels.self',
+            put: {
+                path: 'navigation.racing.setStartTime',
+                value: {
+                    command: 'adjust',
+                    delta: deltaSeconds
+                }
+            }
+        }));
+        updateStatus(`⏳ Sent delta timeToStart: ${deltaSeconds} sec`);
+    }
+
+    function setStartTime() {
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            updateStatus('❌ WebSocket not connected.');
+            return;
+        }
+
+        const date = startTime ? new Date(startTime) : new Date();
+        const [hours, minutes, seconds] = document.getElementById('startTime').value.split(':').map(Number);
+        date.setHours(hours, minutes, seconds, 0);
+
+        socket.send(JSON.stringify({
+            context: 'vessels.self',
+            put: {
+                path: 'navigation.racing.setStartTime',
+                value: {
+                    command: 'set',
+                    startTime : date.toISOString(),
+                }
+            }
+        }));
+        updateStatus(`⏳ Sent start time: ${startTime}`);
+    }
+
+    function sendTimerCommand(command) {
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            updateStatus('❌ WebSocket not connected.');
+            return;
+        }
+        socket.send(JSON.stringify({
+            context: 'vessels.self',
+            put: {
+                path: 'navigation.racing.setStartTime',
+                value: { command }
+            }
+        }));
+        updateStatus(`⏳ Sent timer command: ${command}`);
+    }
+
+    setInterval(() => {
+        if (timeToStart !== null && timeToStart > 0) {
+            timeToStart--;
+            updateTimerDisplay();
+        }
+    }, 1000);
+
 </script>
+
+<h1>Adjust Start Line</h1>
+<div style="display: flex; justify-content: center; align-items: center; gap: 3em; flex-wrap: wrap;">
+
+
+    <div style="display: grid; grid-template-columns: repeat(11, auto); grid-template-rows: repeat(3, auto); gap: 0.5em;">
+        <div></div>
+        <div></div>
+        <button class="port-rotate" onclick="sendAdjustStartLine('port', 0, 1)">+1°</button>
+        <div></div>
+        <div></div>
+
+        <div></div>
+
+        <div></div>
+        <div></div>
+        <button class="stb-rotate" onclick="sendAdjustStartLine('stb', 0, -1)">+1°</button>
+        <div></div>
+        <div></div>
+
+        <!--------->
+
+        <button class="port-move" onclick="sendAdjustStartLine('port', 10, 0)">+10m</button>
+        <button class="port-tweak" onclick="sendAdjustStartLine('port', 1, 0)">+1m</button>
+        <button class="port-set" onclick="sendSetStartLine('port')">Port<br/>(pin)</button>
+        <button class="port-tweak" onclick="sendAdjustStartLine('port', -1, 0)">-1m</button>
+        <button class="port-move" onclick="sendAdjustStartLine('port', -10, 0)">-10m</button>
+
+        <div style="display: flex; flex-direction: column; align-items: center; justify-content: center;">
+            ---------------<br/>
+            <label><input id="lineLength" readonly style="width: 5em; text-align: center;">(m)</label>
+        </div>
+
+        <button class="stb-move" onclick="sendAdjustStartLine('stb', -10, 0)">-10m</button>
+        <button class="stb-tweak" onclick="sendAdjustStartLine('stb', -1, 0)">-1m</button>
+        <button class="stb-set" onclick="sendSetStartLine('stb')">Starboard<br/>(boat)</button>
+        <button class="stb-tweak" onclick="sendAdjustStartLine('stb', 1, 0)">+1m</button>
+        <button class="stb-move" onclick="sendAdjustStartLine('stb', +10, 0)">+10m</button>
+
+        <!--------->
+
+        <div></div>
+        <div></div>
+        <button class="port-rotate" onclick="sendAdjustStartLine('port', 0, -1)">-1°</button>
+        <div></div>
+        <div></div>
+
+        <div style="display: flex; flex-direction: column; align-items: center; justify-content: center;">
+            <label>Bias: <input id="lineBias" readonly style="width: 5em; text-align: center;">(m)</label>
+        </div>
+
+        <div></div>
+        <div></div>
+        <button class="stb-rotate" onclick="sendAdjustStartLine('stb', 0, 1)">-1°</button>
+        <div></div>
+        <div></div>
+    </div>
+
+
+</div>
+
+<div id="status">Connecting...</div>
+
+<!-- Timer Display -->
+<div style="margin-top: 2em;">
+    <div id="timeToStart" style="font-size: 3em; font-weight: bold;">00:00</div>
+</div>
+
+<!-- Start Time Row -->
+<div style="margin-top: 1em; display: flex; justify-content: center; align-items: center; gap: 1em;">
+    <button class="button-timer-adjust" onclick="adjustStartTime(-60)">-1 min</button>
+    <button class="button-timer-adjust" onclick="adjustStartTime(-1)">-1s</button>
+    <label for="startTime">Start at: <input id="startTime" style="font-size: 1.5em; width: 10em; text-align: center;"></label>
+    <button class="button-timer-adjust" onclick="adjustStartTime(1)">+1s</button>
+    <button class="button-timer-adjust" onclick="adjustStartTime(60)">+1 min</button>
+</div>
+
+<!-- Timer Control Buttons -->
+<div style="margin-top: 1em;">
+    <button class="button-timer-command" onclick="sendTimerCommand('start')">Start</button>
+    <button class="button-timer-command" onclick="setStartTime()">Start At</button>
+    <button class="button-timer-command" onclick="sendTimerCommand('sync')">Sync</button>
+    <button class="button-timer-command" onclick="sendTimerCommand('reset')">Reset</button>
+</div>
+
 </body>
 </html>