@signalk/vedirect-serial-usb 1.4.0 → 1.6.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 Joachim Bakke, Fabian Tollenaar and Karl-Erik Gustafsson
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,7 +1,9 @@
-[![Build Status](https://travis-ci.org/SignalK/vedirect-serial-usb.svg?branch=master)](https://travis-ci.org/SignalK/vedirect-serial-usb) [![Greenkeeper badge](https://badges.greenkeeper.io/SignalK/vedirect-serial-usb.svg)](https://greenkeeper.io/)
-
 # vedirect-serial-usb
 
+[![CI](https://github.com/SignalK/vedirect-serial-usb/actions/workflows/ci.yml/badge.svg)](https://github.com/SignalK/vedirect-serial-usb/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@signalk/vedirect-serial-usb.svg)](https://www.npmjs.com/package/@signalk/vedirect-serial-usb)
+[![License](https://img.shields.io/npm/l/@signalk/vedirect-serial-usb.svg)](https://github.com/SignalK/vedirect-serial-usb/blob/master/LICENSE)
+
 This code is a [Signal K Node Server](https://github.com/SignalK/signalk-server-node) plugin. It reads and parses Victron VE.Direct data.
 
 The common way to connect to a Victron product is with the Victron [VE.Direct to USB interface](https://www.victronenergy.com/accessories/ve-direct-to-usb-interface) cable.
@@ -27,15 +29,15 @@ https://pysselilivet.blogspot.com/2021/02/victron-vedirect-with-raspberry.html.
 Lastly, note that when having a Victron GX Device, you won't be needing this
 plugin. Details for that [here](https://github.com/sbender9/signalk-venus-plugin).
 
-### Installation
+## Installation
 
 Use the Signal K app store or install via NPM in the Signal K server root directory: `npm install @signalk/vedirect-serial-usb`
 
-### Usage
+## Usage
 
-Set up the appropiate device on the settings page of this plugin in the Signal K server admin UI, for instance to `/dev/ttyUSB0` and enable the plugin. Your VE.Direct data will be available in Signal K format via various clients and apps.
+Set up the appropriate device on the settings page of this plugin in the Signal K server admin UI, for instance to `/dev/ttyUSB0` and enable the plugin. Your VE.Direct data will be available in Signal K format via various clients and apps.
 
-### Connections
+## Connections
 
 **Select device**
 
@@ -60,7 +62,7 @@ Set up the appropiate device on the settings page of this plugin in the Signal K
 
 - Give each device unique SK paths
 
-### Usage as a library
+## Usage as a library
 
 It's possible to use this plugin as a library, in other Node.js code. This feature simply wraps the plugin in an easy-to-consume manner, so functionality is identical. Example:
 
@@ -71,7 +73,7 @@ const consumer = new VEDirect({
   ignoreChecksum: true,
   mainBatt: 'House',
   auxBatt: 'Starter',
-  solar: 'Main',
+  solar: 'Main'
 })
 
 consumer.on('delta', (delta) => console.log('[onDelta]', delta))
@@ -79,21 +81,8 @@ consumer.stop() // stop the plugin, destruct the connections
 consumer.start() // (re-)start the plugin
 ```
 
-### License
-
-```
-Copyright 2018 Joachim Bakke <github@heiamoss.com>, Fabian Tollenaar <fabian@decipher.industries> and
-Karl-Erik Gustafsson <ke.gustafsson@gmail.com>
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
+## License
 
-    http://www.apache.org/licenses/LICENSE-2.0
+Apache-2.0. See [LICENSE](LICENSE).
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-```
+Copyright 2018 Joachim Bakke, Fabian Tollenaar and Karl-Erik Gustafsson.

package/dist/Parser.d.ts

@@ -0,0 +1,50 @@
+import type { Debugger } from 'debug';
+import { EventEmitter } from 'events';
+import type { FieldContext, FieldMap, PluginOptions, StoredField } from './types';
+/** Parser configuration after merging caller options with defaults. */
+interface ParserOptions extends PluginOptions {
+    productIds: Record<string, string>;
+    fields: FieldMap;
+    defaultUnitId: string;
+    mainBatt: string;
+    auxBatt: string;
+    bmv: string;
+    solar: string;
+}
+export declare class VEDirectParser extends EventEmitter implements FieldContext {
+    options: ParserOptions;
+    fields: FieldMap;
+    debug: Debugger;
+    line: string[];
+    data: Record<string, StoredField>;
+    cache: string;
+    sum: number;
+    constructor(opts?: PluginOptions);
+    addChunk(buf: Buffer, connectionIndex: number): void;
+    parse(line: string): void;
+    set(key: string, value: StoredField): void;
+    get(key: string): StoredField | undefined;
+    unset(key: string): void;
+    getData(): Record<string, StoredField>;
+    private _verifyCacheAndParse;
+    private _parse;
+    getAlarmReason(alarmReason: string | number): string | undefined;
+    getErrorString(err: string | number): string | undefined;
+    getMode(mode: string | number): string | undefined;
+    getStateOfOperation(cs: string | number): string | undefined;
+    getTrackerOperationMode(mppt: string | number): string | undefined;
+    getProductLongname(pid: string): string;
+    generateDelta(connectionIndex: number): void;
+    getPath(name: string, connectionIndex: number): string | null;
+    /**
+     * Resolves a field's unit id to the configured device name. The four
+     * configurable units come from the connection; aux2Batt/inverter have no
+     * config slot and use defaultUnitId. The switch is exhaustive over UnitId,
+     * so adding a unit without handling it here is a compile error.
+     */
+    private resolveUnitId;
+    warn(message: string): void;
+    error(err: Error): void;
+}
+export default VEDirectParser;
+//# sourceMappingURL=Parser.d.ts.map

package/dist/Parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parser.d.ts","sourceRoot":"","sources":["../src/Parser.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAGrC,OAAO,KAAK,EACV,YAAY,EACZ,QAAQ,EACR,aAAa,EAEb,WAAW,EAGZ,MAAM,SAAS,CAAA;AAGhB,uEAAuE;AACvE,UAAU,aAAc,SAAQ,aAAa;IAC3C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,MAAM,EAAE,QAAQ,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd;AAiBD,qBAAa,cAAe,SAAQ,YAAa,YAAW,YAAY;IACtE,OAAO,EAAE,aAAa,CAAA;IACtB,MAAM,EAAE,QAAQ,CAAA;IAChB,KAAK,EAAE,QAAQ,CAAA;IACf,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;gBAEC,IAAI,CAAC,EAAE,aAAa;IAWhC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI;IA6BpD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI;IAM1C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIzC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAYxB,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAItC,OAAO,CAAC,oBAAoB;IA0B5B,OAAO,CAAC,MAAM;IAoCd,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IA2ChE,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IAgDxD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IAgBlD,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IA4B5D,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IAgBlE,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAUvC,aAAa,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI;IAyC5C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAyB7D;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAmBrB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK3B,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI;CAIxB;AAED,eAAe,cAAc,CAAA"}

package/dist/Parser.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VEDirectParser = void 0;
+/**
+ * VE.Direct text-protocol parser.
+ *
+ * Accumulates raw bytes into blocks (terminated by the `Checksum` field),
+ * verifies the block checksum (a running byte sum that must be 0 mod 256),
+ * decodes each `label<TAB>value` line via the field table, and emits a Signal
+ * K delta per valid block.
+ *
+ * Block layout on the wire (one field per line, `\r\n`-separated):
+ *   "\r\nPID\t0xA053\r\nV\t12340\r\n...\r\nChecksum\t<byte>"
+ */
+const debug_1 = __importDefault(require("debug"));
+const events_1 = require("events");
+const fields_1 = __importDefault(require("./fields"));
+const productIds_1 = require("./productIds");
+const constants_1 = require("./constants");
+const defaults = {
+    productIds: productIds_1.productIds,
+    fields: fields_1.default,
+    defaultUnitId: 'victronDevice',
+    mainBatt: 'house',
+    auxBatt: 'starter',
+    bmv: 'bmv',
+    solar: 'solar'
+};
+// A VE.Direct block is well under 1 KB. If far more than that accumulates
+// without a Checksum line, the stream is malformed or the sentinel was lost;
+// the cache is dropped rather than left to grow unbounded from device input.
+const MAX_CACHE_LENGTH = 8192;
+class VEDirectParser extends events_1.EventEmitter {
+    options;
+    fields;
+    debug;
+    line;
+    data;
+    cache;
+    sum;
+    constructor(opts) {
+        super();
+        this.options = Object.assign({}, defaults, opts || {});
+        this.fields = this.options.fields;
+        this.debug = (0, debug_1.default)('signalk-vedirect-parser');
+        this.line = [];
+        this.data = {};
+        this.cache = '';
+        this.sum = 0;
+    }
+    addChunk(buf, connectionIndex) {
+        if (!Buffer.isBuffer(buf)) {
+            this.warn('addChunk: incoming data is not a buffer: ' + typeof buf);
+            return;
+        }
+        const chunk = buf.toString('ascii');
+        buf.forEach((b) => {
+            this.sum += b;
+        });
+        this.cache += chunk;
+        if (chunk.toLowerCase().includes('checksum')) {
+            // Last line of block. Verify checksum of block in cache and parse
+            // line-by-line if checksum is correct.
+            this._verifyCacheAndParse(connectionIndex);
+            return;
+        }
+        if (this.cache.length > MAX_CACHE_LENGTH) {
+            this.warn(`block exceeded ${MAX_CACHE_LENGTH} bytes without a Checksum line; discarding`);
+            this.cache = '';
+            this.sum = 0;
+        }
+    }
+    parse(line) {
+        if (typeof line !== 'string') {
+            return;
+        }
+        this.line = line.trim().split('\t');
+        this._parse();
+    }
+    set(key, value) {
+        this.data[key] = value;
+        this.emit('change', Object.assign({}, this.data));
+        this.emit('set', { key, value });
+    }
+    get(key) {
+        return this.data[key];
+    }
+    unset(key) {
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            return;
+        }
+        this.debug(`Unsetting ${key}`);
+        this.emit('change', Object.assign({}, this.data));
+        this.emit('unset', key);
+        delete this.data[key];
+    }
+    getData() {
+        return Object.assign({}, this.data);
+    }
+    _verifyCacheAndParse(connectionIndex) {
+        const conn = this.options.vedirect?.[connectionIndex];
+        // Verify checksum unless ignoreChecksum is explicitly true.
+        if (conn?.ignoreChecksum !== true && this.sum % 256 !== 0) {
+            this.warn(`block checksum doesn't equal 0: ${this.sum % 256}`);
+            this.cache = '';
+            this.sum = 0;
+            return;
+        }
+        this.cache
+            .trim()
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line !== '')
+            .forEach((line) => {
+            this.line = line.split('\t');
+            this._parse();
+        });
+        this.cache = '';
+        this.sum = 0;
+        this.generateDelta(connectionIndex);
+    }
+    _parse() {
+        if (!Array.isArray(this.line) || this.line.length !== 2) {
+            this.warn('_parse() called on invalid line: ' +
+                JSON.stringify({ line: this.line }));
+            return;
+        }
+        const rawKey = this.line[0];
+        const rawData = this.line[1];
+        if (rawKey === undefined || rawData === undefined) {
+            this.warn('Data is NULL, ignoring');
+            return;
+        }
+        const fieldKey = String(rawKey).toUpperCase();
+        const field = this.fields[fieldKey];
+        if (!field || typeof field !== 'object') {
+            this.warn(`No field definition for: ${fieldKey}, ignoring`);
+            return;
+        }
+        const converted = typeof field.value === 'function' ? field.value(rawData, this) : rawData;
+        // undefined skips the field, leaving any prior value untouched; null is
+        // stored as an explicit null so it clears the value downstream in the
+        // delta (see FieldValue). Only undefined means "no update".
+        if (converted !== undefined) {
+            this.set(field.name, { ...field, value: converted });
+        }
+    }
+    getAlarmReason(alarmReason) {
+        switch (parseInt(String(alarmReason), 10)) {
+            case 1:
+                return 'Low voltage';
+            case 2:
+                return 'High voltage';
+            case 4:
+                return 'Low state-of-charge';
+            case 8:
+                return 'Low starter voltage';
+            case 16:
+                return 'High starter voltage';
+            case 32:
+                return 'Low temperature';
+            case 64:
+                return 'High temperature';
+            case 128:
+                return 'Mid voltage';
+            case 256:
+                return 'Overload';
+            case 512:
+                return 'DC ripple';
+            case 1024:
+                return 'Low V AC out';
+            case 2048:
+                return 'High V AC out';
+            default:
+                return undefined;
+        }
+    }
+    getErrorString(err) {
+        switch (parseInt(String(err), 10)) {
+            case 2:
+                return 'Battery voltage too high';
+            case 17:
+                return 'Charger temperature too high';
+            case 18:
+                return 'Charger overcurrent';
+            // Can be ignored according to victron protocol
+            // case 19:
+            //   return 'Charger current reversed'
+            case 20:
+                return 'Bulk time limit exceeded';
+            // Can be ignored according to victron protocol
+            // case 21:
+            //   return 'Current sensor issue (sensor bias/sensor broken)'
+            case 26:
+                return 'Terminals overheated';
+            case 33:
+                return 'Input voltage too high (solar panel)';
+            case 34:
+                return 'Input current too high (solar panel)';
+            case 38:
+                return 'Input shutdown (due to excessive battery voltage)';
+            case 116:
+                return 'Factory calibration data lost';
+            case 117:
+                return 'Invalid/incompatible firmware';
+            case 119:
+                return 'User settings invalid';
+            default:
+                return undefined;
+        }
+    }
+    getMode(mode) {
+        switch (parseInt(String(mode), 10)) {
+            case 2:
+                return 'on';
+            case 4:
+                return 'off';
+            case 5:
+                return 'eco';
+            default:
+                return undefined;
+        }
+    }
+    getStateOfOperation(cs) {
+        switch (parseInt(String(cs), 10)) {
+            case 0:
+                return 'off';
+            case 1:
+                return 'low power';
+            case 2:
+                return 'fault';
+            case 3:
+                return 'bulk';
+            case 4:
+                return 'absorption';
+            case 5:
+                return 'float';
+            case 9:
+                return 'inverting';
+            default:
+                return undefined;
+        }
+    }
+    getTrackerOperationMode(mppt) {
+        switch (parseInt(String(mppt), 10)) {
+            case 0:
+                return 'off';
+            case 1:
+                return 'voltage or current limited';
+            case 2:
+                return 'mpp tracker active';
+            default:
+                return undefined;
+        }
+    }
+    getProductLongname(pid) {
+        let key = String(pid);
+        if (!key.includes('0x')) {
+            key = `0x${key}`;
+        }
+        return this.options.productIds[key] ?? 'Unknown';
+    }
+    generateDelta(connectionIndex) {
+        const values = Object.keys(this.data)
+            .map((name) => {
+            const path = this.getPath(name, connectionIndex);
+            const entry = this.data[name];
+            if (path === null || entry === undefined) {
+                return null;
+            }
+            return { path, value: entry.value };
+        })
+            .filter((update) => update !== null);
+        if (values.length === 0) {
+            this.warn('No mutations in this delta');
+            return;
+        }
+        const delta = {
+            context: 'vessels.self',
+            updates: [
+                {
+                    // Set the Signal K source ref as a bare string rather than a
+                    // structured `source` object. signalk-server reads any `source.src`
+                    // as an NMEA 2000 device address, so a VE.Direct delta carrying one
+                    // would corrupt the server's `sources` tree with bogus
+                    // `sources.*.n2k.pgns` nodes. A plain `$source` sidesteps that while
+                    // keeping each connection individually addressable:
+                    // `vedirect-signalk.0`, `vedirect-signalk.1`, ...
+                    $source: `${constants_1.PLUGIN_ID}.${connectionIndex}`,
+                    timestamp: new Date().toISOString(),
+                    values
+                }
+            ]
+        };
+        this.emit('delta', delta);
+    }
+    getPath(name, connectionIndex) {
+        const field = Object.values(this.fields).find((f) => f.name === name && f.path !== undefined);
+        if (!field?.path) {
+            return null;
+        }
+        const conn = this.options.vedirect?.[connectionIndex];
+        // On a solar charger, VE.Direct's V/I labels describe the charger's DC
+        // output rather than a battery, so those fields are reported under
+        // electrical.solar (via the field's solarCharger override) to avoid
+        // clashing with a battery monitor on the same bank.
+        const override = conn?.deviceType === 'Solar charger' ? field.solarCharger : undefined;
+        const path = override?.path ?? field.path;
+        const unitId = override?.unitId ?? field.unitId;
+        if (unitId === undefined) {
+            return path;
+        }
+        return path.replace('*', this.resolveUnitId(unitId, conn));
+    }
+    /**
+     * Resolves a field's unit id to the configured device name. The four
+     * configurable units come from the connection; aux2Batt/inverter have no
+     * config slot and use defaultUnitId. The switch is exhaustive over UnitId,
+     * so adding a unit without handling it here is a compile error.
+     */
+    resolveUnitId(unitId, conn) {
+        switch (unitId) {
+            case 'mainBatt':
+                return conn?.mainBatt || this.options.defaultUnitId;
+            case 'auxBatt':
+                return conn?.auxBatt || this.options.defaultUnitId;
+            case 'bmv':
+                return conn?.bmv || this.options.defaultUnitId;
+            case 'solar':
+                return conn?.solar || this.options.defaultUnitId;
+            case 'aux2Batt':
+            case 'inverter':
+                return this.options.defaultUnitId;
+        }
+    }
+    warn(message) {
+        this.debug(`Warning: ${message}`);
+        this.emit('warn', message);
+    }
+    error(err) {
+        this.debug(`Error: ${err.message}`);
+        this.emit('error', err);
+    }
+}
+exports.VEDirectParser = VEDirectParser;
+exports.default = VEDirectParser;
+//# sourceMappingURL=Parser.js.map