dbus-victron-virtual 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbus-victron-virtual",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Add interoperability with victron dbus to a given dbus interface",
   "main": "src/index.js",
   "type": "commonjs",

package/src/__tests__/addSettingsTest.js

@@ -0,0 +1,30 @@
+const { addSettings } = require("..");
+
+describe("victron-dbus-virtual, addSettings tests, without calling addVictronInterfaces", () => {
+  it("works for the happy case", async () => {
+    const bus = {
+      invoke: function (args, cb) {
+        process.nextTick(() => cb(null, args));
+      },
+    };
+    const settingsResult = await addSettings(bus, [
+      {
+        path: "/Settings/MySettings/Setting",
+        default: 3,
+        min: 0,
+        max: 10,
+      },
+    ]);
+    expect(settingsResult.member).toBe("AddSettings");
+    expect(settingsResult.path).toBe("/");
+    expect(settingsResult.interface).toBe("com.victronenergy.Settings");
+    expect(settingsResult.body).toStrictEqual([
+      [
+        [
+          ["path", ["s", "/Settings/MySettings/Setting"]],
+          ["default", ["i", 3]],
+        ],
+      ],
+    ]);
+  });
+});

package/src/index.js

@@ -6,9 +6,182 @@ const products = {
   temperature: 0xc060,
   meteo: 0xc061,
   grid: 0xc062,
-  tank: 0xc063
+  tank: 0xc063,
+  heatpump: 0xc064,
+  battery: 0xc065,
+  pvinverter: 0xc066,
 };
 
+function getType(value) {
+  return value === null
+    ? "d"
+    : typeof value === "undefined"
+      ? (() => {
+        throw new Error("Value cannot be undefined");
+      })()
+      : typeof value === "string"
+        ? "s"
+        : typeof value === "number"
+          ? isNaN(value)
+            ? (() => {
+              throw new Error("NaN is not a valid input");
+            })()
+            : Number.isInteger(value)
+              ? "i"
+              : "d"
+          : (() => {
+            throw new Error("Unsupported type: " + typeof value);
+          })();
+}
+
+function wrapValue(t, v) {
+  if (v === null) {
+    return ["ai", []];
+  }
+  switch (t) {
+    case "b":
+      return ["b", v];
+    case "s":
+      return ["s", v];
+    case "i":
+      return ["i", v];
+    case "d":
+      return ["d", v];
+    default:
+      return t.type ? wrapValue(t.type, v) : v;
+  }
+}
+
+function unwrapValue([t, v]) {
+  switch (t[0].type) {
+    case "b":
+      return !!v[0];
+    case "s":
+      return v[0];
+    case "i":
+      return Number(v[0]);
+    case "d":
+      return Number(v[0]);
+    case "ai":
+      if (v[0].length === 0) {
+        return null;
+      }
+      throw new Error(
+        'Unsupported value type "ai", only supported as empty array',
+      );
+    default:
+      throw new Error(`Unsupported value type: ${JSON.stringify(t)}`);
+  }
+}
+
+async function addSettings(bus, settings) {
+  const body = [
+    settings.map((setting) => [
+      ["path", wrapValue("s", setting.path)],
+      [
+        "default",
+        wrapValue(
+          typeof setting.type !== "undefined"
+            ? setting.type
+            : getType(setting.default),
+          setting.default,
+        ),
+      ],
+      // TODO: incomplete, min and max missing
+    ]),
+  ];
+  return await new Promise((resolve, reject) => {
+    bus.invoke(
+      {
+        interface: "com.victronenergy.Settings",
+        path: "/",
+        member: "AddSettings",
+        destination: "com.victronenergy.settings",
+        type: undefined,
+        signature: "aa{sv}",
+        body: body,
+      },
+      function (err, result) {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(result);
+      },
+    );
+  });
+}
+
+async function removeSettings(bus, settings) {
+  const body = [settings.map((setting) => setting.path)];
+
+  return new Promise((resolve, reject) => {
+    bus.invoke(
+      {
+        interface: "com.victronenergy.Settings",
+        path: "/",
+        member: "RemoveSettings",
+        destination: "com.victronenergy.settings",
+        type: undefined,
+        signature: "as",
+        body: body,
+      },
+      function (err, result) {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(result);
+      },
+    );
+  });
+}
+
+async function setValue(bus, { path, interface_, destination, value, type }) {
+  return await new Promise((resolve, reject) => {
+    if (path === "/DeviceInstance") {
+      console.warn(
+        "setValue called for path /DeviceInstance, this will be ignored by Victron services.",
+      );
+    }
+    bus.invoke(
+      {
+        interface: interface_,
+        path: path || "/",
+        member: "SetValue",
+        destination,
+        signature: "v",
+        body: [
+          wrapValue(typeof type !== "undefined" ? type : getType(value), value),
+        ],
+      },
+      function (err, result) {
+        if (err) {
+          return reject(err);
+        }
+        resolve(result);
+      },
+    );
+  });
+}
+
+async function getValue(bus, { path, interface_, destination }) {
+  return await new Promise((resolve, reject) => {
+    bus.invoke(
+      {
+        interface: interface_,
+        path: path || "/",
+        member: "GetValue",
+        destination,
+      },
+      function (err, result) {
+        if (err) {
+          return reject(err);
+        }
+        resolve(result);
+      },
+    );
+  });
+}
+
 function addVictronInterfaces(
   bus,
   declaration,
@@ -34,11 +207,15 @@ function addVictronInterfaces(
     debug("addDefaults, declaration.name:", declaration.name);
     const productInName = declaration.name.split(".")[2];
     if (!productInName) {
-      throw new Error(`Unable to extract product from name, ensure name is of the form 'com.victronenergy.product.my_name', declaration.name=${declaration.name}`);
+      throw new Error(
+        `Unable to extract product from name, ensure name is of the form 'com.victronenergy.product.my_name', declaration.name=${declaration.name}`,
+      );
     }
     const product = products[productInName];
     if (!product) {
-      throw new Error(`Invalid product, ensure product name is in ${products.join(", ")}`);
+      throw new Error(
+        `Invalid product, ensure product name is in ${products.join(", ")}`,
+      );
     }
     declaration["properties"]["Mgmt/Connection"] = "s";
     definition["Mgmt/Connection"] = "Virtual";
@@ -49,8 +226,7 @@ function addVictronInterfaces(
 
     declaration["properties"]["ProductId"] = {
       type: "i",
-      format: (/* v */) =>
-        product.toString(16),
+      format: (/* v */) => product.toString(16),
     };
     definition["ProductId"] = products[declaration["name"].split(".")[2]];
     declaration["properties"]["ProductName"] = "s";
@@ -61,66 +237,26 @@ function addVictronInterfaces(
     addDefaults();
   }
 
-  function wrapValue(t, v) {
-    if (v === null) {
-      return ["ai", []];
-    }
-    switch (t) {
-      case "b":
-        return ["b", v];
-      case "s":
-        return ["s", v];
-      case "i":
-        return ["i", v];
-      case "d":
-        return ["d", v];
-      default:
-        return t.type ? wrapValue(t.type, v) : v;
-    }
-  }
-
-  function unwrapValue([t, v]) {
-    switch (t[0].type) {
-      case "b":
-        return !!v[0];
-      case "s":
-        return v[0];
-      case "i":
-        return Number(v[0]);
-      case "d":
-        return Number(v[0]);
-      case "ai":
-        if (v[0].length === 0) {
-          return null;
-        }
-        throw new Error(
-          'Unsupported value type "ai", only supported as empty array',
-        );
-      default:
-        throw new Error(`Unsupported value type: ${JSON.stringify(t)}`);
-    }
-  }
-
   const getFormatFunction = (v) => {
-    if (v.format && typeof v.format === 'function') {
+    if (v.format && typeof v.format === "function") {
       // Wrap the custom format function to ensure it always returns a string
       return (value) => {
         const formatted = v.format(value);
-        return formatted != null ? String(formatted) : '';
+        return formatted != null ? String(formatted) : "";
       };
     } else {
       return (value) => {
-        if (value == null) return '';
+        if (value == null) return "";
 
         let stringValue = String(value);
 
         // Handle potential type mismatches
         switch (v.type) {
-          case 'd': // double/float
-            return isNaN(parseFloat(stringValue)) ? '' : stringValue;
-          case 'i': // integer
-            return isNaN(parseInt(stringValue, 10)) ? '' : stringValue;
-          case 's': // string
+          case "d": // double/float
+            return isNaN(parseFloat(stringValue)) ? "" : stringValue;
+          case "i": // integer
+            return isNaN(parseInt(stringValue, 10)) ? "" : stringValue;
+          case "s": // string
             return stringValue;
           default:
             return stringValue;
@@ -145,17 +281,6 @@ function addVictronInterfaces(
     });
   }
 
-  function getType(value) {
-    return value === null ? 'd'
-        : typeof value === 'undefined' ? (() => { throw new Error('Value cannot be undefined'); })()
-        : typeof value === 'string' ? 's'
-        : typeof value === 'number'
-            ? (isNaN(value)
-                ? (() => { throw new Error('NaN is not a valid input'); })()
-                : Number.isInteger(value) ? 'i' : 'd')
-        : (() => { throw new Error('Unsupported type: ' + typeof value); })();
-  }
-
   const iface = {
     GetItems: function () {
       return getProperties(true);
@@ -166,7 +291,7 @@ function addVictronInterfaces(
         return [k.replace(/^(?!\/)/, "/"), wrapValue(v, definition[k])];
       });
     },
-    emit: function () {},
+    emit: function () { },
   };
 
   const ifaceDesc = {
@@ -224,107 +349,22 @@ function addVictronInterfaces(
     );
   }
 
-  async function addSettings(settings) {
-    const body = [
-      settings.map((setting) => [
-        ["path", wrapValue("s", setting.path)],
-        ["default", wrapValue(typeof setting.type !== 'undefined' ? setting.type: getType(setting.default), setting.default)],
-        // TODO: incomplete, min and max missing
-      ]),
-    ];
-    return await new Promise((resolve, reject) => {
-      bus.invoke(
-        {
-          interface: "com.victronenergy.Settings",
-          path: "/",
-          member: "AddSettings",
-          destination: "com.victronenergy.settings",
-          type: undefined,
-          signature: "aa{sv}",
-          body: body,
-        },
-        function (err, result) {
-          if (err) {
-            return reject(err);
-          }
-          return resolve(result);
-        },
-      );
-    });
-  }
-
-  async function removeSettings(settings) {
-    const body = [settings.map((setting) => setting.path)];
-
-    return new Promise((resolve, reject) => {
-      bus.invoke(
-        {
-          interface: "com.victronenergy.Settings",
-          path: "/",
-          member: "RemoveSettings",
-          destination: "com.victronenergy.settings",
-          type: undefined,
-          signature: "as",
-          body: body,
-        },
-        function (err, result) {
-          if (err) {
-            return reject(err);
-          }
-          return resolve(result);
-        },
-      );
-    });
-  }
-
-  async function setValue({ path, interface_, destination, value, type }) {
-    return await new Promise((resolve, reject) => {
-      bus.invoke(
-        {
-          interface: interface_,
-          path: path || "/",
-          member: "SetValue",
-          destination,
-          signature: "v",
-          body: [wrapValue(typeof type !== 'undefined' ? type: getType(value), value)],
-        },
-        function (err, result) {
-          if (err) {
-            return reject(err);
-          }
-          resolve(result);
-        },
-      );
-    });
-  }
-
-  async function getValue({ path, interface_, destination }) {
-    return await new Promise((resolve, reject) => {
-      bus.invoke(
-        {
-          interface: interface_,
-          path: path || "/",
-          member: "GetValue",
-          destination,
-        },
-        function (err, result) {
-          if (err) {
-            return reject(err);
-          }
-          resolve(result);
-        },
-      );
-    });
-  }
-
   return {
     emitItemsChanged: () => iface.emit("ItemsChanged", getProperties()),
-    addSettings,
-    removeSettings,
-    setValue,
-    getValue,
+    addSettings: (settings) => addSettings(bus, settings),
+    removeSettings: (settings) => removeSettings(bus, settings),
+    setValue: ({ path, interface_, destination, value, type }) =>
+      setValue(bus, { path, interface_, destination, value, type }),
+    getValue: ({ path, interface_, destination }) =>
+      getValue(bus, { path, interface_, destination }),
     warnings,
   };
 }
 
-module.exports = { addVictronInterfaces };
+module.exports = {
+  addVictronInterfaces,
+  addSettings,
+  removeSettings,
+  getValue,
+  setValue,
+};