@lifefinder/vsm-mqtt-client-open-source 0.0.46

package/integrations/helium.js

@@ -0,0 +1,150 @@
+const mqtt = require('mqtt')
+
+const printUsageAndExit = (info) => {
+    console.log(info);
+    process.exit(1);
+}
+
+// Try to determine the maximum downlink frame size
+/* TODO: Inventory all these for max size and use in below function
+const sfToSizeTable = {
+"SF12BW125"    : 51,
+"SF11BW125"    : 51,
+"SF10BW125"    : 51,
+"SF9BW125"     : 115,
+"SF8BW125"     : 222,
+"SF7BW125"     : 222,
+"SF12BW250"    : 
+"SF11BW250"    : 
+"SF10BW250"    : 
+"SF9BW250"     : 
+"SF8BW250"     : 
+"SF7BW250"     : 
+"SF12BW500"    : 
+"SF11BW500"    : 
+"SF10BW500"    : 
+"SF9BW500"     : 
+"SF8BW500"     : 
+"SF7BW500"     : 
+"LRFHSS1BW137" : 7),
+"LRFHSS2BW137" : 7),
+"LRFHSS1BW336" : 6),
+"LRFHSS2BW336" : 6),
+"LRFHSS1BW1523": 523),
+"LRFHSS2BW1523": 523),
+"FSK50"        :
+*/
+
+const getMaxSize = (sfbw) => {
+    if (sfbw == "SF12BW125" ||
+        sfbw == "SF11BW125" ||
+        sfbw == "SF10BW125")
+        return 51;
+    if (sfbw == "SF9BW125")
+        return 115;
+    if (sfbw == "SF8BW125" ||
+        sfbw == "SF7BW125" ||
+        sfbw == "SF8BW250")
+        return 222;
+    console.log("Warning: Unhandled helium spreading: " + sfbw);
+}
+
+module.exports.api = {
+    getVersionString: () => { return "Helium MQTT Integration"; },
+    checkArgumentsOrExit: (args) => { 
+        if (!args.u)
+            printUsageAndExit("Helium: -u <mqtt broker user name> is required")
+        if (!args.p)
+            printUsageAndExit("Helium: -u <mqtt broker password> is required")
+        if (!args.s)
+            printUsageAndExit("Helium: -s <mqtt broker url> is required");
+    },
+    connectAndSubscribe: async (args, devices, onUplinkDevicePortBufferDateLatLng) => {
+        args.v && console.log("Trying to connect to " + args.s);
+        try {
+            // Create an MQTT client instance
+            /* const options = {
+                // Clean session
+                clean: true,
+                connectTimeout: 4000,
+                // Authentication
+                clientId: args.u,
+                username: args.u,
+                password: args.p,
+            } */
+            
+            const client  = mqtt.connect(args.s /*, options*/);
+
+            client.on('connect', () => {
+                args.v && console.log("Helium: Connected to mqtt broker");
+
+                // Do we have a device list?
+                if (Array.isArray(devices) && devices.length > 0) {
+                    for (let i = 0; i < devices.length; ++i) {
+                        const topic = `helium/vsm/rx/${devices[i].toUpperCase()}`;
+                        client.subscribe(topic, (err) => {
+                            if (err)
+                                console.log(`Helium subscribe: ${topic} failed:` + err.message );
+                            else
+                                args.v && console.log(`Helium subscribed ok to ${topic}`);
+                            });
+                    }
+                } else {
+                    // Do a wildcard subscription to any device starting with the assigned range of
+                    // Sensative DevEUIs
+                    const topic = `helium/vsm/rx/#`;
+                    client.subscribe(topic, (err) => {
+                        if (err)
+                            console.log(`Helium subscribe: ${topic} failed:` + err.message );
+                        else
+                            args.v && console.log(`Helium subscribed ok to ${topic}`);
+                        });
+                }
+                });
+            client.on('message', async (topic, message) => {
+                // message is Buffer
+                args.v && console.log(topic, message.toString());
+
+                const obj = JSON.parse(message.toString('utf-8'));
+                console.log(obj);
+                const data = Buffer.from(obj.payload, "base64");
+                const port = obj.port;
+                const id = obj.dev_eui;
+                
+                let lat, lng;
+                let date;
+                let maxSize = 40; // Some default
+                // Take first gateways lat & lng values, any gateway likely to hear this is likely within 150km
+                if (obj.hotspots && obj.hotspots.length > 0) {
+                    let gwinfo = obj.hotspots[0];
+                    lat = gwinfo.lat;
+                    lng = gwinfo.long;
+                    maxSize = getMaxSize(gwinfo.spreading);
+                }
+                date = new Date(obj.reported_at);
+                if (!date)
+                    date = new Date()
+
+                await onUplinkDevicePortBufferDateLatLng(client, id, port, data, date, lat, lng, maxSize);
+            });
+            return client;
+        } catch (e) {
+            console.log("Chirpstack: Got exception: " + e.message);
+            throw e;
+        }
+    },
+    sendDownlink: async (client, args, deviceId, port, data, confirmed) => {
+        if (!Buffer.isBuffer(data))
+            throw new Error("Helium sendDownlink: data must be a buffer object");
+        const devEUI = deviceId.toUpperCase();
+        const topic = `helium/vsm/tx/${devEUI}`;
+        const obj = {
+            confirmed,
+            port,
+            payload_raw: data.toString('base64'),
+        };
+        client.publish(topic, JSON.stringify(obj));
+        args.v && console.log("Publish downlink on port " + port + " data: " + data.toString("hex"));
+    },
+}
+

package/integrations/yggio.js

@@ -0,0 +1,136 @@
+const mqtt = require("mqtt");
+const { isDate } = require("util/types");
+
+const printUsageAndExit = (info) => {
+    console.log(info);
+    process.exit(1);
+}
+
+const getMaxSize = (obj) => {
+    if (Number.isInteger(obj.dr)) {
+        if (obj.dr <= 2)
+            return 51;
+        if (obj.dr == 3)
+            return 115;
+        return 222;
+    }
+
+    return 51;
+}
+
+module.exports.api = {
+    getVersionString: () => { return "Yggio Integration"; },
+    checkArgumentsOrExit: (args) => { 
+        const CONSTANTS = require('../constants');
+        if (!args.a)
+            printUsageAndExit("Chirpstack: -a <application-id> is required");
+        if (!args.s)
+            printUsageAndExit("Chirpstack: -s <server url> is required");
+        if (!CONSTANTS.MONGODB.URI)
+            printUsageAndExit("Yggio: MONGODB.URI must be set in constants.json");
+        if (args.c)
+            console.log("Chirpstack: Using custom client id: " + args.c);
+    },
+    connectAndSubscribe: async (args, devices, onUplinkDevicePortBufferDateLatLng) => {
+        const TIMEOUT = 600000; // 10 minutes
+        let interval;
+        let client;
+        const runYggioIntegration = async () => {
+            const { MongoClient } = require("mongodb");
+            const CONSTANTS = require("../constants");
+            try {
+                args.v && console.log("Connecting to Yggio MongoDB");
+                const client = new MongoClient(CONSTANTS.MONGODB.URI, { useUnifiedTopology: true });
+                args.v && console.log("Connected to Yggio MongoDB");
+
+                const database = client.db("fafnir");
+                const entities = database.collection("entities");
+                const devicesResult = await entities
+                    .find({"deviceModelName": "sensative-vsm-lora", "devEui": {$exists: true}})
+                    .toArray();
+                devices = devicesResult.map(device => device.devEui);
+                console.log("Device count: " + devices.length);
+            } catch (e) {
+                console.log("Yggio: Got exception: " + e.message);
+                clearInterval(interval);
+                throw e;
+            }
+
+            args.v && console.log("Trying to connect to " + args.s + " with application " + args.a);
+            try {
+                if (!client?.connected) {
+                    args.v && console.log("Connecting to chirpstack server");
+                    client  = mqtt.connect(args.s, {username: args.u, password: args.p, clientId: args.c || CONSTANTS.MQTT.CLIENT_ID});
+                } else {
+                    args.v && console.log("Already connected to chirpstack server");
+                }
+
+                client.on("connect", () => {
+                    args.v && console.log("Connected to chirpstack server");
+
+                    if (Array.isArray(devices) && devices.length > 0) {
+                        for (let i = 0; i < devices.length; ++i) {
+                            const topic = `application/${args.a}/device/${devices[i].toLowerCase()}/event/up`;
+                            client.subscribe(topic, (err) => {
+                                if (err)
+                                    console.log(`Chirpstack subscribe: ${topic} failed:` + err.message );
+                                else
+                                    args.v && console.log(`Chirpstack subscribed ok to ${topic}`);
+                            });
+                        }
+                    }
+                });
+                client.on("message", async (topic, message) => {
+                    // message is Buffer
+                    args.v && console.log(topic, message.toString());
+
+                    const obj = JSON.parse(message.toString("utf-8"));
+                    if (!obj.data)
+                        return;
+                    const data = Buffer.from(obj.data, "base64");
+                    const port = obj.fPort;
+                    const id = obj.deviceInfo?.devEui || obj.devEUI;
+                    const maxSize = getMaxSize(obj);
+
+                    let lat, lng;
+                    let date;
+                    // Take first gateways lat & lng values, any gateway likely to hear this is likely within 150km
+                    if (obj.rxInfo && obj.rxInfo.length > 0) {
+                        let gwinfo = obj.rxInfo[0];
+                    if (gwinfo.location) {
+                        lat = gwinfo.location.latitude;
+                        lng = gwinfo.location.longitude;
+                    }
+                        date = new Date(gwinfo.time);
+                    }
+                    if (! (date && isDate(date)))
+                        date = new Date()
+
+                    await onUplinkDevicePortBufferDateLatLng(client, id, port, data, date, lat, lng, maxSize);
+                });
+                return client;
+            } catch (e) {
+                console.log("Chirpstack: Got exception: " + e.message);
+                clearInterval(interval);
+                throw e;
+            }
+        };
+        runYggioIntegration();
+        interval = setInterval(runYggioIntegration, TIMEOUT);
+    },
+    sendDownlink: async (client, args, deviceId, port, data, confirmed) => {
+        if (!Buffer.isBuffer(data))
+            throw new Error("Chirpstack sendDownlink: data must be a buffer object");
+        const devEUI = deviceId.toLowerCase();
+        const topic = `application/${args.a}/device/${devEUI}/command/down`;
+        const obj = {
+            devEui: devEUI,
+            confirmed,
+            fPort: port,
+            payload: data.toString("base64"),
+        };
+        client.publish(topic, JSON.stringify(obj));
+        args.v && console.log("Publish downlink on port " + port + " data: " + data.toString("hex"));
+    },
+}
+

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@lifefinder/vsm-mqtt-client-open-source",
+  "version": "0.0.46",
+  "description": "MQTT client for vsm sensors",
+  "main": "vsm-mqtt-client.js",
+  "author": "Lars Mats",
+  "license": "MIT",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "minimist": "1.2.8",
+    "mongodb": "6.3.0",
+    "mqtt": "4.3.7",
+    "node-fetch": "3.3.1",
+    "vsm-translator-open-source": "^0.2.157"
+  }
+}

package/publishers/console.js

@@ -0,0 +1,13 @@
+// Publisher which only displays output on standardout
+
+module.exports.api = {
+    checkArgumentsOrExit: (args) => { },
+    initialize: (args) => { },
+    publish: (args, deviceid, obj) => {
+        console.log(deviceid, obj);
+    },
+    getVersionString: () => {
+        return "Console Publisher";
+    }
+}
+

package/publishers/https.js

@@ -0,0 +1,38 @@
+// Publisher which publishes on https
+const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
+
+const printErrorAndExit = (info) => {
+    console.log(info);
+    process.exit(1);
+}
+
+module.exports.api = {
+    checkArgumentsOrExit: (args) => { 
+        if (!args.S)
+            printErrorAndExit("HTPPS Publisher: -S <url> is required");
+    },
+    initialize: (args) => {
+    },
+    publish: async (args, deviceid, obj) => {
+        const url = args.S;
+        console.log("HTTPS Publish to " + url, deviceid, JSON.stringify(obj));
+        try {
+            await fetch(url, { 
+                method:"POST", 
+                body: JSON.stringify(obj), 
+                headers: {
+                    "Accept": "application/json",
+                    "Content-type" : "application/json",
+                    "cache-control": "no-cache"
+              },}).then(response => response.json())
+              .then(data => {console.log("  Response: ", data); return data; })
+              .catch(err => {console.log("  HTTPS Publish Failed: " + err.message);});
+        } catch (e) {
+            console.log("  HTTPS Publisher: Failed to publish: ", e.message);
+        }
+    },
+    getVersionString: () => {
+        return "HTTPS Publisher";
+    }
+}
+

package/publishers/mqtt.js

@@ -0,0 +1,53 @@
+// Publisher which publishes on mqtt
+
+const mqtt = require('mqtt')
+
+const REPLACE_STRING = "deveui";
+
+const printErrorAndExit = (info) => {
+    console.log(info);
+    process.exit(1);
+}
+
+let client;
+
+module.exports.api = {
+    checkArgumentsOrExit: (args) => { 
+        if (!args.S)
+            printErrorAndExit("MQTT Publisher: -S <mqtt server> is required");
+        if (!args.T)
+            printErrorAndExit("MQTT Publisher: -T <topic format> is required");
+        if (!args.T.includes(REPLACE_STRING))
+            printErrorAndExit("MQTT Publisher: -T <topic format> must contain the substutution string " + REPLACE_STRING)
+    },
+    initialize: (args) => { 
+            /* const options = {
+                // Clean session
+                clean: true,
+                connectTimeout: 4000,
+                // Authentication
+                clientId: args.u,
+                username: args.u,
+                password: args.p,
+            } */
+            
+            client = mqtt.connect(args.S /*, options*/);
+
+            client.on('connect', () => {
+                args.v && console.log("MQTT Publisher: Connected to mqtt broker");
+            });
+    },
+    publish: (args, deviceid, obj) => {
+        console.log("MQTT Publishing", deviceid, obj);
+        const topic = args.T.replace(REPLACE_STRING, deviceid);
+        try {
+            client.publish(topic,  JSON.stringify(obj));
+        } catch (e) {
+            console.log("MQTT Publisher: Failed to publish: ", e.message);
+        }
+    },
+    getVersionString: () => {
+        return "MQTT Publisher";
+    }
+}
+

package/rules.js

@@ -0,0 +1,246 @@
+/*
+The MIT License (MIT)
+
+Copyright Sensative AB 2023. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+const { mergeDeep, delay } = require('./util');
+let translatorVersion = "";
+try {
+  // Running at top level
+  translatorVersion = require('./node_modules/vsm-translator-open-source/package.json').version;
+} catch (e) {
+  // Running as npm package
+  translatorVersion = require('../vsm-translator-open-source/package.json').version;
+}
+console.log("Translator Version: " + translatorVersion);
+
+const ASSISTANCE_INTERVAL_S =  60*30; // max 300km/h
+const MAX_ALMANAC_AGE_S =   60*60*24*30; // This is a monthly process
+const ALMANAC_DOWNLOAD_INTERVAL_S = 60*60*12; // No more frequent tries than this
+
+const byteToHex2 = (b) => {
+  const table = "0123456789abcdef";
+  return "" + table[(b>>4)&0xf] + table[b&0xf];
+}
+
+const int32ToHex8 = (n) => {
+  return "" + byteToHex2(n>>24) + byteToHex2(n>>16) + byteToHex2(n>>8) + byteToHex2(n);
+}
+
+
+const downlinkAssistancePositionIfMissing = async (args, integration, client, solver, deviceid, next, lat, lng) => {
+  if (lat && lng && next && next.gnss) {
+    let updateRequired = false;
+    if (next.gnss.lastAssistanceUpdateAttempt) {
+      lastTime = new Date(next.gnss.lastAssistanceUpdateAttempt);
+      now = new Date();
+      if (now.getTime() - lastTime.getTime() < ASSISTANCE_INTERVAL_S*1000) {
+        return next; // Do nothing
+      }
+    } 
+
+    if (!next.gnss.assistanceLatitude || Math.abs(lat - next.gnss.assistanceLatitude) > 0.1)
+      updateRequired = true;
+    if (!next.gnss.assistanceLongitude || Math.abs(lng - next.gnss.assistanceLongitude) > 0.1)
+      updateRequired = true;
+    if (updateRequired) {
+      next.gnss.lastAssistanceUpdateAttempt = new Date();
+
+      const lat16 = Math.round(2048*lat / 90) & 0xffff;
+      const lon16 = Math.round(2048*lng / 180) & 0xffff;
+      let downlink = "01"; // Begin with 01 which indicates that this is a assisted position
+      let str = lat16.toString(16);
+      while (str.length < 4)
+        str = "0"+str;
+      downlink += str;
+      str = lon16.toString(16);
+      while (str.length < 4)
+        str = "0"+str;
+      downlink += str;
+  
+      integration.api.sendDownlink(client, args, deviceid, 21, Buffer.from(downlink, "hex"), false /* confirmed */ );
+    }
+  }
+  return next;
+}
+
+const downlinkCrcRequest = (args, integration, client, deviceid) => {
+  integration.api.sendDownlink(client, args, deviceid, 15, Buffer.from("00", "hex"), false /* confirmed */ );
+}
+
+const downlinkDeviceTimeDelta = (args, integration, client, deviceid, deltaS) => {
+  let buffer = "08" + int32ToHex8(deltaS);
+  integration.api.sendDownlink(client, args, deviceid, 21, Buffer.from(buffer, "hex"), false /* confirmed */ );
+}
+
+const downlinkAlmanac = async (args, integration, client, solver, deviceid, maxSize) => {
+    const f = async () => {
+        const almanac = await solver.api.loadAlmanac(args);
+        if (!(almanac && almanac.result && almanac.result.almanac_image)) {
+            console.log("Bad alamanac data");
+            return;
+        }
+    
+        const compressedAlmanac = almanac.result.almanac_compressed;
+        const image = compressedAlmanac ? compressedAlmanac : almanac.result.almanac_image;
+    
+        let maxDownlinkSize = maxSize - 6; // Give space for some mac commands
+        if (maxDownlinkSize < 30) {
+          // Does not make sense with this small downlink size for almanac download
+          console.log("Too many almanac downlinks, cancelling until better connection acheived");
+          return;
+        }
+        const almanacTypeStr = (compressedAlmanac ? "Compressed" : "Full");
+        console.log("Almanac image type: " + almanacTypeStr);
+        console.log("Selected payload size: " + maxDownlinkSize);
+        console.log("Almanac image size: " + image.length / 2 );
+        console.log("Downlink count: " + image.length / 2 / maxDownlinkSize);
+    
+        let chunks = image.match(new RegExp('.{1,' + (maxDownlinkSize*2 /* 40 is randomly selected */ ) + '}', 'g'));
+        console.log("Chunks: " + chunks.length);
+    
+        for (let i = 0; i < chunks.length; ++i) {
+            var data;
+            if (i === 0) // Begin new almanac
+                data = "02";
+            else if (i === chunks.length-1) {
+                if (compressedAlmanac)
+                    data = "05"; // End compressed almanac
+                else
+                    data = "04"; // End uncompressed almanac
+            }
+            else
+                data = "03"; // Plain almanac segment
+            data += chunks[i];
+
+            try {
+                await integration.api.sendDownlink(client, args, deviceid, 21, Buffer.from(data, "hex"), true);
+                console.log(deviceid, almanacTypeStr + " Almanac downlink " + (i+1) + " of " + chunks.length + " - enqueueing");
+                await delay(1000); // Increase chance of correct order in chirpstack
+            } catch (e) { return; }
+        }
+    }
+    // Do not await the results here
+    f();
+}
+
+
+const rules = [
+  // Detect if we do not know which application the device is running (meaning it cannot be translated fully)
+  async (args, integration, client, solver, deviceid, next, updates, date, lat, lng) => {
+    // Check if the rules CRC is registerred
+    if (next.vsm && next.vsm.rulesCrc32)
+      return next;
+    // This needs to be resolved ASAP
+    downlinkCrcRequest(args, integration, client, deviceid);
+    return next;
+  },
+
+  // Detect if device time is off, and if so downlink a time correction
+  async (args, integration, client, solver, deviceid, next, updates, date, lat, lng) => {
+    // Check if this update was a gnss message containing deviceTime
+    if (!updates.gnss)
+      return next;
+    if (!(updates.gnss.deviceTime && updates.gnss.deviceTimeTimestamp))
+      return next;
+    let deviceDateS = new Date(updates.gnss.deviceTime).getTime()/1000;
+    let receivedDateS = new Date(updates.gnss.deviceTimeTimestamp).getTime()/1000;
+    let deltaS = receivedDateS - deviceDateS;
+    args.v && console.log("Device time offset: " + deltaS);
+    if (deltaS >= 5 || deltaS <= 5) {
+        // Send downlink
+        console.log("Updating device time for " + deviceid + " by " + deltaS + "s");
+        downlinkDeviceTimeDelta(args, integration, client, deviceid, Math.round(deltaS));
+    }
+    return next;
+  },
+
+  // Solve positions and add the solution to the data
+  async (args, integration, client, solver, deviceid, next, updates, date, lat, lng) => {
+    if (updates.semtechEncoded && !args.hasOwnProperty("N")) {
+      // Call semtech to resolve the location
+      console.log("New positioning data");
+      let solved = await solver.api.solvePosition(args, updates);
+      if (solved && solved.result && solved.result.latitude && solved.result.longitude) {
+        // Extra check: If we have a result here but no assistance data in the device, use this to generate an assistance position
+        // and downlink it to the device
+        downlinkAssistancePositionIfMissing(args, integration, client, solver, deviceid, next, lat, lng);
+        return solved.result;
+      } else {
+        return null;
+      }
+    }
+  },
+
+  // Detect absense of device assistance position OR the too large difference of lat & long vs assistance position,
+  // try to solve that by downloading new assistance position
+  async (args, integration, client, solver, deviceid, next, updates, date, lat, lng) => {
+    // try download from gateway position only if there is no assistance position, else use solutions
+    if (next.gnss && !next.gnss.assistanceLatitude)
+      downlinkAssistancePositionIfMissing(args, integration, client, solver, deviceid, next, lat, lng);
+  },
+
+  // Detect if almanac download is called for
+  async (args, integration, client, solver, deviceid, next, updates, date, lat, lng) => {
+    // Do we know if there is an almanac timestamp?
+    if (!(next.gnss && next.gnss.almanacTimestamp))
+        return next;
+
+    const almanacDate = new Date(next.gnss.almanacTimestamp);
+    if (date.getTime() - almanacDate.getTime() < MAX_ALMANAC_AGE_S*1000)
+        return next; // Unmodified
+
+    const lastAttemptMs = next.gnss.lastAlmanacDownloadAttempt ? new Date(next.gnss.lastAlmanacDownloadAttempt).getTime() : 0;
+    const lastAttemptPeriodS = (date.getTime() - lastAttemptMs)/1000;
+    if (lastAttemptPeriodS < ALMANAC_DOWNLOAD_INTERVAL_S)
+        return next; // Do not attempt a download now
+    next.gnss.lastAlmanacDownloadAttempt = date;
+
+    // Run this asynchronously rather than wait
+    if (!solver.api.downlinkAlmanac) {
+      return next;
+    }
+    downlinkAlmanac(args, integration, client, solver, deviceid, next.encodedData.maxSize);
+
+    return next;
+  },
+
+  // Update translator version
+  async (args, integration, client, solver, deviceid, next, updates, date, lat, lng) => {
+    if (next.vsm) {
+      next.vsm.translatorVersion = translatorVersion;
+    } else 
+      next.vsm = { translatorVersion };
+    return next;
+  },
+];
+
+module.exports.processRules = async (args, integration, client, solver, deviceid, next, updates, date, lat, lng) => {
+  // console.log("processRules - updates:", deviceid, updates);
+  for (let i = 0; i < rules.length; ++i) {
+    synthesized = await rules[i](args, integration, client, solver, deviceid, next, updates, date, lat, lng);
+    if (synthesized) {
+      next = mergeDeep(next, synthesized);
+    }
+  }
+  return next;
+}