signalk-usage 0.1.3 → 0.1.4

package/package.json

@@ -1,30 +1,38 @@
 {
-    "name": "signalk-usage",
-    "version": "0.1.3",
-    "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": "git+https://github.com/ofernander/signalk-usage.git"
-    },
-    "dependencies": {
-        "@influxdata/influxdb-client": "^1.33.2"
-    },
-    "engines": {
-        "node": ">=16.0.0"
-    },
-    "signalk-plugin-enabled-by-default": false
-}
+  "name": "signalk-usage",
+  "version": "0.1.4",
+  "description": "Track electrical and tank usage with web UI",
+  "main": "plugin/index.js",
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-webapp",
+    "signalk-category-utility",
+    "signalk",
+    "usage",
+    "reporting",
+    "analytics",
+    "tanks",
+    "batteries",
+    "influxdb"
+  ],
+  "author": {
+    "name": "Oliver Fernander",
+    "email": "oliver@fernander.net"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ofernander/signalk-usage.git"
+  },
+  "dependencies": {
+    "@influxdata/influxdb-client": "^1.33.2"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "signalk": {
+    "appIcon": "./assets/icons/signalk-usage-icon_72x72.png",
+    "displayName": "SignalK-Usage"
+  },
+  "signalk-plugin-enabled-by-default": true
+}

package/plugin/index.js

@@ -1,7 +1,8 @@
 const schema = require('./lib/schema');
-const InfluxClient = require('./lib/influx-client');
-const UsageCoordinator = require('./lib/usage-coordinator');
+const InfluxClient = require('./lib/influxClient');
+const UsageCoordinator = require('./lib/usageCoordinator');
 const Publisher = require('./lib/publisher');
+const routes = require('./lib/routes');
 
 module.exports = function (app) {
   let plugin = {
@@ -120,29 +121,9 @@ module.exports = function (app) {
     }
   };
 
-  // API endpoint to get usage data
+  // Register routes
   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 });
-      }
-    });
+    routes(router, app, plugin);
   };
 
   return plugin;

package/plugin/lib/{influx-client.js → influxClient.js}

@@ -100,6 +100,45 @@ InfluxClient.prototype.queryPathRaw = async function(path, range) {
   });
 };
 
+InfluxClient.prototype.queryPathCustomRange = async function(path, start, end, aggregation) {
+  const query = `
+    from(bucket: "${this.config.bucket}")
+      |> range(start: ${start}, stop: ${end})
+      |> filter(fn: (r) => r._measurement == "${path}")
+      |> filter(fn: (r) => r._field == "value")
+      |> filter(fn: (r) => r.self == "true")
+      |> aggregateWindow(every: ${aggregation}, fn: mean, createEmpty: false)
+      |> sort(columns: ["_time"])
+  `;
+
+  this.app.debug(`Executing custom range 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(),
+          value: obj._value
+        });
+      },
+      error: (err) => {
+        self.app.debug(`Custom query error for ${path}: ${err.message}`);
+        reject(err);
+      },
+      complete: () => {
+        self.app.debug(`Custom 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';

package/plugin/lib/{power-engine.js → powerEngine.js}

@@ -290,6 +290,21 @@ PowerEngine.prototype.autoDetectDirectionalityType = function(path) {
   }
 };
 
+PowerEngine.prototype.autoDetectBidirectionalPolarity = function(positiveEnergyWh, negativeEnergyWh) {
+  // For bidirectional items, detect which direction is which based on magnitudes
+  // If positive energy is significantly larger, it's likely normal polarity
+  // If negative energy is larger, it's likely reversed
+  
+  if (positiveEnergyWh > negativeEnergyWh * 1.5) {
+    return 'normal';  // Positive = generated, Negative = consumed
+  } else if (negativeEnergyWh > positiveEnergyWh * 1.5) {
+    return 'reversed';  // Positive = consumed, Negative = generated
+  } else {
+    // Similar magnitudes - default to normal
+    return 'normal';
+  }
+};
+
 PowerEngine.prototype.applyDirectionality = function(path, directionality, positiveEnergyWh, negativeEnergyWh) {
   let consumedWh, generatedWh, appliedDirectionality;
   
@@ -312,6 +327,20 @@ PowerEngine.prototype.applyDirectionality = function(path, directionality, posit
       }
       break;
       
+    case 'bidirectional':
+      // Simple bidirectional - use auto-detection to determine normal vs reversed
+      const detectedDirection = this.autoDetectBidirectionalPolarity(positiveEnergyWh, negativeEnergyWh);
+      if (detectedDirection === 'normal') {
+        consumedWh = negativeEnergyWh;
+        generatedWh = positiveEnergyWh;
+        appliedDirectionality = 'bidirectional (auto-detected normal)';
+      } else {
+        consumedWh = positiveEnergyWh;
+        generatedWh = negativeEnergyWh;
+        appliedDirectionality = 'bidirectional (auto-detected reversed)';
+      }
+      break;
+      
     case 'bidirectional-normal':
       consumedWh = negativeEnergyWh;
       generatedWh = positiveEnergyWh;

package/plugin/lib/publisher.js

@@ -101,10 +101,10 @@ Publisher.prototype.publishTankageItems = function(items, deltas, meta) {
         return;
       }
       
-      // Publish totals with 1 decimal place
+      // Publish totals with 3 decimal places for better precision when converting to L/gal
       deltas.push({
         path: `${basePath}.consumed.${period}`,
-        value: this.round(periodData.consumed || 0, 1)
+        value: this.round(periodData.consumed || 0, 3)
       });
       meta.push({
         path: `${basePath}.consumed.${period}`,
@@ -113,22 +113,12 @@ Publisher.prototype.publishTankageItems = function(items, deltas, meta) {
       
       deltas.push({
         path: `${basePath}.added.${period}`,
-        value: this.round(periodData.added || 0, 1)
+        value: this.round(periodData.added || 0, 3)
       });
       meta.push({
         path: `${basePath}.added.${period}`,
         value: { units: unit }
       });
-      
-      // Publish rates with 4 decimal places (more precision needed)
-      deltas.push({
-        path: `${basePath}.consumptionRate.${period}`,
-        value: this.round(periodData.consumptionRate || 0, 4)
-      });
-      meta.push({
-        path: `${basePath}.consumptionRate.${period}`,
-        value: { units: `${unit}/h` }
-      });
     });
   });
 };
@@ -224,11 +214,8 @@ Publisher.prototype.publishPowerItems = function(items, deltas, meta) {
 };
 
 Publisher.prototype.getBasePath = function(item) {
-  // If user provided a custom name, use it in the path
-  // Otherwise use the full SignalK path
-  if (item.name && item.name !== item.path) {
-    return 'usage.' + item.name;
-  }
+  // Always use the full SignalK path for deltas
+  // Display name is only for UI presentation
   return 'usage.' + item.path;
 };
 

package/plugin/lib/routes.js

@@ -0,0 +1,140 @@
+const path = require('path');
+
+module.exports = function(router, app, plugin) {
+  // Serve static files from public directory
+  router.use('/', (req, res, next) => {
+    const express = require('express');
+    const staticHandler = express.static(path.join(__dirname, '../../public'));
+    staticHandler(req, res, next);
+  });
+
+  // Serve index.html at root
+  router.get('/', (req, res) => {
+    res.sendFile(path.join(__dirname, '../../public/index.html'));
+  });
+
+  // Get all usage data
+  router.get('/api/usage', (req, res) => {
+    try {
+      if (!plugin.usageCoordinator) {
+        return res.status(503).json({ error: 'Plugin not initialized' });
+      }
+      
+      const data = plugin.usageCoordinator.getUsageData();
+      res.json(data);
+    } catch (err) {
+      app.debug(`Error getting usage data: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Get usage for specific path
+  router.get('/api/usage/:path', (req, res) => {
+    try {
+      if (!plugin.usageCoordinator) {
+        return res.status(503).json({ error: 'Plugin not initialized' });
+      }
+      
+      const data = plugin.usageCoordinator.getUsageForPath(req.params.path);
+      if (!data) {
+        res.status(404).json({ error: 'Path not found' });
+      } else {
+        res.json(data);
+      }
+    } catch (err) {
+      app.debug(`Error getting usage for path: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Custom time range query endpoint
+  router.post('/api/query', (req, res) => {
+    (async () => {
+      try {
+        const { path, start, end, aggregation } = req.body;
+
+        if (!path || !start || !end) {
+          return res.status(400).json({ 
+            error: 'Missing required parameters: path, start, end' 
+          });
+        }
+
+        if (!plugin.influxClient) {
+          return res.status(503).json({ error: 'InfluxDB client not initialized' });
+        }
+
+        // Calculate time range
+        const startTime = new Date(start);
+        const endTime = new Date(end);
+        const rangeMs = endTime - startTime;
+        
+        // Use provided aggregation or calculate default
+        const aggWindow = aggregation || plugin.usageCoordinator.calculateAggregation(rangeMs);
+
+        app.debug(`Custom query: ${path} from ${start} to ${end}, aggregation: ${aggWindow}`);
+
+        // Query data from InfluxDB
+        const dataPoints = await plugin.influxClient.queryPathCustomRange(
+          path,
+          start,
+          end,
+          aggWindow
+        );
+
+        if (!dataPoints || dataPoints.length === 0) {
+          return res.json({
+            data: [],
+            start,
+            end,
+            aggregation: aggWindow,
+            message: 'No data found for the specified range'
+          });
+        }
+
+        // Determine item type
+        const itemConfig = plugin.usageCoordinator.findItemConfig(path);
+        const isPower = itemConfig && itemConfig.type === 'power';
+
+        let result = {
+          data: dataPoints,
+          start,
+          end,
+          aggregation: aggWindow,
+          type: isPower ? 'power' : 'tankage'
+        };
+
+        // Calculate energy if it's a power item
+        if (isPower) {
+          result.energy = plugin.usageCoordinator.calculateEnergyFromData(
+            dataPoints,
+            itemConfig
+          );
+        }
+
+        res.json(result);
+
+      } catch (err) {
+        app.debug(`Custom query error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+      }
+    })();
+  });
+
+  // Get configuration
+  router.get('/api/config', (req, res) => {
+    try {
+      if (!plugin.usageCoordinator) {
+        return res.status(503).json({ error: 'Plugin not initialized' });
+      }
+      
+      res.json({
+        power: plugin.usageCoordinator.options.power || [],
+        tankage: plugin.usageCoordinator.options.tankage || [],
+        reporting: plugin.usageCoordinator.options.reporting || {}
+      });
+    } catch (err) {
+      app.debug(`Error getting config: ${err.message}`);
+      res.status(500).json({ error: err.message });
+    }
+  });
+};

package/plugin/lib/schema.js

@@ -49,8 +49,8 @@ module.exports = {
           },
           name: {
             type: 'string',
-            title: 'Name',
-            description: 'Display name (optional, defaults to path)'
+            title: 'Display Name',
+            description: 'Optional friendly name for this tank'
           },
           periods: {
             type: 'array',
@@ -58,9 +58,9 @@ module.exports = {
             format: 'table',
             default: [
               { range: '1h', aggregation: '1m' },
-              { range: '24h', aggregation: '3m' },
-              { range: '7d', aggregation: '5m' },
-              { range: '30d', aggregation: '10m' }
+              { range: '24h', aggregation: '15m' },
+              { range: '7d', aggregation: '1h' },
+              { range: '30d', aggregation: '4h' }
             ],
             items: {
               type: 'object',
@@ -69,19 +69,16 @@ module.exports = {
               properties: {
                 range: {
                   type: 'string',
-                  title: 'Range'
+                  title: 'Range',
+                  description: 'Time range (e.g., 30s, 1h, 24h, 7d, 30d)'
                 },
                 aggregation: {
                   type: 'string',
-                  title: 'Aggregation'
+                  title: 'Aggregation',
+                  description: 'Data aggregation window (e.g., 5s, 1m, 15m, 1h)'
                 }
               }
             }
-          },
-          enabled: {
-            type: 'boolean',
-            title: 'Enabled',
-            default: true
           }
         }
       }
@@ -92,7 +89,7 @@ module.exports = {
       default: [],
       items: {
         type: 'object',
-        title: 'Power Source',
+        title: 'Power Item',
         required: ['path', 'periods'],
         properties: {
           path: {
@@ -102,15 +99,15 @@ module.exports = {
           },
           name: {
             type: 'string',
-            title: 'Name',
-            description: 'Display name (optional, defaults to path)'
+            title: 'Display Name',
+            description: 'Optional friendly name for this item'
           },
           directionality: {
             type: 'string',
-            title: 'Direction',
-            enum: ['', 'producer', 'consumer', 'bidirectional-normal', 'bidirectional-reversed'],
-            description: 'Energy flow direction (blank = auto-detect)',
-            default: ''
+            title: 'Directionality',
+            enum: ['producer', 'consumer', 'bidirectional', 'auto'],
+            default: 'auto',
+            description: 'How power flows: producer (generates), consumer (uses), bidirectional (both), or auto (detect from data)'
           },
           periods: {
             type: 'array',
@@ -118,9 +115,9 @@ module.exports = {
             format: 'table',
             default: [
               { range: '1h', aggregation: '1m' },
-              { range: '24h', aggregation: '3m' },
-              { range: '7d', aggregation: '5m' },
-              { range: '30d', aggregation: '10m' }
+              { range: '24h', aggregation: '15m' },
+              { range: '7d', aggregation: '1h' },
+              { range: '30d', aggregation: '4h' }
             ],
             items: {
               type: 'object',
@@ -129,11 +126,13 @@ module.exports = {
               properties: {
                 range: {
                   type: 'string',
-                  title: 'Range'
+                  title: 'Range',
+                  description: 'Time range (e.g., 30m, 1h, 24h, 7d, 30d)'
                 },
                 aggregation: {
                   type: 'string',
-                  title: 'Aggregation'
+                  title: 'Aggregation',
+                  description: 'Data aggregation window (e.g., 30s, 1m, 15m, 1h)'
                 }
               }
             }
@@ -161,6 +160,13 @@ module.exports = {
           title: 'Cache Results',
           default: true,
           description: 'Cache calculated results to reduce InfluxDB queries'
+        },
+        unitPreference: {
+          type: 'string',
+          title: 'Volume Units (Web UI)',
+          enum: ['metric', 'imperial'],
+          default: 'metric',
+          description: 'Display volumes in Liters (metric) or Gallons (imperial) in the web interface'
         }
       }
     }

package/plugin/lib/{tankage-engine.js → tankageEngine.js}

@@ -170,24 +170,23 @@ TankageEngine.prototype.calculateUsageForPeriod = async function(item, period) {
       };
     }
 
-    // Sum all increases and decreases from aggregated data
-    // No threshold needed - aggregation already smoothed out boat motion
-    let totalAdded = 0;
+    // Simple net change approach: first reading vs last reading
+    // No summing between points, no threshold needed
+    const netChange = last.value - first.value;
+    
+    this.app.debug(`TankageEngine: ${path} - Start: ${first.value.toFixed(4)} m³, End: ${last.value.toFixed(4)} m³, Net Change: ${netChange.toFixed(4)} m³ (${(netChange / 0.00378541).toFixed(2)} gal)`);
+    
+    // If net is negative: consumed (tank went down)
+    // If net is positive: added (tank went up)
     let totalConsumed = 0;
+    let totalAdded = 0;
     
-    for (let i = 1; i < dataPoints.length; i++) {
-      const prev = dataPoints[i - 1];
-      const curr = dataPoints[i];
-      const change = curr.value - prev.value;
-      
-      if (change > 0) {
-        totalAdded += change;
-      } else if (change < 0) {
-        totalConsumed += Math.abs(change);
-      }
+    if (netChange < 0) {
+      totalConsumed = Math.abs(netChange);
+    } else if (netChange > 0) {
+      totalAdded = netChange;
     }
-    
-    this.app.debug(`TankageEngine: ${path} - Added: ${totalAdded.toFixed(4)}, Consumed: ${totalConsumed.toFixed(4)} from ${dataPoints.length} aggregated points`);
+    // If netChange === 0, both stay 0
     
     usage.consumed = totalConsumed;
     usage.added = totalAdded;