signalk-polar-performance-plugin 0.0.10 → 0.0.13

package/README.md

@@ -33,11 +33,13 @@ In the plugin configuration you can toggle the following options:
  - Polar Speed Ratio (performance.polarSpeedRatio)
  - Plugin option to use SOG as boat speed
  - Wind angle for maximum speed at this wind speed
+ - Fill up the ends of the polar diagram
 
 ### To-do list
- - Fill up the ends of the polar diagram
  - Improved interpolation
  - Make moment to do calculation smarter/configurable
+ - API to see JSON of polar
+ - Visualisation of the polar diagram
  - Create polar from live data
  -- Save polar info to file
  -- Save new record speed for angle in polar
@@ -46,7 +48,6 @@ In the plugin configuration you can toggle the following options:
  -- Configure the resolution of the polar diagram
  - Support multiple polar diagrams
  - Capture heel in polar diagram
- - Visualisation of the polar diagram
 
 ## MFD configuration
 
@@ -59,15 +60,15 @@ To get the values calculated by this plugin from SignalK to your B&G MFD/Triton2
 To see lay lines you need to set:
  - Settings -> Chart -> Laylines -> Targets... -> True wind angle to 'Actual'
 
- ![](doc/BandG_Laylines_Target_TWA_to_Active.png)
+ ![](https://raw.githubusercontent.com/htool/signalk-polar-performance-plugin/main/doc/BandG_Laylines_Target_TWA_to_Active.png)
 
  - SailSteer screen -> Long press tile to add 'Performance -> Target TWA -> decollapse, choose SignalK'
 
- ![](doc/BandG_Target_TWA_to_SignalK.png)
+ ![](https://raw.githubusercontent.com/htool/signalk-polar-performance-plugin/main/doc/BandG_Target_TWA_to_SignalK.png)
 
 Now the Target TWA is coming from SignalK and the laylines will be drawn based on it's value.
 
-![](doc/BandG_Sailsteer_with_laylines.png)
+![](https://raw.githubusercontent.com/htool/signalk-polar-performance-plugin/main/doc/BandG_Sailsteer_with_laylines.png)
 
 ### Raymarine
 If you have a Raymarine MFD and can tell more about this, please add to the README or tell me.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-polar-performance-plugin",
-  "version": "0.0.10",
+  "version": "0.0.13",
   "description": "A plugin that calculates performance information based on a (CSV) polar diagram.",
   "main": "plugin/index.js",
   "scripts": {

package/plugin/index.js

@@ -61,8 +61,7 @@ module.exports = function (app) {
    
     // Global variables
     var BSP, STW, TWA, TWS, port // Angles in rad, speed in m/s
-    var Pi = Math.PI
-    var halfPi = Pi / 2
+    var halfPi = Math.PI / 2
 
     // Subscribe to paths
     let localSubscription = {
@@ -195,79 +194,106 @@ module.exports = function (app) {
           let gap = upper - lower
           let twsGapRatio = (1 / gap) * (TWS - lower)
           //app.debug('twsGapRatio: %d', twsGapRatio)
-	          // Calculate beat/run angle
+	        // Calculate beat/run angle
 	        if (TWA < halfPi) {
             // app.debug('Upwind')
             if (options.beatAngle == true) {
-	            // Calculate beat angle
-	            let beatLower = polar[indexTWS]['Beat angle']
-	            let beatUpper = polar[indexTWS+1]['Beat angle']
-	            performance.beatAngle = beatLower + ((beatUpper - beatLower) * twsGapRatio)
+	            // Take beat angle
+              if (typeof polar[indexTWS]['Beat angle'] != 'undefined') {
+	              let beatLower = polar[indexTWS]['Beat angle']
+	              let beatUpper = polar[indexTWS+1]['Beat angle']
+	              performance.beatAngle = beatLower + ((beatUpper - beatLower) * twsGapRatio)
+              }
             }
 	          // Calculate optimum wind angle (B&G thing)
 	          if (options.optimumWindAngle == true) {
-              performance.optimumWindAngle = (TWA - performance.beatAngle) * port
+              if (typeof performance.beatAngle != 'undefined') {
+                performance.optimumWindAngle = (TWA - performance.beatAngle) * port
+              }
 	          }
 	          // Calculate beat VMG
 	          if (options.beatVMG == true) {
-	            let VMGLower = polar[indexTWS]['Beat VMG']
-	            let VMGUpper = polar[indexTWS+1]['Beat VMG']
-	            performance.beatVMG = VMGLower + ((VMGUpper - VMGLower) * twsGapRatio)
+              if (typeof polar[indexTWS]['Beat VMG'] != 'undefined') {
+	              let VMGLower = polar[indexTWS]['Beat VMG']
+	              let VMGUpper = polar[indexTWS+1]['Beat VMG']
+	              performance.beatVMG = VMGLower + ((VMGUpper - VMGLower) * twsGapRatio)
+              }
             }
 	        } else {
             // app.debug('Downwind')
             if (options.beatAngle == true) {
-	            // Calculate run angle
-	            let runLower = polar[indexTWS]['Run angle']
-	            let runUpper = polar[indexTWS+1]['Run angle']
-	            //app.debug('runLower: %s runUpper: %s', runLower, runUpper)
-	            performance.runAngle = runLower + ((runUpper - runLower) * twsGapRatio)
+              if (typeof polar[indexTWS]['Run angle'] != 'undefined') {
+	              // Calculate run angle
+	              let runLower = polar[indexTWS]['Run angle']
+	              let runUpper = polar[indexTWS+1]['Run angle']
+	              //app.debug('runLower: %s runUpper: %s', runLower, runUpper)
+	              performance.runAngle = runLower + ((runUpper - runLower) * twsGapRatio)
+              }
             }
 	          if (options.optimumWindAngle == true) {
-	            // Calculate optimum wind angle
-	            performance.optimumWindAngle = (performance.runAngle - TWA) * port * -1
+              if (typeof performance.runAngle != 'undefined') {
+	              // Calculate optimum wind angle
+	              performance.optimumWindAngle = (performance.runAngle - TWA) * port * -1
+              }
 	          }
 	          if (options.beatVMG == true) {
 	            // Calculate run VMG
-	            let VMGLower = polar[indexTWS]['Run VMG']
-	            let VMGUpper = polar[indexTWS+1]['Run VMG']
+              if (typeof polar[indexTWS]['Run VMG'] != 'undefined') {
+	              let VMGLower = polar[indexTWS]['Run VMG']
+	              let VMGUpper = polar[indexTWS+1]['Run VMG']
 	            //app.debug('VMGLower: %s VMGUpper: %s', VMGLower, VMGUpper)
-	            performance.runVMG = VMGLower + ((VMGUpper - VMGLower) * twsGapRatio)
+	              performance.runVMG = VMGLower + ((VMGUpper - VMGLower) * twsGapRatio)
+              }
             }
           }
           // Calculate polar target boat speed
 
-          // Define the 4 near data points
+          // Interpolate Define the 4 near data points
           let lowerTWA = polar[indexTWS].twa
           let upperTWA = polar[indexTWS+1].twa
           // app.debug('TWAlower: %s', JSON.stringify(TWAlower))
+          // First find lowerTWA
           for (let indexTWA = 0 ; indexTWA < lowerTWA.length-1; indexTWA++) {
             let lowerTWAlower = lowerTWA[indexTWA]
             let lowerTWAupper = lowerTWA[indexTWA+1]
-            let upperTWAlower = upperTWA[indexTWA]
-            let upperTWAupper = upperTWA[indexTWA+1]
-
 	          // app.debug('lowerTWAlower: %s lowerTWAupper: %s', lowerTWAlower, lowerTWAupper)
             if (TWA >= lowerTWAlower.twa && TWA <= lowerTWAupper.twa) {
-	            // app.debug('lowerTWAlower: %d TWA: %d lowerTWAupper: %d', lowerTWAlower.twa, TWA, lowerTWAupper.twa)
-              // Calculate gap ratio
-              let gap = lowerTWAupper.twa - lowerTWAlower.twa
-              let twaGapRatio = (1 / gap) * (TWA - lowerTWAlower.twa)
-	            // app.debug('twaGapRatio: %d', twaGapRatio)
-              // Calculate lower tws boat speed
-	            let lowerTBS = lowerTWAlower.tbs + ((lowerTWAupper.tbs - lowerTWAlower.tbs) * twaGapRatio)
-              // Calculate upper tws boat speed
-	            let upperTBS = upperTWAlower.tbs + ((upperTWAupper.tbs - upperTWAlower.tbs) * twaGapRatio)
-
-              // Calculate polar performance
-              performance.polarSpeed = lowerTBS + ((upperTBS - lowerTBS) * twsGapRatio)
-	            // app.debug('lowerTBS: %d TBS: %d upperTBS: %d', lowerTBS, performance.polarSpeed, upperTBS)
-
-              // Calculate polar performance ratio
-              performance.polarSpeedRatio = (1 / performance.polarSpeed) * BSP
+              // Now find upperTWA
+              for (let indexTWA = 0 ; indexTWA < upperTWA.length-1; indexTWA++) {
+                let upperTWAlower = upperTWA[indexTWA]
+                let upperTWAupper = upperTWA[indexTWA+1]
+                if (TWA >= upperTWAlower.twa && TWA <= upperTWAupper.twa) {
+                  // Found the 4 points
+			            // app.debug('lowerTWAlower: %d TWA: %d lowerTWAupper: %d', lowerTWAlower.twa, TWA, lowerTWAupper.twa)
+		              // Calculate gap ratio
+		              let gap = lowerTWAupper.twa - lowerTWAlower.twa
+		              let twaGapRatio = (1 / gap) * (TWA - lowerTWAlower.twa)
+			            // app.debug('twaGapRatio: %d', twaGapRatio)
+		              // Calculate lower tws boat speed
+			            let lowerTBS = lowerTWAlower.tbs + ((lowerTWAupper.tbs - lowerTWAlower.tbs) * twaGapRatio)
+		              // Calculate upper tws boat speed
+			            let upperTBS = upperTWAlower.tbs + ((upperTWAupper.tbs - upperTWAlower.tbs) * twaGapRatio)
+		              // Calculate polar boat speed
+		              performance.polarSpeed = lowerTBS + ((upperTBS - lowerTBS) * twsGapRatio)
+			            // app.debug('lowerTBS: %d TBS: %d upperTBS: %d', lowerTBS, performance.polarSpeed, upperTBS)
+                  break
+                }
+              }
               break
             } 
           }
+          if (typeof performance.polarSpeed == 'undefined') {
+            if (TWA < performance.beatAngle) {
+              // In case TWA < lowest polar angle
+              app.debug('Low angle %d not present in table', radToDeg(TWA))
+              // performance.polarSpeed = 
+            } else if (TWA > performance.runAngle) {
+              // In case TWA > highest polar angle
+              app.debug('High angle %d not present in table', radToDeg(TWA))
+              // performance.polarSpeed =
+            }
+          }
+
           if (options.maxSpeed == true) {
             let lowerMax = polar[indexTWS]['Max speed']
             let upperMax = polar[indexTWS+1]['Max speed']
@@ -278,10 +304,20 @@ module.exports = function (app) {
             let maxSpeedAngle = lowerMaxAngle + ((upperMaxAngle - lowerMaxAngle) * twsGapRatio)
             performance.maxSpeedAngle = maxSpeedAngle
           }
-        } else {
-          // app.debug('%d not >= %d && <= %d', TWS, lower, upper)
+        } else if (indexTWS == 0 && TWS < lower) {
+          app.debug('No data for low wind speed (%d kts)', msToKts(TWS))
+        } else if (indexTWS == polar.length-1 && TWS > upper) {
+          app.debug('No data for high wind speed (%d kts)', msToKts(TWS))
         }
       }
+      // Calculate polar performance ratio
+      if (typeof performance.polarSpeed != 'undefined') {
+        performance.polarSpeedRatio = (1 / performance.polarSpeed) * BSP
+      } else {
+        // No value would create stale values
+        performance.polarSpeed = 0
+        performance.polarSpeedRatio = 0
+      }
       return performance
     }
 
@@ -322,35 +358,37 @@ module.exports = function (app) {
             angleName = 'Run angle'
             VMGName = 'Run VMG'
           }
-          for (let index = 1; index < row.length; index++) {
-            if (row[index] != 0) {
-              polar[index-1][angleName] = degToRad(angle)
-              polar[index-1][VMGName] = roundDec(Number((row[index]) * Math.abs(Math.cos(angle))))
-              if (typeof polar[index-1]['twa'] == 'undefined') {
-                polar[index-1]['twa'] = []
+          for (let index = 0; index < row.length-1; index++) {
+            if (row[index+1] != 0) {
+              polar[index][angleName] = degToRad(angle)
+              polar[index][VMGName] = roundDec(Number((row[index+1]) * Math.abs(Math.cos(angle))))
+              if (typeof polar[index]['twa'] == 'undefined') {
+                polar[index]['twa'] = []
               }
-              let tbs = ktsToMs(Number(row[index]))
+              let tbs = ktsToMs(Number(row[index+1]))
               let Obj = {"twa": degToRad(angle), "tbs": tbs}
-              polar[index-1]['twa'] = polar[index-1]['twa'].concat(Obj)
-              if (typeof polar[index-1]['Max speed'] == 'undefined' || tbs > polar[index-1]['Max speed']) {
-                polar[index-1]['Max speed'] = tbs
-                polar[index-1]['Max speed angle'] = degToRad(angle)
+              polar[index]['twa'] = polar[index]['twa'].concat(Obj)
+              if (typeof polar[index]['Max speed'] == 'undefined' || tbs > polar[index]['Max speed']) {
+                polar[index]['Max speed'] = tbs
+                polar[index]['Max speed angle'] = degToRad(angle)
               }
             }
           }
         } else {
           // Normal line
           let angle = degToRad(Number(row[0]))  // CSV deg to internal rad
-          for (let index = 1; index < row.length; index++) {
-            if (typeof polar[index-1].twa == 'undefined') {
-              polar[index-1].twa = []
+          for (let index = 0; index < row.length-1; index++) {
+            if (typeof polar[index].twa == 'undefined') {
+              polar[index].twa = []
             }
-            let tbs = ktsToMs(Number(row[index]))
+            let tbs = ktsToMs(Number(row[index+1]))
             let Obj = {"twa": angle, "tbs": tbs}
-            polar[index-1]['twa'] = polar[index-1]['twa'].concat(Obj)
-            if (tbs > polar[index-1]['Max speed']) {
-              polar[index-1]['Max speed'] = tbs
-              polar[index-1]['Max speed angle'] = angle
+            app.debug('Adding Obj: %s', JSON.stringify(Obj))
+            polar[index]['twa'] = polar[index]['twa'].concat(Obj)
+            // See if this a new Max speed
+            if (typeof polar[index]['Max speed'] == 'undefined' || tbs > polar[index]['Max speed']) {
+              polar[index]['Max speed'] = tbs
+              polar[index]['Max speed angle'] = angle
             }
           }
         }
@@ -364,14 +402,50 @@ module.exports = function (app) {
         tws.twa = twaArray
       })
 
+      // And now fill in some missing ends to avoid doing expensive calculations in the main loop
+      for (let index = 0; index < polar.length-1; index++) {
+        // Sorted on angle, so first is lowest
+        let twaArray = polar[index].twa
+        let lowTBS = twaArray[0].tbs
+        let lowTWA = twaArray[0].twa
+
+        // app.debug('Padding polar from 0 to first given angle (%d deg, %d kts) to twaArray %s' , radToDeg(lowTWA), msToKts(lowTBS), JSON.stringify(twaArray))
+        
+        // Now put some extra values at the beginning
+        var topArray = []
+        for (let angle = 0; angle < lowTWA; angle = angle + degToRad(5)) {
+          let tbs = (angle / lowTWA) * Math.pow(Math.cos((-1*lowTWA + angle)*3),3) * lowTBS
+          let Obj = {'twa': angle, 'tbs': tbs}
+          // app.debug('Adding Obj: %s', JSON.stringify(Obj))
+          topArray.push(Obj)
+          // app.debug('twaArray: %s', JSON.stringify(twaArray))
+        }
+        twaArray = topArray.concat(twaArray)
+        // app.debug('twaArray: %s', JSON.stringify(polar[index].twa))
+      }
+
+      for (let index = 0; index < polar.length-1; index++) {
+        let twaArray = polar[index].twa
+        let highTBS = twaArray[twaArray.length-1].tbs
+        let highTWA = twaArray[twaArray.length-1].twa
+
+        // app.debug('Padding polar from highTWA to last given angle (%d, %d kts) to twaArray %s' , highTWA, msToKts(highTBS), JSON.stringify(twaArray))
+
+        // Now put some extra values at the beginning
+        var tailArray = []
+        for (let angle = Math.PI; angle > highTWA; angle = angle - degToRad(5)) {
+          let tbs = Math.pow(highTWA/angle, 2) * highTBS
+          let Obj = {'twa': angle, 'tbs': tbs}
+          tailArray.unshift(Obj)
+        }
+        twaArray = twaArray.concat(tailArray)
+      }
+
       // app.debug(JSON.stringify(polar))
 		  return (polar)
 		}
-
-
   }
 
-
   plugin.stop = function () {
     // Here we put logic we need when the plugin stops
     app.debug('Plugin stopped');