signalk-polar-performance-plugin 0.0.13 → 0.0.15

package/README.md

@@ -17,8 +17,11 @@ The polar diagram can be configured through CSV notation as used on [ORC sailboa
 
 ### Plugin options
 In the plugin configuration you can toggle the following options:
- - Enable calculation of beat/upwind and run/gybe/downwind angle
- - Enable calculation of beat/upwind and run/gybe/downwind VMG
+ - Enable calculation/sending of beat/upwind and run/gybe/downwind angle
+ - Enable calculation/sending of beat/upwind and run/gybe/downwind VMG
+ - Enable sending Target TWA
+ - Enable calculation of Optimum Wind Angle (difference between TWA and beat/run angle (depends on beat/run angle)
+ - Enable sending of maximum speed angle and boat speed for a given TWS
  - Enable calculation of Optimum Wind Angle (difference between TWA and beat/run angle (depends on beat/run angle)
 
 ## Calculated performance data
@@ -40,6 +43,7 @@ In the plugin configuration you can toggle the following options:
  - Make moment to do calculation smarter/configurable
  - API to see JSON of polar
  - Visualisation of the polar diagram
+ - Extrapolation of polar data
  - Create polar from live data
  -- Save polar info to file
  -- Save new record speed for angle in polar

package/package.json

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

package/plugin/index.js

@@ -18,11 +18,19 @@ module.exports = function (app) {
     properties: {
       beatAngle: {
         type: 'boolean',
-        title: 'Enable calculation of beat/upwind and run/gybe/downwind angle'
+        title: 'Enable calculation/sending of beat/upwind and run/gybe/downwind angle'
       },
       beatVMG: {
         type: 'boolean',
-        title: 'Enable calculation of beat/upwind and run/gybe/downwind VMG'
+        title: 'Enable calculation/sending of beat/upwind and run/gybe/downwind VMG'
+      },
+      targetTWA: {
+        type: 'boolean',
+        title: 'Enable sending Target TWA (performance.targetAngle)'
+      },
+      tackTrue: {
+        type: 'boolean',
+        title: 'Enable calculating Opposite Tack True (performance.tackTrue)'
       },
       optimumWindAngle: {
         type: 'boolean',
@@ -60,7 +68,7 @@ module.exports = function (app) {
     app.debug('polar: %s', JSON.stringify(polar))
    
     // Global variables
-    var BSP, STW, TWA, TWS, port // Angles in rad, speed in m/s
+    var BSP, STW, TWA, targetTWA, TWS, HDG, port // Angles in rad, speed in m/s
     var halfPi = Math.PI / 2
 
     // Subscribe to paths
@@ -89,6 +97,12 @@ module.exports = function (app) {
         policy: 'instant'
       })
     }
+    if (options.tackTrue == true) {
+      localSubscription.subscribe.push({
+          path: 'navigation.headingTrue',
+          policy: 'instant'
+      })
+    }
 
     app.subscriptionmanager.subscribe(
       localSubscription,
@@ -116,6 +130,9 @@ module.exports = function (app) {
 	        SOG = delta.value
           BSP = SOG
 	        // app.debug('speedThroughWater (STW): %d', STW)
+	      } else if (delta.path == 'navigation.headingTrue') {
+	        HDG = delta.value
+	        // app.debug('heading (HDG): %d', HDG)
 	      } else if (delta.path == 'environment.wind.speedTrue') {
 	        TWS = delta.value
 	        // app.debug('environment.wind.speedTrue (TWS): %d', TWS)
@@ -136,22 +153,34 @@ module.exports = function (app) {
       let values = []
       let metas = []
       if (typeof perfObj.beatAngle != 'undefined') {
-        values.push({path: 'performance.beatAngle', value: roundDec(perfObj.beatAngle)})
-        values.push({path: 'performance.targetAngle', value: roundDec(perfObj.beatAngle)})
+        if (options.beatAngle == true) {
+          values.push({path: 'performance.beatAngle', value: roundDec(perfObj.beatAngle)})
+        }
+        if (options.targetTWA == true) {
+          values.push({path: 'performance.targetAngle', value: roundDec(perfObj.beatAngle)})
+        }
       }
       if (typeof perfObj.beatVMG != 'undefined') {
         values.push({path: 'performance.beatAngleVelocityMadeGood', value: roundDec(perfObj.beatVMG)})
-        values.push({path: 'performance.targetVelocityMadeGood', value: roundDec(perfObj.beatVMG)})
-        metas.push({path: 'performance.targetVelocityMadeGood', value: {"units": "rad"}})
+        if (options.targetTWA == true) {
+          values.push({path: 'performance.targetVelocityMadeGood', value: roundDec(perfObj.beatVMG)})
+          metas.push({path: 'performance.targetVelocityMadeGood', value: {"units": "rad"}})
+        }
       }
       if (typeof perfObj.runAngle != 'undefined') {
-        values.push({path: 'performance.gybeAngle', value: roundDec(perfObj.runAngle)})
-        values.push({path: 'performance.targetAngle', value: roundDec(perfObj.runAngle)})
+        if (options.beatAngle == true) {
+          values.push({path: 'performance.gybeAngle', value: roundDec(perfObj.runAngle)})
+        }
+        if (options.targetTWA == true) {
+          values.push({path: 'performance.targetAngle', value: roundDec(perfObj.runAngle)})
+        }
       }
       if (typeof perfObj.runVMG != 'undefined') {
         values.push({path: 'performance.gybeAngleVelocityMadeGood', value: roundDec(perfObj.runVMG)})
-        values.push({path: 'performance.targetVelocityMadeGood', value: roundDec(perfObj.runVMG)})
-        metas.push({path: 'performance.targetVelocityMadeGood', value: {"units": "rad"}})
+        if (options.targetTWA == true) {
+          values.push({path: 'performance.targetVelocityMadeGood', value: roundDec(perfObj.runVMG)})
+          metas.push({path: 'performance.targetVelocityMadeGood', value: {"units": "rad"}})
+        }
       }
       if (typeof perfObj.optimumWindAngle != 'undefined') {
         values.push({path: 'performance.optimumWindAngle', value: roundDec(perfObj.optimumWindAngle)})
@@ -170,6 +199,11 @@ module.exports = function (app) {
         values.push({path: 'performance.maxSpeedAngle', value: roundDec(perfObj.maxSpeedAngle)})
         metas.push({path: 'performance.maxSpeedAngle', value: {"units": "rad"}})
       }
+      if (options.tackTrue == true) {
+        if (typeof perfObj.tackTrue != 'undefined') {
+          values.push({path: 'performance.tackTrue', value: roundDec(perfObj.tackTrue)})
+        }
+      }
 
       app.debug('sendUpdates: %s', JSON.stringify(values))
       app.handleMessage(plugin.id, {
@@ -197,13 +231,12 @@ module.exports = function (app) {
 	        // Calculate beat/run angle
 	        if (TWA < halfPi) {
             // app.debug('Upwind')
-            if (options.beatAngle == true) {
-	            // 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)
-              }
+	          // 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)
+              targetTWA = performance.beatAngle
             }
 	          // Calculate optimum wind angle (B&G thing)
 	          if (options.optimumWindAngle == true) {
@@ -212,23 +245,20 @@ module.exports = function (app) {
               }
 	          }
 	          // Calculate beat VMG
-	          if (options.beatVMG == true) {
-              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)
-              }
+            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) {
-              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 (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)
+              targetTWA = performance.runAngle
             }
 	          if (options.optimumWindAngle == true) {
               if (typeof performance.runAngle != 'undefined') {
@@ -236,16 +266,29 @@ module.exports = function (app) {
 	              performance.optimumWindAngle = (performance.runAngle - TWA) * port * -1
               }
 	          }
-	          if (options.beatVMG == true) {
-	            // Calculate 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)
-              }
+	          // Calculate 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)
             }
           }
+          // Calculate opposite Tack True
+          // app.debug('tackTrue: port: %d HDG: %d targetTWA: %d', port, radToDeg(HDG), radToDeg(targetTWA))
+          if (port) {
+            let tackTrue = HDG - targetTWA
+            if (tackTrue < 0) {
+              tackTrue = tackTrue + (2*Math.PI)
+            }
+            performance.tackTrue = tackTrue
+          } else {
+            let tackTrue = HDG + targetTWA
+            if (tackTrue > (2*Math.PI)) {
+              tackTrue = tackTrue - (2*Math.PI)
+            }
+            performance.tackTrue = tackTrue
+          }
           // Calculate polar target boat speed
 
           // Interpolate Define the 4 near data points
@@ -348,10 +391,10 @@ module.exports = function (app) {
           app.debug('beat and run angles are included')
         } else if (row.includes('0')) {
           // Beat / Run angle
-          let angle = Number(row[0])
+          let angle = degToRad(Number(row[0]))
           let angleName
           let VMGName
-          if (angle < 90) {
+          if (angle < halfPi) {
             angleName = 'Beat angle'
             VMGName = 'Beat VMG'
           } else {
@@ -360,17 +403,18 @@ module.exports = function (app) {
           }
           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))))
+              polar[index][angleName] = angle
+              let tbs = ktsToMs(Number(row[index+1]))
+              let vmg = tbs * Math.abs(Math.cos(angle))
+              polar[index][VMGName] = roundDec(vmg)
               if (typeof polar[index]['twa'] == 'undefined') {
                 polar[index]['twa'] = []
               }
-              let tbs = ktsToMs(Number(row[index+1]))
-              let Obj = {"twa": degToRad(angle), "tbs": tbs}
+              let Obj = {"twa": angle, "tbs": tbs, "vmg": vmg}
               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)
+                polar[index]['Max speed angle'] = angle
               }
             }
           }
@@ -382,9 +426,13 @@ module.exports = function (app) {
               polar[index].twa = []
             }
             let tbs = ktsToMs(Number(row[index+1]))
-            let Obj = {"twa": angle, "tbs": tbs}
-            app.debug('Adding Obj: %s', JSON.stringify(Obj))
+            let vmg = tbs * Math.abs(Math.cos(angle))
+            let Obj = {"twa": angle, "tbs": tbs, "vmg": vmg}
+            // app.debug('Adding Obj: %s', JSON.stringify(Obj))
             polar[index]['twa'] = polar[index]['twa'].concat(Obj)
+            // See if we need to set/overwrite beat/run angle
+
+
             // See if this a new Max speed
             if (typeof polar[index]['Max speed'] == 'undefined' || tbs > polar[index]['Max speed']) {
               polar[index]['Max speed'] = tbs
@@ -402,34 +450,68 @@ module.exports = function (app) {
         tws.twa = twaArray
       })
 
+      // Find the beat/run angle if not set yet.
+      if (typeof polar[0].beatAngle == 'undefined') {
+        for (let index = 0; index < polar.length-1; index++) {
+          let tws = polar[index].tws
+          let beatVMG = 0
+          let beatElement = 0
+          let runVMG = 0
+          let runElement = 0
+
+          let twaArray = polar[index].twa
+          for (let element = 0; element < twaArray.length-1; element++) {
+            let Obj = twaArray[element]
+            if (Obj.twa < halfPi) {
+              // Beat
+              if (Obj.vmg > beatVMG) {
+                beatElement = element
+              }
+            } else {
+              // Run
+              if (Obj.vmg > runVMG) {
+                runElement = element
+              }
+            }
+          }
+          app.debug('beatVMG for %d is %d (angel %d)', tws, twaArray[beatElement].vmg, twaArray[beatElement].twa)
+          app.debug(' runVMG for %d is %d (angel %d)', tws, twaArray[runElement].vmg, twaArray[runElement].twa)
+          polar[index]['Beat angle'] = twaArray[beatElement].twa
+          polar[index]['Beat VMG'] = twaArray[beatElement].vmg
+          polar[index]['Run angle'] = twaArray[runElement].twa
+          polar[index]['Run VMG'] = twaArray[runElement].vmg
+        }
+        
+      }
+
       // 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 tws = polar[index].tws
         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))
+        app.debug('Padding polar for %s from 0 to first given angle (%d deg, %d kts)', msToKts(tws).toFixed(0), radToDeg(lowTWA), msToKts(lowTBS))
         
         // 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))
+        // app.debug('Adding values: %s', JSON.stringify(topArray))
+        polar[index].twa = topArray.concat(twaArray)
       }
 
       for (let index = 0; index < polar.length-1; index++) {
+        let tws = polar[index].tws
         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))
+        app.debug('Padding polar for %s from highTWA to last given angle (%d, %d kts)', msToKts(tws).toFixed(0), highTWA, msToKts(highTBS))
 
         // Now put some extra values at the beginning
         var tailArray = []
@@ -438,7 +520,8 @@ module.exports = function (app) {
           let Obj = {'twa': angle, 'tbs': tbs}
           tailArray.unshift(Obj)
         }
-        twaArray = twaArray.concat(tailArray)
+        // app.debug('Adding values: %s', JSON.stringify(tailArray))
+        polar[index].twa = twaArray.concat(tailArray)
       }
 
       // app.debug(JSON.stringify(polar))