signalk-usage 0.1.0

package/README.md

@@ -0,0 +1,18 @@
+# signalk-usage
+
+Uses infuxDB data to caculate tank and electrical usage
+
+## Dependencies
+
+- SignalK server with signalk-to-influxdb2 plugin
+- InfluxDB 2.x 
+
+## Installation
+
+Install via SignalK Appstore or:
+```bash
+cd ~/.signalk
+npm install signalk-usage
+```
+
+Configure InfluxDB connection and paths in plugin settings, then restart SignalK.

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "signalk-usage",
+    "version": "0.1.0",
+    "description": "Track electrical and tank usage",
+    "main": "plugin/index.js",
+    "keywords": [
+      "signalk-node-server-plugin",
+      "signalk-category-utility",
+      "signalk",
+      "usage",
+      "reporting",
+      "analytics",
+      "tanks",
+      "batteries",
+      "influxdb"
+    ],
+    "author": "Oliver Fernander",
+    "license": "MIT",
+    "repository": {
+      "type": "git",
+      "url": "https://github.com/yourusername/signalk-usage.git"
+    },
+    "dependencies": {
+      "@influxdata/influxdb-client": "^1.33.2"
+    },
+    "engines": {
+      "node": ">=16.0.0"
+    },
+    "signalk-plugin-enabled-by-default": false
+  }

package/plugin/index.js

@@ -0,0 +1,149 @@
+const schema = require('./lib/schema');
+const InfluxClient = require('./lib/influx-client');
+const UsageCoordinator = require('./lib/usage-coordinator');
+const Publisher = require('./lib/publisher');
+
+module.exports = function (app) {
+  let plugin = {
+    id: 'signalk-usage',
+    name: 'SignalK Usage',
+    description: 'Report Electrical and Tank Usage',
+    schema: schema,
+    
+    influxClient: null,
+    usageCoordinator: null,
+    publisher: null,
+    updateTimer: null
+  };
+
+  plugin.start = function (options, restartPlugin) {
+    try {
+      app.debug('Starting SignalK Usage plugin');
+      
+      // Validate configuration
+      if (!options.influx) {
+        app.setPluginError('InfluxDB configuration is required');
+        return;
+      }
+
+      const tankageItems = options.tankage || [];
+      const powerItems = options.power || [];
+      
+      if (tankageItems.length === 0 && powerItems.length === 0) {
+        app.setPluginError('At least one tankage or power item must be configured');
+        return;
+      }
+
+      // Initialize InfluxDB client (read-only)
+      plugin.influxClient = new InfluxClient(
+        options.influx,
+        app
+      );
+
+      // Test connection
+      plugin.influxClient.ping()
+        .then(() => {
+          app.debug('InfluxDB connection successful');
+          
+          // Initialize usage coordinator
+          plugin.usageCoordinator = new UsageCoordinator(
+            app,
+            plugin.influxClient,
+            options
+          );
+          
+          // Start periodic updates
+          const updateInterval = (options.reporting?.updateInterval || 60) * 1000;
+          
+          // Initial calculation
+          plugin.usageCoordinator.calculateAll()
+            .then(() => {
+              app.debug('Initial usage calculation complete');
+              
+              // Initialize publisher
+              plugin.publisher = new Publisher(
+                app,
+                plugin.usageCoordinator,
+                options
+              );
+              
+              plugin.publisher.start();
+              
+              app.setPluginStatus('Running');
+            })
+            .catch(err => {
+              app.setPluginError(`Initial calculation failed: ${err.message}`);
+            });
+          
+          // Set up periodic recalculation
+          plugin.updateTimer = setInterval(() => {
+            plugin.usageCoordinator.calculateAll()
+              .catch(err => {
+                app.debug(`Calculation error: ${err.message}`);
+              });
+          }, updateInterval);
+          
+        })
+        .catch(err => {
+          app.setPluginError(`InfluxDB connection failed: ${err.message}`);
+        });
+
+    } catch (err) {
+      app.setPluginError(`Failed to start: ${err.message}`);
+    }
+  };
+
+  plugin.stop = function () {
+    try {
+      app.debug('Stopping SignalK Usage plugin');
+      
+      if (plugin.updateTimer) {
+        clearInterval(plugin.updateTimer);
+        plugin.updateTimer = null;
+      }
+      
+      if (plugin.publisher) {
+        plugin.publisher.stop();
+      }
+      
+      if (plugin.usageCoordinator) {
+        plugin.usageCoordinator.stop();
+      }
+      
+      if (plugin.influxClient) {
+        plugin.influxClient.close();
+      }
+      
+      app.setPluginStatus('Stopped');
+    } catch (err) {
+      app.setPluginError(`Error stopping plugin: ${err.message}`);
+    }
+  };
+
+  // API endpoint to get usage data
+  plugin.registerWithRouter = function (router) {
+    router.get('/usage', (req, res) => {
+      try {
+        const data = plugin.usageCoordinator.getUsageData();
+        res.json(data);
+      } catch (err) {
+        res.status(500).json({ error: err.message });
+      }
+    });
+
+    router.get('/usage/:path', (req, res) => {
+      try {
+        const data = plugin.usageCoordinator.getUsageForPath(req.params.path);
+        if (!data) {
+          res.status(404).json({ error: 'Path not found' });
+        } else {
+          res.json(data);
+        }
+      } catch (err) {
+        res.status(500).json({ error: err.message });
+      }
+    });
+  };
+
+  return plugin;
+};

package/plugin/lib/influx-client.js

@@ -0,0 +1,171 @@
+const { InfluxDB } = require('@influxdata/influxdb-client');
+const { PingAPI } = require('@influxdata/influxdb-client-apis');
+
+function InfluxClient(config, app) {
+  this.config = config;
+  this.app = app;
+  this.client = new InfluxDB({
+    url: config.url,
+    token: config.token
+  });
+  this.queryApi = this.client.getQueryApi(config.org);
+}
+
+InfluxClient.prototype.ping = async function() {
+  try {
+    const pingAPI = new PingAPI(this.client);
+    await pingAPI.getPing();
+    return true;
+  } catch (err) {
+    this.app.debug(`InfluxDB ping failed: ${err.message}`);
+    throw err;
+  }
+};
+
+InfluxClient.prototype.queryPath = async function(path, range, aggregation) {
+  // Use provided aggregation window or fall back to smart default
+  const window = aggregation || this.getAggregateWindow(range);
+  
+  const query = `
+    from(bucket: "${this.config.bucket}")
+      |> range(start: ${range})
+      |> filter(fn: (r) => r._measurement == "${path}")
+      |> filter(fn: (r) => r._field == "value")
+      |> filter(fn: (r) => r.self == "true")
+      |> aggregateWindow(every: ${window}, fn: mean, createEmpty: false)
+      |> sort(columns: ["_time"])
+  `;
+
+  const self = this;
+  
+  return new Promise((resolve, reject) => {
+    const results = [];
+    
+    self.queryApi.queryRows(query, {
+      next: (row, tableMeta) => {
+        const obj = tableMeta.toObject(row);
+        results.push({
+          timestamp: new Date(obj._time),
+          value: obj._value
+        });
+      },
+      error: (err) => {
+        self.app.debug(`Query error for ${path}: ${err.message}`);
+        reject(err);
+      },
+      complete: () => {
+        self.app.debug(`Query complete for ${path}: ${results.length} points (window: ${window})`);
+        resolve(results);
+      }
+    });
+  });
+};
+
+InfluxClient.prototype.queryPathRaw = async function(path, range) {
+  // Query without aggregation for accurate energy integration
+  const query = `
+    from(bucket: "${this.config.bucket}")
+      |> range(start: ${range})
+      |> filter(fn: (r) => r._measurement == "${path}")
+      |> filter(fn: (r) => r._field == "value")
+      |> filter(fn: (r) => r.self == "true")
+      |> sort(columns: ["_time"])
+  `;
+  
+  this.app.debug(`Executing raw query for ${path}:`);
+  this.app.debug(query);
+  
+  const self = this;
+  
+  return new Promise((resolve, reject) => {
+    const results = [];
+    
+    self.queryApi.queryRows(query, {
+      next: (row, tableMeta) => {
+        const obj = tableMeta.toObject(row);
+        results.push({
+          timestamp: new Date(obj._time).getTime(), // Convert to milliseconds
+          value: obj._value
+        });
+      },
+      error: (err) => {
+        self.app.debug(`Query error for ${path}: ${err.message}`);
+        reject(err);
+      },
+      complete: () => {
+        self.app.debug(`Raw query complete for ${path}: ${results.length} points`);
+        resolve(results);
+      }
+    });
+  });
+};
+
+InfluxClient.prototype.getAggregateWindow = function(range) {
+  if (range === '-1h' || range === '-15m') return '1m';
+  if (range === '-6h') return '5m';
+  if (range === '-12h') return '10m';
+  if (range === '-24h') return '15m';
+  if (range === '-7d') return '1h';
+  if (range === '-30d') return '4h';
+  if (range === '-90d') return '12h';
+  return '1m';
+};
+
+InfluxClient.prototype.getFirstAndLast = async function(path, range) {
+  const query = `
+    from(bucket: "${this.config.bucket}")
+      |> range(start: ${range})
+      |> filter(fn: (r) => r._measurement == "${path}")
+      |> filter(fn: (r) => r._field == "value")
+      |> filter(fn: (r) => r.self == "true")
+  `;
+  
+  this.app.debug(`Executing query for ${path}:`);
+  this.app.debug(query);
+  
+  const firstQuery = query + '\n|> first()';
+  const lastQuery = query + '\n|> last()';
+  
+  try {
+    const [first, last] = await Promise.all([
+      this.executeSingleValueQuery(firstQuery),
+      this.executeSingleValueQuery(lastQuery)
+    ]);
+    
+    this.app.debug(`Query results for ${path}: first=${first ? first.value : 'null'}, last=${last ? last.value : 'null'}`);
+    
+    return { first, last };
+  } catch (err) {
+    this.app.debug(`Error getting first/last for ${path}: ${err.message}`);
+    throw err;
+  }
+};
+
+InfluxClient.prototype.executeSingleValueQuery = function(query) {
+  const self = this;
+  return new Promise((resolve, reject) => {
+    let result = null;
+    
+    self.queryApi.queryRows(query, {
+      next: (row, tableMeta) => {
+        const obj = tableMeta.toObject(row);
+        result = {
+          timestamp: new Date(obj._time),
+          value: obj._value
+        };
+      },
+      error: reject,
+      complete: () => resolve(result)
+    });
+  });
+};
+
+InfluxClient.prototype.close = function() {
+  try {
+    this.app.debug('InfluxDB client closed');
+  } catch (err) {
+    this.app.debug(`Error closing InfluxDB client: ${err.message}`);
+  }
+};
+
+module.exports = InfluxClient;