@rhizomatics/signalk-bluetti-plugin 1.4.1 → 1.5.1

package/index.js

@@ -5,10 +5,10 @@ const path = require("path");
 const fs = require("fs");
 
 const PLUGIN_ID = "signalk-bluetti-plugin";
-const REGISTERS_DIR = path.join(__dirname, "registers");
+const DEVICES_DIR = path.join(__dirname, "devices");
 
 // Bluetti device BLE name prefixes (mirrors scanner.js).
-const BLUETTI_PREFIXES = ["BT-TH-", "BLUETTI", "AC", "EP", "EB", "EL"];
+const BLUETTI_PREFIXES = ["BT-TH-", "BLUETTI", "AC", "EP", "EB", "EL", "PR", "AP"];
 
 // Search $HOME for exactly one CSV whose stem looks like a Bluetti device ID.
 // Returns the full path if exactly one match, empty string otherwise.
@@ -26,18 +26,28 @@ function findBluettiEncryptionCsvInHome() {
   }
 }
 
-function builtinModelNames() {
+function yamlModelNames(dir) {
   try {
     return fs
-      .readdirSync(REGISTERS_DIR)
-      .filter((f) => f.endsWith(".csv"))
-      .map((f) => f.replace(/\.csv$/, ""))
+      .readdirSync(dir)
+      .filter((f) => /\.ya?ml$/.test(f))
+      .map((f) => f.replace(/\.ya?ml$/, ""))
       .sort();
   } catch {
     return [];
   }
 }
 
+// The directory a user can drop their own device configuration YAML files into,
+// without needing to fork/publish the plugin — defaults to a `bluetti`
+// subdirectory of the SignalK home directory (e.g. ~/.signalk/bluetti).
+// `app.config.configPath` isn't part of the documented plugin API but is the
+// long-established way plugins locate the SignalK home directory.
+function defaultUserRegistersDir(app) {
+  const home = app && app.config && app.config.configPath;
+  return home ? path.join(home, "bluetti") : null;
+}
+
 module.exports = function (app) {
   const log = (msg) => app.debug(msg);
 
@@ -46,7 +56,15 @@ module.exports = function (app) {
   let scanResultCache = [];
   let waitingStatusTimer = null;
 
-  const builtins = builtinModelNames();
+  const defaultUserDir = defaultUserRegistersDir(app);
+  const builtins = yamlModelNames(DEVICES_DIR);
+  // Models available for the dropdown at schema-render time — bundled plus
+  // whatever's already sitting in the default user directory. If `registersDir`
+  // is overridden away from the default, models unique to that directory won't
+  // appear here until the plugin restarts with the new setting saved.
+  const allModels = [...new Set([...builtins, ...(defaultUserDir ? yamlModelNames(defaultUserDir) : [])])].sort((a, b) =>
+    a.localeCompare(b),
+  );
 
   // ── Plugin metadata ────────────────────────────────────────────────────
 
@@ -65,9 +83,15 @@ module.exports = function (app) {
       scanOnStart: {
         type: "boolean",
         title: "Scan for new devices on plugin start",
-        description: "Runs a 15-second BLE scan and logs discovered Bluetti devices. Useful for finding device addresses.",
+        description: "Runs a short BLE scan and logs discovered Bluetti devices. Useful for finding device addresses.",
         default: true,
       },
+      registersDir: {
+        type: "string",
+        title: "Custom Device Configuration Directory",
+        description: `Directory to scan for your own device configuration YAML files (e.g. for a model this plugin doesn't bundle yet), in addition to the ones built in. Leave blank to use the default: ${defaultUserDir || "<SignalK home>/bluetti"}.`,
+        default: "",
+      },
       devices: {
         type: "array",
         title: "Devices",
@@ -93,16 +117,11 @@ module.exports = function (app) {
             },
             builtinModel: {
               type: "string",
-              title: "Built-in register map",
-              description: 'Select a bundled register map for your device model, or "custom" to supply your own CSV path below.',
-              enum: ["custom", ...builtins],
-              default: builtins.length > 0 ? builtins[0] : "custom",
-            },
-            csvPath: {
-              type: "string",
-              title: "Custom register map CSV path",
-              description: 'Absolute path to a register definition CSV. Only used when "custom" is selected above.',
-              default: "",
+              title: "Device Configuration",
+              description:
+                "Select a device configuration for your model — bundled with the plugin, or dropped into the custom device configuration directory above.",
+              enum: allModels,
+              default: allModels.length > 0 ? allModels[0] : "",
             },
             encryptionCsvPath: {
               type: "string",
@@ -124,11 +143,11 @@ module.exports = function (app) {
   };
 
   plugin.uiSchema = {
+    registersDir: { "ui:placeholder": defaultUserDir || "e.g. /home/pi/.signalk/bluetti" },
     devices: {
       items: {
         address: { "ui:placeholder": "aa:bb:cc:dd:ee:ff" },
         name: { "ui:placeholder": "house" },
-        csvPath: { "ui:placeholder": "e.g. /path/to/my-device-registers.csv" },
         encryptionCsvPath: { "ui:placeholder": "e.g. /path/to/19e1646709e0421b755fa9dda74.csv" },
       },
     },
@@ -137,11 +156,11 @@ module.exports = function (app) {
   // ── Start ──────────────────────────────────────────────────────────────
 
   plugin.start = function (options) {
-    let Scanner, BluettiDevice, loadCsv, buildDelta, readEncryptionKey;
+    let Scanner, BluettiDevice, loadRegisters, buildDelta, readEncryptionKey;
     try {
       Scanner = require("./lib/scanner");
       BluettiDevice = require("./lib/device");
-      ({ loadCsv } = require("./lib/csv-loader"));
+      ({ loadRegisters } = require("./lib/register-loader"));
       ({ buildDelta } = require("./lib/path-mapper"));
       ({ readEncryptionKey } = require("./lib/encryption"));
     } catch (err) {
@@ -149,6 +168,15 @@ module.exports = function (app) {
       return;
     }
 
+    const userRegistersDir = options.registersDir || defaultUserDir;
+    if (userRegistersDir) {
+      try {
+        fs.mkdirSync(userRegistersDir, { recursive: true });
+      } catch (err) {
+        log(`Could not create custom device configuration directory "${userRegistersDir}": ${err.message}`);
+      }
+    }
+
     scanner = new Scanner(log);
 
     const devices = (options.devices || []).filter((d) => d.enabled !== false);
@@ -185,7 +213,7 @@ module.exports = function (app) {
     // Build address → cfg lookup (normalise to lowercase, no colons)
     const normalise = (addr) => addr.toLowerCase().replace(/:/g, "");
     const pending = new Map(devices.map((cfg) => [normalise(cfg.address), cfg]));
-    const deps = { BluettiDevice, loadCsv, buildDelta, readEncryptionKey };
+    const deps = { BluettiDevice, loadRegisters, buildDelta, readEncryptionKey, userRegistersDir };
 
     scanner.on("discovered", ({ address, name, device: bleDevice }) => {
       scanResultCache.push({ address, name });
@@ -260,22 +288,37 @@ module.exports = function (app) {
     return null;
   }
 
-  function resolveRegisterMapPath(cfg) {
-    const { builtinModel, csvPath } = cfg;
-    if (!builtinModel || builtinModel === "custom") {
-      if (!csvPath) throw new Error("No register map: select a built-in model or provide a custom CSV path");
-      return csvPath;
+  // Finds <model>.yaml (or .yml), checking the custom directory before the
+  // bundled one so a user's own file can override a built-in of the same name.
+  function findModelFile(model, userRegistersDir) {
+    const dirs = [userRegistersDir, DEVICES_DIR].filter(Boolean);
+    for (const dir of dirs) {
+      for (const ext of [".yaml", ".yml"]) {
+        const p = path.join(dir, `${model}${ext}`);
+        if (fs.existsSync(p)) return p;
+      }
     }
-    return path.join(REGISTERS_DIR, `${builtinModel}.csv`);
+    return null;
+  }
+
+  function resolveRegisterMapPath(cfg, userRegistersDir) {
+    const { builtinModel } = cfg;
+    if (!builtinModel) throw new Error("No device configuration: select a model");
+    const found = findModelFile(builtinModel, userRegistersDir);
+    if (!found)
+      throw new Error(
+        `Device configuration "${builtinModel}" not found (checked ${userRegistersDir ? `${userRegistersDir} and ` : ""}${DEVICES_DIR})`,
+      );
+    return found;
   }
 
-  function startDevice(cfg, bleDevice, bleName, { BluettiDevice, loadCsv, buildDelta, readEncryptionKey }) {
+  function startDevice(cfg, bleDevice, bleName, { BluettiDevice, loadRegisters, buildDelta, readEncryptionKey, userRegistersDir }) {
     const { address, name, encryptionCsvPath = "", pollIntervalSeconds = 10 } = cfg;
     const registerCache = new Map(); // last-known value per field_name, across polls — see buildDelta
 
     let registerPath;
     try {
-      registerPath = resolveRegisterMapPath(cfg);
+      registerPath = resolveRegisterMapPath(cfg, userRegistersDir);
     } catch (err) {
       app.setPluginError(`[${name}] ${err.message}`);
       return;
@@ -283,10 +326,10 @@ module.exports = function (app) {
 
     let fields;
     try {
-      fields = loadCsv(registerPath);
+      fields = loadRegisters(registerPath);
       log(`[${name}] Loaded ${fields.length} registers from ${registerPath}`);
     } catch (err) {
-      app.setPluginError(`[${name}] Failed to load register map "${registerPath}": ${err.message}`);
+      app.setPluginError(`[${name}] Failed to load device configuration "${registerPath}": ${err.message}`);
       return;
     }
 

package/lib/path-mapper.js

@@ -1,9 +1,9 @@
 "use strict";
 
-const { decodeValue } = require("./csv-loader");
+const { decodeValue } = require("./register-loader");
 
 // SignalK requires specific SI units. These conversions handle the most common
-// cases found in Bluetti register maps. The CSV's `unit` column drives the choice.
+// cases found in Bluetti register maps. The YAML field's `unit` key drives the choice.
 const UNIT_CONVERSIONS = {
   // temperature: Bluetti reports in °C or 0.1°C (handled by scale), SignalK wants K
   c: (v) => v + 273.15,
@@ -30,9 +30,9 @@ function convertUnits(value, unit) {
 }
 
 // Canonical field_name → SignalK path for the register names Bluetti's own
-// documentation and the bundled CSVs use. A CSV's `signalk_path` column is an
+// documentation and the bundled register maps use. A field's `path` key is an
 // override on top of this — only needed for a register the code doesn't know
-// about — so bundled/well-known CSVs can leave it blank and just list
+// about — so bundled/well-known register maps can leave it out and just list
 // field_name + register info.
 //
 // ac_input_power, ac_input_voltage, and dc_output_power are intentionally
@@ -69,13 +69,55 @@ const STANDARD_FIELD_PATHS = {
   // registers for them; if not, current is derived (see buildDelta below).
   ac_input_current: "electrical.chargers.{name}.current",
   ac_input_frequency: "electrical.chargers.{name}.frequency",
+  grid_frequency: "electrical.chargers.{name}.frequency", // alias used by 3-phase/home-backup models
+
+  // Lifetime energy generation counter (some models only)
+  power_generation: "electrical.solar.{name}.energyGeneratedTotal",
+
+  // Second PV string (dual-MPPT models) — the primary string uses dc_input_* above
+  pv_s2_power: "electrical.solar.{name}.pv2.panelPower",
+  pv_s2_voltage: "electrical.solar.{name}.pv2.panelVoltage",
+  pv_s2_current: "electrical.solar.{name}.pv2.panelCurrent",
+
+  // Per-phase grid (mains) input — split-phase/3-phase home-backup models
+  grid_p1_power: "electrical.chargers.{name}.L1.power",
+  grid_p1_voltage: "electrical.chargers.{name}.L1.voltage",
+  grid_p1_current: "electrical.chargers.{name}.L1.current",
+  grid_p2_power: "electrical.chargers.{name}.L2.power",
+  grid_p2_voltage: "electrical.chargers.{name}.L2.voltage",
+  grid_p2_current: "electrical.chargers.{name}.L2.current",
+  grid_p3_power: "electrical.chargers.{name}.L3.power",
+  grid_p3_voltage: "electrical.chargers.{name}.L3.voltage",
+  grid_p3_current: "electrical.chargers.{name}.L3.current",
+
+  // Per-phase AC output — split-phase/3-phase home-backup models
+  ac_p1_power: "electrical.inverters.{name}.ac.L1.realPower",
+  ac_p1_voltage: "electrical.inverters.{name}.ac.L1.voltage",
+  ac_p1_current: "electrical.inverters.{name}.ac.L1.current",
+  ac_p2_power: "electrical.inverters.{name}.ac.L2.realPower",
+  ac_p2_voltage: "electrical.inverters.{name}.ac.L2.voltage",
+  ac_p2_current: "electrical.inverters.{name}.ac.L2.current",
+  ac_p3_power: "electrical.inverters.{name}.ac.L3.realPower",
+  ac_p3_voltage: "electrical.inverters.{name}.ac.L3.voltage",
+  ac_p3_current: "electrical.inverters.{name}.ac.L3.current",
+
+  // Smart meter (external CT clamp on the home panel) — home-backup models only
+  sm_p1_power: "electrical.inverters.{name}.smartMeter.L1.power",
+  sm_p1_voltage: "electrical.inverters.{name}.smartMeter.L1.voltage",
+  sm_p1_current: "electrical.inverters.{name}.smartMeter.L1.current",
+  sm_p2_power: "electrical.inverters.{name}.smartMeter.L2.power",
+  sm_p2_voltage: "electrical.inverters.{name}.smartMeter.L2.voltage",
+  sm_p2_current: "electrical.inverters.{name}.smartMeter.L2.current",
+  sm_p3_power: "electrical.inverters.{name}.smartMeter.L3.power",
+  sm_p3_voltage: "electrical.inverters.{name}.smartMeter.L3.voltage",
+  sm_p3_current: "electrical.inverters.{name}.smartMeter.L3.current",
 };
 
 // Fields that feed a derived computation in buildDelta() rather than being
 // published under their own path directly.
 const DERIVED_SOURCE_FIELDS = new Set(["ac_input_power", "ac_input_voltage", "dc_output_power", "dc_output_voltage"]);
 
-// Build a SignalK path for a field: explicit CSV override first, then the
+// Build a SignalK path for a field: explicit `path` override first, then the
 // standard field_name registry above, then a best-effort keyword guess.
 function resolvePath(field, deviceName) {
   if (field.signalkPath) {
@@ -88,7 +130,7 @@ function resolvePath(field, deviceName) {
 
 // Best-effort automatic path generation for common Bluetti field names.
 // Only reached for fields not in STANDARD_FIELD_PATHS above — i.e. a custom
-// CSV using field names the code doesn't recognise and no explicit override.
+// register map using field names the code doesn't recognise and no explicit override.
 function autoPath(fieldName, name) {
   const f = fieldName.toLowerCase();
   if (f.includes("battery") || f.includes("batt") || f.includes("soc")) {
@@ -163,8 +205,8 @@ function buildDelta(registers, fields, deviceName, source, opts = {}) {
   }
 
   // DC output port (e.g. a 12V accessory socket): Bluetti reports power only,
-  // at a fixed nominal voltage that isn't itself a register — the CSV supplies
-  // it as a constant (dc_output_voltage), and current is derived from that.
+  // at a fixed nominal voltage that isn't itself a register — the register map
+  // supplies it as a constant (dc_output_voltage), and current is derived from that.
   if (cache.has("dc_output_power") && cache.has("dc_output_voltage")) {
     const power = cache.get("dc_output_power");
     const voltage = cache.get("dc_output_voltage");
@@ -174,7 +216,7 @@ function buildDelta(registers, fields, deviceName, source, opts = {}) {
 
   // Remaining capacity = nominal capacity × state of charge. Bluetti's own
   // "remaining capacity" register drifts with cell aging and isn't available
-  // on every model; deriving it from a fixed nominal spec (see registers/*.csv)
+  // on every model; deriving it from a fixed nominal spec (see devices/*.yaml)
   // plus the reported SoC is simpler and consistent across models.
   const soc = cache.has("battery_soc") ? cache.get("battery_soc") : cache.has("battery_percent") ? cache.get("battery_percent") : null;
   if (soc !== null && cache.has("total_capacity")) {

package/lib/register-loader.js

@@ -0,0 +1,120 @@
+"use strict";
+
+const fs = require("fs");
+const YAML = require("yaml");
+
+// Parse a register map YAML file and return an array of field descriptors.
+// Each descriptor is either register-backed: { fieldName, register, count, dataType, scale, offset, unit, signalkPath }
+// or a fixed constant (no register on the device): { fieldName, register: null, count: 0, dataType: "const", ..., constantValue }
+//
+// Expected shape:
+//
+//   fields:
+//     battery_soc: { register: 100, type: uint16, unit: "%" }
+//     battery_voltage: { register: 101, type: uint16, scale: 0.1, unit: V }
+//   constants:
+//     battery_chemistry: LiFePO4
+//     total_capacity: { value: 2000, unit: Wh }
+//
+// `type` defaults to uint16, `scale` to 1, `offset` to 0, `count` is inferred
+// from `type` when absent. `path` on a field/constant is an explicit SignalK
+// path override (see lib/path-mapper.js). A constant may be a bare scalar
+// (string or number) or an object with `value` (+ optional `unit`, `path`).
+function loadRegisters(filePath) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const doc = YAML.parse(raw);
+  if (!doc || typeof doc !== "object") throw new Error(`${filePath}: empty or invalid YAML register map`);
+
+  const fields = [];
+
+  for (const [fieldName, spec] of Object.entries(doc.fields || {})) {
+    if (spec === null || typeof spec !== "object") {
+      throw new Error(`${filePath}: field "${fieldName}" must be a mapping with at least a "register" key`);
+    }
+    const register = parseInt(spec.register, 10);
+    if (isNaN(register)) throw new Error(`${filePath}: field "${fieldName}" is missing a numeric "register" address`);
+
+    const dataType = String(spec.type || "uint16").toLowerCase();
+    const count = Number.isInteger(spec.count) ? spec.count : registersForType(dataType);
+    const scale = spec.scale !== undefined ? Number(spec.scale) : 1;
+    const offset = spec.offset !== undefined ? Number(spec.offset) : 0;
+    const unit = spec.unit !== undefined ? String(spec.unit) : "";
+    const signalkPath = spec.path !== undefined ? String(spec.path) : "";
+
+    fields.push({ fieldName, register, count, dataType, scale, offset, unit, signalkPath });
+  }
+
+  for (const [fieldName, spec] of Object.entries(doc.constants || {})) {
+    const isExpanded = spec !== null && typeof spec === "object" && "value" in spec;
+    const value = isExpanded ? spec.value : spec;
+    const unit = isExpanded && spec.unit !== undefined ? String(spec.unit) : "";
+    const signalkPath = isExpanded && spec.path !== undefined ? String(spec.path) : "";
+    const constantValue = typeof value === "number" ? value : String(value);
+
+    fields.push({ fieldName, register: null, count: 0, dataType: "const", scale: 1, offset: 0, unit, signalkPath, constantValue });
+  }
+
+  if (fields.length === 0) throw new Error(`No fields or constants found in ${filePath}`);
+  return fields;
+}
+
+function registersForType(dataType) {
+  switch (dataType) {
+    case "int32":
+    case "uint32":
+    case "float32":
+      return 2;
+    case "int64":
+    case "uint64":
+      return 4;
+    default:
+      return 1; // uint16, int16, bool, enum
+  }
+}
+
+// Decode a raw register value (or pair of registers for 32-bit types) into a number.
+// rawRegs: Map<addr, uint16>, startAddr: the register address for this field
+function decodeValue(field, rawRegs) {
+  const { register, count, dataType, scale, offset } = field;
+
+  if (dataType === "const") return field.constantValue;
+
+  let raw;
+  if (count === 1) {
+    raw = rawRegs.get(register);
+    if (raw === undefined) return null;
+  } else if (count === 2) {
+    const hi = rawRegs.get(register);
+    const lo = rawRegs.get(register + 1);
+    if (hi === undefined || lo === undefined) return null;
+    raw = (hi << 16) | lo;
+  } else {
+    return null;
+  }
+
+  let value;
+  switch (dataType) {
+    case "int16":
+      value = raw > 0x7fff ? raw - 0x10000 : raw;
+      break;
+    case "int32": {
+      const signed = raw > 0x7fffffff ? raw - 0x100000000 : raw;
+      value = signed;
+      break;
+    }
+    case "float32": {
+      const tmpBuf = Buffer.alloc(4);
+      tmpBuf.writeUInt32BE(raw, 0);
+      value = tmpBuf.readFloatBE(0);
+      break;
+    }
+    case "bool":
+      return raw !== 0 ? 1 : 0;
+    default:
+      value = raw;
+  }
+
+  return value * scale + offset;
+}
+
+module.exports = { loadRegisters, decodeValue };

package/lib/scanner.js

@@ -2,7 +2,7 @@
 
 const EventEmitter = require("events");
 
-const BLUETTI_NAME_PREFIXES = ["BT-TH-", "BLUETTI", "AC", "EP", "EB", "EL"];
+const BLUETTI_NAME_PREFIXES = ["BT-TH-", "BLUETTI", "AC", "EP", "EB", "EL", "PR", "AP"];
 
 // Retry/backoff for BLE adapter init — covers the case where SignalK (and this
 // plugin) starts before bluetoothd/D-Bus is up, e.g. on boot when service

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@rhizomatics/signalk-bluetti-plugin",
-  "version": "1.4.1",
-  "description": "SignalK plugin for Bluetti power station monitoring via Bluetooth LE. Beta, use with caution.",
+  "version": "1.5.1",
+  "description": "SignalK plugin for Bluetti power station monitoring via Bluetooth LE. Comes with configuration for 20+ models.",
   "keywords": [
     "battery",
     "ble",
     "bluetooth",
     "bluetti",
     "electrical",
+    "generator",
     "marine",
+    "signalk",
+    "signalk-category-hardware",
     "signalk-node-plugin",
-    "signalk-node-server-plugin"
+    "signalk-node-server-plugin",
+    "solar"
   ],
   "homepage": "https://github.com/rhizomatics/signalk-bluetti-plugin.git",
   "bugs": {
@@ -29,7 +33,9 @@
     "index.js",
     "cli.js",
     "lib/",
-    "registers/",
+    "docs/assets/",
+    "docs/examples/",
+    "devices/",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -45,11 +51,11 @@
   },
   "dependencies": {
     "@naugehyde/node-ble": "^1.13.5",
-    "csv-parse": "^5.5.6"
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "oxfmt": "^0.61.0",
-    "oxlint": "^1.76.0",
+    "oxlint": "^1.75.0",
     "oxlint-tsgolint": "^7.0.2001"
   },
   "engines": {
@@ -58,6 +64,7 @@
   },
   "signalk": {
     "displayName": "Bluetti Monitoring",
+    "appIcon": "docs/assets/icon.svg",
     "recommends": [
       "@rhizomatics/signalk-einklabel-plugin"
     ],

package/lib/csv-loader.js

@@ -1,160 +0,0 @@
-"use strict";
-
-const fs = require("fs");
-const { parse } = require("csv-parse/sync");
-
-// Column name aliases — Bluetti CSVs have been seen in English and Chinese headers.
-// Maps our internal key → list of possible header strings (case-insensitive match).
-const COL_ALIASES = {
-  field_name: ["field_name", "fieldname", "name", "字段名", "field"],
-  register_address: ["register_address", "register", "address", "addr", "reg", "no", "no.", "寄存器", "地址"],
-  data_type: ["data_type", "datatype", "type", "数据type", "数据类型"],
-  scale: ["scale", "倍率", "factor", "multiplier"],
-  offset: ["offset", "偏移"],
-  unit: ["unit", "units", "单位"],
-  signalk_path: ["signalk_path", "signalk", "sk_path", "path"],
-  register_count: ["register_count", "count", "length", "bytes", "数据长度"],
-  constant_value: ["constant_value", "constant", "const", "fixed_value", "static_value"],
-};
-
-function resolveColumn(headers, key) {
-  const aliases = COL_ALIASES[key];
-  for (const alias of aliases) {
-    const found = headers.find((h) => h.trim().toLowerCase() === alias.toLowerCase());
-    if (found) return found;
-  }
-  return null;
-}
-
-// Parse the CSV and return an array of field descriptors.
-// Each descriptor is either register-backed: { fieldName, register, count, dataType, scale, offset, unit, signalkPath }
-// or a fixed constant (register_address left blank): { fieldName, register: null, count: 0, dataType: "const", ..., constantValue }
-function loadCsv(filePath) {
-  const raw = fs.readFileSync(filePath, "utf8");
-
-  // Strip BOM if present
-  const content = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
-
-  const records = parse(content, {
-    columns: true,
-    skip_empty_lines: true,
-    trim: true,
-    comment: "#",
-    relax_column_count: true,
-  });
-
-  if (records.length === 0) throw new Error(`CSV file ${filePath} has no data rows`);
-
-  const headers = Object.keys(records[0]);
-
-  const col = {};
-  for (const key of Object.keys(COL_ALIASES)) {
-    col[key] = resolveColumn(headers, key);
-  }
-
-  if (!col.register_address) throw new Error("CSV must have a register address column");
-  if (!col.field_name) throw new Error("CSV must have a field name column");
-
-  const fields = [];
-  for (const row of records) {
-    const fieldName = (row[col.field_name] || "").trim();
-    if (!fieldName) continue;
-
-    const signalkPath = col.signalk_path ? (row[col.signalk_path] || "").trim() : "";
-    const constantRaw = col.constant_value ? (row[col.constant_value] || "").trim() : "";
-
-    const registerRaw = row[col.register_address];
-    const register = parseInt(registerRaw, 10);
-
-    if (isNaN(register)) {
-      // No register address — only valid if this row instead supplies a fixed
-      // constant (e.g. a model's nominal battery capacity or chemistry, which
-      // isn't a live register on every device). Otherwise it's a header-like
-      // row embedded in the data and gets skipped.
-      if (!constantRaw) continue;
-      // Numeric constants (e.g. a nominal capacity in Wh) need to go through
-      // the same unit conversion as register-backed fields; text constants
-      // (chemistry, manufacturer name) are left as-is.
-      const asNumber = Number(constantRaw);
-      const constantValue = Number.isNaN(asNumber) ? constantRaw : asNumber;
-      const unit = col.unit ? (row[col.unit] || "").trim() : "";
-      fields.push({ fieldName, register: null, count: 0, dataType: "const", scale: 1, offset: 0, unit, signalkPath, constantValue });
-      continue;
-    }
-
-    const dataType = col.data_type ? (row[col.data_type] || "uint16").toLowerCase().trim() : "uint16";
-    const scale = col.scale ? parseFloat(row[col.scale]) || 1 : 1;
-    const offset = col.offset ? parseFloat(row[col.offset]) || 0 : 0;
-    const unit = col.unit ? (row[col.unit] || "").trim() : "";
-
-    // register_count: for multi-register types (int32, uint32, float32 = 2 regs; int64 = 4 regs)
-    let count = col.register_count ? parseInt(row[col.register_count], 10) : NaN;
-    if (isNaN(count)) count = registersForType(dataType);
-
-    fields.push({ fieldName, register, count, dataType, scale, offset, unit, signalkPath });
-  }
-
-  if (fields.length === 0) throw new Error(`No valid register rows found in ${filePath}`);
-  return fields;
-}
-
-function registersForType(dataType) {
-  switch (dataType) {
-    case "int32":
-    case "uint32":
-    case "float32":
-      return 2;
-    case "int64":
-    case "uint64":
-      return 4;
-    default:
-      return 1; // uint16, int16, bool, enum
-  }
-}
-
-// Decode a raw register value (or pair of registers for 32-bit types) into a number.
-// rawRegs: Map<addr, uint16>, startAddr: the register address for this field
-function decodeValue(field, rawRegs) {
-  const { register, count, dataType, scale, offset } = field;
-
-  if (dataType === "const") return field.constantValue;
-
-  let raw;
-  if (count === 1) {
-    raw = rawRegs.get(register);
-    if (raw === undefined) return null;
-  } else if (count === 2) {
-    const hi = rawRegs.get(register);
-    const lo = rawRegs.get(register + 1);
-    if (hi === undefined || lo === undefined) return null;
-    raw = (hi << 16) | lo;
-  } else {
-    return null;
-  }
-
-  let value;
-  switch (dataType) {
-    case "int16":
-      value = raw > 0x7fff ? raw - 0x10000 : raw;
-      break;
-    case "int32": {
-      const signed = raw > 0x7fffffff ? raw - 0x100000000 : raw;
-      value = signed;
-      break;
-    }
-    case "float32": {
-      const tmpBuf = Buffer.alloc(4);
-      tmpBuf.writeUInt32BE(raw, 0);
-      value = tmpBuf.readFloatBE(0);
-      break;
-    }
-    case "bool":
-      return raw !== 0 ? 1 : 0;
-    default:
-      value = raw;
-  }
-
-  return value * scale + offset;
-}
-
-module.exports = { loadCsv, decodeValue };