signalk-vessels-to-ais 1.1.1 → 1.1.5

package/.eslintrc.js

@@ -0,0 +1,24 @@
+module.exports = {
+  env: {
+    commonjs: true,
+    es2021: true,
+    node: true,
+    browser: true,
+    jquery: true,
+  },
+  extends: [
+    'airbnb-base',
+  ],
+  parserOptions: {
+    ecmaVersion: 12,
+  },
+  rules: {
+    'linebreak-style': 0,
+    'no-console': 0,
+    'func-names': 0,
+    'prefer-destructuring': 0,
+    'one-var-declaration-per-line': 0,
+    'one-var': 0,
+    'no-plusplus': 0,
+  },
+};

package/README.md

@@ -6,8 +6,13 @@ SignalK server plugin to convert other vessel data to NMEA0183 AIS format and fo
 
 User can configure:
 - How often data is sent out
+- Own data can be added to AIS sending
 
 New:
+- v1.1.5, updated vessels within selected timeframe are sent out, radius filtering around own vessel and tag-block option added
+- v1.1.4, small fix
+- v1.1.3, add: own vessel data and sending interval modified
+- v1.1.2, fix: http/https url selection and better error info
 - v1.1.1, fix: current status of the plugin updated
 - v1.1.0, fix: numeric value test for text strings of AIS
 - v1.0.0, v1 release

package/index.js

@@ -22,8 +22,10 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-const fetch = require('node-fetch');
-const AisEncode = require("ggencoder").AisEncode
+const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
+const AisEncode = require('ggencoder').AisEncode;
+const moment = require('moment');
+const haversine = require('haversine-distance');
 
 module.exports = function createPlugin(app) {
   const plugin = {};
@@ -31,229 +33,365 @@ module.exports = function createPlugin(app) {
   plugin.name = 'Other vessels data to AIS NMEA0183';
   plugin.description = 'SignalK server plugin to convert other vessel data to NMEA0183 AIS format and forward it out to 3rd party applications';
 
-  var position_update = null;
-  var url;
-  var interval_id1;
-  var interval_id2;
-  var unsubscribes = [];
+  let positionUpdate = null;
+  let distance;
+  let sendOwn;
+  let url;
+  let intervalRun;
+  let readInfo;
   const setStatus = app.setPluginStatus || app.setProviderStatus;
 
-plugin.start = function (options, restartPlugin) {
+  let position_update;
+  let useTag;
+
+  plugin.start = function (options, restartPlugin) {
+    position_update = options.position_update * 60;
+    useTag = options.useTag;
+
+    let port = options.port || 3000;
+    let portSec = options.portSec || 3443;
+
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+    url = 'https://localhost:' + portSec + '/signalk/v1/api/vessels';
+    fetch(url, { method: 'GET' })
+      .then((res) => {
+        console.log(`${plugin.id}: SSL enabled, using https`);
+        if (!res.ok) {
+          console.error(`${plugin.id}: SSL enabled, but error accessing server. Check 'Allow Readonly Access' and enable it.`);
+          setStatus("Error accessing server. Check 'Allow Readonly Access' and enable it");
+        }
+      })
+      .catch(() => {
+        url = 'http://localhost:' + port + '/signalk/v1/api/vessels';
+        fetch(url, { method: 'GET' })
+          .then((res) => {
+            console.log(`${plugin.id}: SSL disabled, using http`);
+            if (!res.ok) {
+              console.error(`${plugin.id}: SSL disabled, but error accessing server. Check 'Allow Readonly Access' and enable it.`);
+              setStatus("Error accessing server. Check 'Allow Readonly Access' and enable it");
+            }
+          })
+          .catch(() => {
+          });
+      });
 
-  position_update = options.position_update
-  app.debug('Plugin started');
+    positionUpdate = options.position_update;
+    distance = options.distance;
+    sendOwn = options.sendOwn;
 
-  interval_id1 = setInterval(read_info,(15000));
-  setTimeout(clear, 15000);
-  interval_id2 = setInterval(read_info,(position_update * 60000));
+    app.debug('Plugin started');
 
+    intervalRun = setInterval(readInfo, (positionUpdate * 60000));
   };
 
-//----------------------------------------------------------------------------
-// State Mapping
-
-let stateMapping = {
-  'motoring': 0,
-  'anchored': 1,
-  'not under command': 2,
-  'restricted manouverability': 3,
-  'constrained by draft': 4,
-  'moored': 5,
-  'aground': 6,
-  'fishing': 7,
-  'sailing': 8,
-  'hazardous material high speed': 9,
-  'hazardous material wing in ground': 10,
-  'ais-sart': 14,
-  'default': 15
-}
-
-//----------------------------------------------------------------------------
-// Rad to Deg
-function radians_to_degrees(radians)
-{
-  var pi = Math.PI;
-  return ((radians * 180)/pi);
-}
-
-//----------------------------------------------------------------------------
-// m/s to  knots
-function ms_to_knots(speed)
-{
-  return ((speed * 3.6) / 1.852);
-}
-
-//----------------------------------------------------------------------------
-// Clear start interval
-
-  function clear() {
-    clearInterval(interval_id1);
+  //----------------------------------------------------------------------------
+  // State Mapping
+
+  const stateMapping = {
+    motoring: 0,
+    anchored: 1,
+    'not under command': 2,
+    'restricted manouverability': 3,
+    'constrained by draft': 4,
+    moored: 5,
+    aground: 6,
+    fishing: 7,
+    sailing: 8,
+    'hazardous material high speed': 9,
+    'hazardous material wing in ground': 10,
+    'ais-sart': 14,
+    default: 15,
   };
 
-//----------------------------------------------------------------------------
-// json size
-function lengthInUtf8Bytes(str,str2) {
-  var m = encodeURIComponent(str).match(/%[89ABab]/g);
-  return (((str.length + (m ? m.length : 0))/1024) + (str2*0.2)).toFixed(1);
-}
-
-//----------------------------------------------------------------------------
-// nmea out
-
-function ais_out(enc_msg) {
-  var enc= new AisEncode(enc_msg)
-  var sentence = enc.nmea
-  if ( sentence && sentence.length > 0 )
-  {
-    app.debug(sentence);
-    app.emit('nmea0183out', sentence);
+  //----------------------------------------------------------------------------
+  // Rad to Deg
+  function radToDegrees(radians) {
+    const pi = Math.PI;
+    return ((radians * 180) / pi);
+  }
+
+  //----------------------------------------------------------------------------
+  // m/s to  knots
+  function msToKnots(speed) {
+    return ((speed * 3.6) / 1.852);
   }
-}
 
-//----------------------------------------------------------------------------
-// Read and parse AIS data
+  //----------------------------------------------------------------------------
+  // nmea out
+
+  function aisOut(encMsg, aisTime) {
+    const enc = new AisEncode(encMsg);
+    const sentence = enc.nmea;
+    let taggString = '';
+    if (useTag) {
+      taggString = createTagBlock(aisTime)
+    } 
+    if (sentence && sentence.length > 0) {
+      app.debug(taggString+sentence);
+      app.emit('nmea0183out', taggString+sentence);
+    }
+  }
 
-  read_info = function read_data() {
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-        var url ="http://localhost:3000/signalk/v1/api/vessels";
+  const m_hex = [
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F'
+  ]
+  
+  function toHexString (v) {
+    let msn = (v >> 4) & 0x0f
+    let lsn = (v >> 0) & 0x0f
+    return m_hex[msn] + m_hex[lsn]
+  }
 
-        fetch(url, { method: 'GET'})
-          .then((res) => {
-             return res.json()
-        })
-        .then((json) => {
-          var jsonContent = JSON.parse(JSON.stringify(json));
-          var numberAIS = Object.keys(jsonContent).length;
-          for (i = 1; i < numberAIS; i++) {
-            var jsonKey = Object.keys(jsonContent)[i];
-
-            try { var mmsi = jsonContent[jsonKey].mmsi;} catch (error) {mmsi = null;};
-            try { var name = jsonContent[jsonKey].name;} catch (error) {name = "";};
-            try { var lat = jsonContent[jsonKey].navigation.position.value.latitude;} catch (error) {lat = null ;};
-            try { var lon = jsonContent[jsonKey].navigation.position.value.longitude;} catch (error) {lon = null;};
-            try { var sog = ms_to_knots(jsonContent[jsonKey].navigation.speedOverGround.value);} catch (error) {sog = null;};
-            try { var cog = radians_to_degrees(jsonContent[jsonKey].navigation.courseOverGroundTrue.value);} catch (error) {cog = null;};
-            try { var rot = radians_to_degrees(jsonContent[jsonKey].navigation.rateOfTurn.value);} catch (error) {rot = null;};
-            try { var navStat = stateMapping[jsonContent[jsonKey].navigation.state.value];} catch (error) {navStat = "";};
-            try { var hdg = radians_to_degrees(jsonContent[jsonKey].navigation.headingTrue.value);} catch (error) {hdg = null;};
-            try { var dst = jsonContent[jsonKey].navigation.destination.commonName.value;} catch (error) {dst = "";};
-            try { var callSign = jsonContent[jsonKey].communication.callsignVhf;} catch (error) {callSign = "";};
-            try { var imo = (jsonContent[jsonKey].registrations.imo).substring(4, 20);} catch (error) {imo = null;};
-            try { var id = jsonContent[jsonKey].design.aisShipType.value.id;} catch (error) {id = null;};
-            try { var type = jsonContent[jsonKey].design.aisShipType.value.name;} catch (error) {type = "";};
-            try { var draft_cur = (jsonContent[jsonKey].design.draft.value.current)/10;} catch (error) {draft_cur = null;};
-            try { var length = jsonContent[jsonKey].design.length.value.overall;} catch (error) {length = null;};
-            try { var beam = (jsonContent[jsonKey].design.beam.value)/2;} catch (error) {beam = null;};
-            try { var ais = jsonContent[jsonKey].sensors.ais.class.value;} catch (error) {ais = null;};
-
-            if (name % 1 == 0) {
-               name = "";
-            }
-            if (navStat % 1 == 0) {
-               navStat = "";
+  function createTagBlock (aisTime) {
+    let tagBlock = ''
+    tagBlock += 's:SK0001,'
+    //tagBlock += 'c:' + aisTime + ','
+    tagBlock += 'c:' + Date.now(aisTime) + ','
+    tagBlock = tagBlock.slice(0, - 1)
+    let tagBlockChecksum = 0
+    for (let i = 0; i < tagBlock.length; i++) {
+      tagBlockChecksum ^= tagBlock.charCodeAt(i)
+    }
+    return `\\${tagBlock}*` + toHexString(tagBlockChecksum) + `\\`
+  }
+
+  //----------------------------------------------------------------------------
+  // Read and parse AIS data
+
+  readInfo = function readData(options) {
+    let i, mmsi, aisTime, aisDelay, shipName, lat, lon, sog, cog, rot, navStat, hdg, dst, callSign, imo, id, type;
+    let draftCur, length, beam, ais, encMsg3, encMsg5, encMsg18, encMsg240, encMsg241, own;
+    let ownLat = app.getSelfPath('navigation.position.value.latitude');
+    let ownLon = app.getSelfPath('navigation.position.value.longitude');
+    fetch(url, { method: 'GET' })
+      .then((res) => res.json())
+      .then((json) => {
+        const jsonContent = JSON.parse(JSON.stringify(json));
+        const numberAIS = Object.keys(jsonContent).length;
+        for (i = 0; i < numberAIS; i++) {
+          const jsonKey = Object.keys(jsonContent)[i];
+
+          try {
+            aisTime = jsonContent[jsonKey].sensors.ais.class.timestamp;
+            if ((parseFloat((moment(new Date(Date.now())).diff(aisTime)/1000).toFixed(3))) < position_update) {
+              aisDelay = true;
+            } else {
+              aisDelay = false;
             }
-            if (dst % 1 == 0) {
-               dst = "";
+          } catch (error) {
+            if (i === 0) {
+              aisTime = new Date(Date.now()).toISOString();
+              aisDelay = true;
+            } else {
+              aisTime = null;
+              aisDelay = false;
             }
-            if (callSign % 1 == 0) {
-               callSign = "";
+          }
+          try {
+            mmsi = jsonContent[jsonKey].mmsi;
+          } catch (error) { mmsi = null; }
+          try {
+            shipName = jsonContent[jsonKey].name;
+          } catch (error) { shipName = ''; }
+          try {
+            lat = jsonContent[jsonKey].navigation.position.value.latitude;
+          } catch (error) { lat = null; }
+          try {
+            lon = jsonContent[jsonKey].navigation.position.value.longitude;
+          } catch (error) { lon = null; }
+          try {
+            sog = msToKnots(jsonContent[jsonKey].navigation.speedOverGround.value);
+          } catch (error) { sog = null; }
+          try {
+            cog = radToDegrees(jsonContent[jsonKey].navigation.courseOverGroundTrue.value);
+          } catch (error) { cog = null; }
+          try {
+            rot = radToDegrees(jsonContent[jsonKey].navigation.rateOfTurn.value);
+          } catch (error) { rot = null; }
+          try {
+            navStat = stateMapping[jsonContent[jsonKey].navigation.state.value];
+          } catch (error) { navStat = ''; }
+          try {
+            hdg = radToDegrees(jsonContent[jsonKey].navigation.headingTrue.value);
+          } catch (error) { hdg = null; }
+          try {
+            dst = jsonContent[jsonKey].navigation.destination.commonName.value;
+          } catch (error) { dst = ''; }
+          try {
+            if (i === 0) {
+              callSign = jsonContent[jsonKey].communication.callsignVhf;
+            } else {
+              callSign = jsonContent[jsonKey].communication.value.callsignVhf;
             }
-            if (type % 1 == 0) {
-               type = "";
+          } catch (error) { callSign = ''; }
+          try {
+            imo = (jsonContent[jsonKey].registrations.value.imo).substring(4, 20);
+          } catch (error) { imo = null; }
+          try {
+            id = jsonContent[jsonKey].design.aisShipType.value.id;
+          } catch (error) { id = null; }
+          try {
+            type = jsonContent[jsonKey].design.aisShipType.value.name;
+          } catch (error) { type = ''; }
+          try {
+            draftCur = (jsonContent[jsonKey].design.draft.value.current) / 10;
+          } catch (error) { draftCur = null; }
+          try {
+            length = jsonContent[jsonKey].design.length.value.overall;
+          } catch (error) { length = null; }
+          try {
+            beam = (jsonContent[jsonKey].design.beam.value) / 2;
+          } catch (error) { beam = null; }
+          try {
+            ais = jsonContent[jsonKey].sensors.ais.class.value;
+          } catch (error) { ais = null; }
+
+          if (shipName % 1 === 0) {
+            shipName = '';
+          }
+          if (dst % 1 === 0) {
+            dst = '';
+          }
+          if (callSign % 1 === 0) {
+            callSign = '';
+          }
+          if (type % 1 === 0) {
+            type = '';
+          }
+
+          if (i === 0) {
+            own = true;
+            if (sendOwn) {
+              ais = 'A';
+            } else {
+              ais = '';
             }
+          } else {
+            own = false;
+          }
+
+          const a = { lat: ownLat, lon: ownLon }
+          const b = { lat: lat, lon: lon }
+          let dist = (haversine(a, b)/1000).toFixed(2);
 
-            enc_msg_3 = {
+          if (dist <= distance) {
+            
+            encMsg3 = {
+              own,
               aistype: 3, // class A position report
               repeat: 0,
-              mmsi: mmsi,
+              mmsi,
               navstatus: navStat,
-              sog: sog,
-              lon: lon,
-              lat: lat,
-              cog: cog,
-              hdg: hdg,
-              rot: rot
-            }
-
-            enc_msg_5 = {
-              aistype: 5, //class A static
+              sog,
+              lon,
+              lat,
+              cog,
+              hdg,
+              rot,
+            };
+  
+            encMsg5 = {
+              own,
+              aistype: 5, // class A static
               repeat: 0,
-              mmsi: mmsi,
-              imo: imo,
+              mmsi,
+              imo,
               cargo: id,
               callsign: callSign,
-              shipname: name,
-              draught: draft_cur,
+              shipname: shipName,
+              draught: draftCur,
               destination: dst,
               dimA: 0,
               dimB: length,
               dimC: beam,
-              dimD: beam
-            }
-
-            enc_msg_18 = {
+              dimD: beam,
+            };
+  
+            encMsg18 = {
+              own,
               aistype: 18, // class B position report
               repeat: 0,
-              mmsi: mmsi,
-              sog: sog,
+              mmsi,
+              sog,
               accuracy: 0,
-              lon: lon,
-              lat: lat,
-              cog: cog,
-              hdg: hdg
-            }
-
-            enc_msg_24_0 = {
+              lon,
+              lat,
+              cog,
+              hdg,
+            };
+  
+            encMsg240 = {
+              own,
               aistype: 24, // class B static
               repeat: 0,
               part: 0,
-              mmsi: mmsi,
-              shipname: name
-            }
-
-            enc_msg_24_1 = {
+              mmsi,
+              shipname: shipName,
+            };
+  
+            encMsg241 = {
+              own,
               aistype: 24, // class B static
               repeat: 0,
               part: 1,
-              mmsi: mmsi,
+              mmsi,
               cargo: id,
               callsign: callSign,
               dimA: 0,
               dimB: length,
               dimC: beam,
-              dimD: beam
-            }
+              dimD: beam,
+            };
+  
+            if (aisDelay && (ais === 'A' || ais === 'B')) {
+              app.debug("Distance range: " + distance + "km, AIS target distance: "  + dist + "km" + ", Class " + ais + " Vessel" + ", MMSI:" + mmsi)
+              if (ais === 'A') {
+                app.debug(`class A, ${i}, time: ${aisTime}`);
+                aisOut(encMsg3, aisTime);
+                aisOut(encMsg5, aisTime);
+              }
+              if (ais === 'B') {
+                app.debug(`class B, ${i}, time: ${aisTime}`);
+                aisOut(encMsg18, aisTime);
+                aisOut(encMsg240, aisTime);
+                aisOut(encMsg241, aisTime);
+              }
+              app.debug("--------------------------------------------------------");
 
-            if (ais == "A") {
-               app.debug("class A " + i);
-               ais_out(enc_msg_3);
-               ais_out(enc_msg_5);
-            }
-            if (ais == "B") {
-               app.debug("class B " + i);
-               ais_out(enc_msg_18);
-               ais_out(enc_msg_24_0);
-               ais_out(enc_msg_24_1);
             }
-
           }
-        var dateobj = new Date( Date.now());
-        var date = dateobj.toISOString();
+        }
+        const dateobj = new Date(Date.now());
+        const date = dateobj.toISOString();
         app.handleMessage(plugin.id, {
           context: `vessels.${app.selfId}`,
           updates: [
-          ]
+          ],
         });
-        setStatus(`Number of AIS targets sent: ${numberAIS-1} (${date})`);
-        })
-        .catch(err => console.error(err));
-
+        setStatus(`Number of AIS targets sent: ${numberAIS - 1} (${date})`);
+      })
+      .catch((err) => console.error(err));
   };
 
-//----------------------------------------------------------------------------
+  //----------------------------------------------------------------------------
 
   plugin.stop = function stop() {
-    clearInterval(interval_id2);
+    clearInterval(intervalRun);
     app.debug('Stopped');
   };
 
@@ -261,10 +399,35 @@ function ais_out(enc_msg) {
     type: 'object',
     properties: {
       position_update: {
-        type: 'integer',
+        type: 'number',
         default: 1,
-        title: 'How often AIS data is sent to NMEA0183 out (in minutes)',
-      }
+        title: 'How often AIS data is sent to NMEA0183 out (in minutes). E.g. 0.5 = 30s, 1 = 1min',
+      },
+      port: {
+        type: 'number',
+        title: 'HTTP port',
+        default: 3000
+      },
+      portSec: {
+        type: 'number',
+        title: 'HTTPS port',
+        default: 3443
+      },
+      sendOwn: {
+        type: 'boolean',
+        title: 'Send own AIS data, VDO',
+        default: true
+      },
+      useTag: {
+        type: 'boolean',
+        title: 'Add Tag-block',
+        default: false
+      },
+      distance: {
+        type: 'integer',
+        default: 100,
+        title: 'AIS target within range [km]',
+      },
     },
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-vessels-to-ais",
-  "version": "1.1.1",
+  "version": "1.1.5",
   "description": "SignalK server plugin to convert other vessel data to NMEA0183 AIS format and forward it out to 3rd party applications",
   "main": "index.js",
   "scripts": {
@@ -13,7 +13,14 @@
   "author": "Karl-Erik Gustafsson",
   "license": "MIT",
   "dependencies": {
-    "node-fetch": "^2.6.0",
-    "ggencoder": "^1.0.4"
+    "haversine-distance": "^1.2.1",
+    "moment": "^2.29.1",
+    "node-fetch": "^3.1.1",
+    "ggencoder": "^1.0.5"
+  },
+  "devDependencies": {
+    "eslint": "^7.17.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.22.1"
   }
 }