dbus-victron-virtual 0.1.0

package/.husky/pre-commit

@@ -0,0 +1,2 @@
+npm test
+npm run lint

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Victron Energy BV
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# About
+
+`dbus-victron-virtual` is a wrapper around
+[dbus-native](https://www.npmjs.com/package/dbus-native), which allows you to
+connect to [dbus](https://www.freedesktop.org/wiki/Software/dbus/), and
+simplify integrating with the [Victron](https://www.victronenergy.com/)
+infrastructure: To do this, `dbus-victron-virtual` provides functions to
+
+* expose your dbus interface as a Victron service, by implementing the dbus interface `com.victronenergy.BusItem`,
+* emit the Victron-specific event `ItemsChanged`, and
+* define and modify settings which are then available through Victron's settings interface.
+
+See `dbus-victron-virtual` in action [here](https://github.com/Chris927/dbus-victron-virtual-test).
+
+
+This package may be for you if
+
+* you want to define virtual devices for testing on a Victron device, like a [Victron Cerbo GX](https://www.victronenergy.com/media/pg/Cerbo_GX/en/index-en.html), e.g. to use it in [Node-RED](https://www.victronenergy.com/live/venus-os:large), or
+* you need to integrate a device via dbus that is not (yet) supported by Victron natively.
+
+
+# Usage
+
+(TODO)
+
+
+# Development
+
+
+## Prerequisites
+
+You can develop on a device that runs [Venus OS](https://github.com/victronenergy/venus). This way, the dbus environment as required by this package will be available.  Alternatively, you can develop in any environment that support node 18 or higher, but you won't be able to run integration tests.
+
+
+## Steps
+
+* clone the repository
+* `npm install`
+* `npm run test`
+* run integration tests with `DBUS_SESSION_BUS_ADDRESS=unix:socket=/var/run/dbus/system_bus_socket TEST_INTEGRATION=1 npm run test`
+
+The implementation is in `./src/index.js`, tests are in `./src/__tests__`.
+
+Test coverage stats, when run with the integration `./src/__tests__/integrationTest.js`:
+
+----------|---------|----------|---------|---------|---------------------------
+File      | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
+----------|---------|----------|---------|---------|---------------------------
+All files |   85.18 |    69.23 |     100 |    84.9 |
+ index.js |   85.18 |    69.23 |     100 |    84.9 | 28,35,39-41,94-95,130,170
+----------|---------|----------|---------|---------|---------------------------
+

package/eslint.config.mjs

@@ -0,0 +1,10 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import jest from "eslint-plugin-jest"
+
+
+export default [
+  { languageOptions: { sourceType: 'commonjs', globals: { ...globals.browser, ...globals.node, ...globals.jest } } },
+  pluginJs.configs.recommended,
+  { files: ["src/__tests__/*.js"], plugins: { jest: jest } }
+];

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "dbus-victron-virtual",
+  "version": "0.1.0",
+  "description": "Add interoperability with victron dbus to a given dbus interface",
+  "main": "src/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint 'src/**/*.js'",
+    "prepare": "husky"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Chris927/dbus-victron-virtual.git"
+  },
+  "keywords": [
+    "dbus",
+    "victron"
+  ],
+  "author": "chris@uber5.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Chris927/dbus-victron-virtual/issues"
+  },
+  "homepage": "https://github.com/Chris927/dbus-victron-virtual#readme",
+  "devDependencies": {
+    "@eslint/js": "^9.6.0",
+    "eslint": "^9.6.0",
+    "eslint-plugin-jest": "^28.6.0",
+    "globals": "^15.7.0",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "lint-staged": "^15.2.7"
+  },
+  "dependencies": {
+    "dbus-native": "^0.4.0"
+  }
+}

package/src/__tests__/dummyTest.js

@@ -0,0 +1,5 @@
+describe('victron-dbus-virtual', () => {
+  it('should pass', () => {
+    expect(true).toBe(true);
+  });
+});

package/src/__tests__/emitItemsChangedTest.js

@@ -0,0 +1,31 @@
+/* eslint-env node */
+const { addVictronInterfaces } = require('../index');
+
+describe('victron-dbus-virtual, emitItemsChanged tests', () => {
+
+  const noopBus = { exportInterface: () => { } };
+
+  it('works for the case without props', () => {
+    const declaration = { name: 'foo' };
+    const definition = {};
+    const { emitItemsChanged } = addVictronInterfaces(noopBus, declaration, definition);
+    emitItemsChanged();
+  });
+
+  it('works for the happy case', () => {
+    const declaration = { name: 'foo', properties: { StringProp: 's' } };
+    const definition = { StringProp: 'hello' };
+    const emit = jest.fn();
+    const bus = {
+      exportInterface: (iface /* , _path, _ifaceDesc */) => {
+        iface.emit = emit;
+      }
+    }
+    const { emitItemsChanged } = addVictronInterfaces(bus, declaration, definition);
+    emitItemsChanged();
+    expect(emit.mock.calls.length).toBe(1);
+    expect(emit.mock.calls[0][0]).toBe('ItemsChanged');
+    expect(emit.mock.calls[0][1]).toEqual([['StringProp', [['Value', ['s', 'hello']], ['Text', ['s', 'hello']]]]]);
+  });
+
+});

package/src/__tests__/getValueTest.js

@@ -0,0 +1,57 @@
+const { addVictronInterfaces } = require('../index');
+
+describe('victron-dbus-virtual, getValue tests', () => {
+
+  it('works for the happy case', async () => {
+    const declaration = { name: 'foo' };
+    const definition = {};
+    const bus = {
+      exportInterface: () => { },
+      invoke: function(args, cb) {
+        process.nextTick(() => cb(null, args));
+      }
+    }
+    const { getValue } = addVictronInterfaces(bus, declaration, definition);
+
+    // NOTE: calling getValue() is useful to retrieve the value of a setting.
+    // See https://github.com/Chris927/dbus-victron-virtual-test/blob/master/index.js for an example.
+
+    const result = await getValue({
+      path: '/StringProp',
+      interface_: 'foo',
+      destination: 'foo'
+    });
+    expect(result.member).toBe('GetValue');
+    expect(result.path).toBe('/StringProp');
+    expect(result.interface).toBe('foo');
+    expect(result.destination).toBe('foo');
+
+  });
+
+  it('fails if invoke fails', async () => {
+    const declaration = { name: 'foo' };
+    const definition = {};
+    const bus = {
+      exportInterface: () => { },
+      invoke: function(args, cb) {
+        process.nextTick(() => cb(new Error('oops')));
+      }
+    }
+    const { getValue } = addVictronInterfaces(bus, declaration, definition);
+
+    // NOTE: calling getValue() is useful to retrieve the value of a setting.
+    // See https://github.com/Chris927/dbus-victron-virtual-test/blob/master/index.js for an example.
+
+    try {
+      await getValue({
+        path: '/StringProp',
+        interface_: 'foo',
+        destination: 'foo'
+      });
+      expect(false, 'should have thrown');
+    } catch (err) {
+      expect(err.message).toBe('oops');
+    }
+  });
+
+});

package/src/__tests__/inputsTest.js

@@ -0,0 +1,94 @@
+/* eslint-env node */
+const { addVictronInterfaces } = require('../index');
+
+describe('victron-dbus-virtual, input parameters tests', () => {
+
+  const noopBus = { exportInterface: () => { } };
+
+  it('works for the trivial case', () => {
+    const declaration = { name: 'foo' };
+    const definition = {};
+    const result = addVictronInterfaces(noopBus, declaration, definition);
+    expect(!!result).toBe(true);
+  });
+
+  it('fails in some scenarios', () => {
+    try {
+      addVictronInterfaces(noopBus, {}, {});
+    } catch (e) {
+      expect(e.message.includes('Interface name')).toBe(true);
+    }
+    try {
+      addVictronInterfaces(noopBus, { name: '' }, {});
+    } catch (e) {
+      expect(e.message.includes('Interface name')).toBe(true);
+    }
+  });
+
+  it('works for an example with properties', () => {
+    const declaration = {
+      name: 'com.victronenergy.myservice',
+      properties: {
+        'foo': 'i',
+        'bar': 's',
+      }
+    };
+    const definition = {
+      foo: 42,
+      bar: 'hello',
+      emit: function() { }
+    };
+    const result = addVictronInterfaces(noopBus, declaration, definition);
+    expect(!!result).toBe(true);
+    expect(result.warnings.length).toBe(0);
+  });
+
+  it('provides a warning if the interface name contains problematic characters', () => {
+    const declaration = {
+      name: 'com.victronenergy.my-service-with-dashes',
+    };
+    const { warnings } = addVictronInterfaces(noopBus, declaration, {});
+    expect(warnings.length).toBe(1);
+    expect(warnings[0].includes('problematic characters')).toBe(true);
+  });
+
+  it('provides a warning if the interface name does not start with com.victronenergy', () => {
+    const declaration = {
+      name: 'com.example.my_service',
+    };
+    const { warnings } = addVictronInterfaces(noopBus, declaration, {});
+    expect(warnings.length).toBe(1);
+    expect(warnings[0].includes('start with com.victronenergy')).toBe(true);
+  });
+
+  it('exports GetItems, and SetValue for each property', () => {
+    const declaration = {
+      name: 'some_name',
+      properties: {
+        'foo': 'i',
+        'bar': 's',
+        'baz': 'b',
+      }
+    }
+    const bus = {
+      exportInterface: jest.fn()
+    };
+
+    addVictronInterfaces(bus, declaration, {});
+    expect(bus.exportInterface.mock.calls.length).toBe(4);
+
+    const call0 = bus.exportInterface.mock.calls[0];
+    expect(Object.keys(call0[0])).toStrictEqual(['GetItems', 'emit']);
+
+    const call1 = bus.exportInterface.mock.calls[1];
+    expect(Object.keys(call1[0])).toStrictEqual(['SetValue']);
+    expect(call1[1]).toStrictEqual('/foo');
+    expect(call1[2].name).toBe('com.victronenergy.BusItem');
+
+    const call3 = bus.exportInterface.mock.calls[3];
+    expect(call3[1]).toStrictEqual('/baz');
+
+  });
+
+
+});

package/src/__tests__/integrationTest.js

@@ -0,0 +1,162 @@
+const dbus = require('dbus-native');
+const { addVictronInterfaces } = require('../index');
+
+const describeIf = (condition, ...args) =>
+    condition ? describe(...args) : describe.skip(...args);
+
+
+describeIf(process.env.TEST_INTEGRATION, "run integration tests", () => {
+  test("this is a dummy integration test", async () => {
+
+    // example adopted from https://github.com/sidorares/dbus-native/blob/master/examples/basic-service.js
+    const serviceName = 'com.victronenergy.my_integration_test_service1';
+    const interfaceName = serviceName;
+    const objectPath = `/${serviceName.replace(/\./g, '/')}`;
+
+    const sessionBus = dbus.sessionBus();
+    if (!sessionBus) {
+      throw new Error('Could not connect to the DBus session bus.');
+    }
+
+    // request service name from the bus
+    await new Promise((resolve, reject) => {
+      sessionBus.requestName(serviceName, 0x4, (err, retCode) => {
+        // If there was an error, warn user and fail
+        if (err) {
+          return reject(new Error(
+            `Could not request service name ${serviceName}, the error was: ${err}.`
+          ));
+        }
+
+        // Return code 0x1 means we successfully had the name
+        if (retCode === 1) {
+          console.log(`Successfully requested service name "${serviceName}"!`);
+          resolve();
+        } else {
+          /* Other return codes means various errors, check here
+        (https://dbus.freedesktop.org/doc/api/html/group__DBusShared.html#ga37a9bc7c6eb11d212bf8d5e5ff3b50f9) for more
+        information
+        */
+          return reject(new Error(
+            `Failed to request service name "${serviceName}". Check what return code "${retCode}" means.`
+          ));
+        }
+      });
+    });
+
+    // First, we need to create our interface description (here we will only expose method calls)
+    var ifaceDesc = {
+      name: interfaceName,
+      methods: {
+        // Simple types
+        SayHello: ['', 's', [], ['hello_sentence']],
+        GiveTime: ['', 's', [], ['current_time']],
+        Capitalize: ['s', 's', ['initial_string'], ['capitalized_string']]
+      },
+      properties: {
+        Flag: 'b',
+        StringProp: 's',
+        RandValue: 'i'
+      },
+      signals: {
+        Rand: ['i', 'random_number']
+      }
+    };
+
+    // Then we need to create the interface implementation (with actual functions)
+    var iface = {
+      SayHello: function() {
+        return 'Hello, world!';
+      },
+      GiveTime: function() {
+        return new Date().toString();
+      },
+      Capitalize: function(str) {
+        return str.toUpperCase();
+      },
+      Flag: true,
+      StringProp: 'initial string',
+      RandValue: 43,
+      emit: function() {
+        // no nothing, as usual
+      }
+    };
+
+
+    // Now we need to actually export our interface on our object
+    sessionBus.exportInterface(iface, objectPath, ifaceDesc);
+
+    // Then we can add the required Victron interfaces, and receive some funtions to use
+    const {
+      emitItemsChanged,
+      addSettings,
+      removeSettings,
+      getValue,
+      setValue
+    } = addVictronInterfaces(sessionBus, ifaceDesc, iface);
+
+    console.log('Interface exposed to DBus, ready to receive function calls!');
+
+    async function proceed() {
+      const settingsResult = await addSettings([
+        { path: '/Settings/Basic2/OptionA', default: 3, min: 0, max: 5 },
+        { path: '/Settings/Basic2/OptionB', default: 'x' },
+        { path: '/Settings/Basic2/OptionC', default: 'y' },
+        { path: '/Settings/Basic2/OptionD', default: 'y' },
+      ]);
+      console.log('settingsResult', JSON.stringify(settingsResult, null, 2));
+
+      const interval = setInterval(async () => {
+
+        // emit a random value (not relevant for our Victron interfaces)
+        var rand = Math.round(Math.random() * 100);
+        if (rand > 75) {
+          iface.emit('Rand', Math.round(Math.random() * 100));
+        }
+
+        // set a random value. By calling emitItemsChanged afterwards, the
+        // Victron-specific signal 'ItemsChanged' will be emitted
+        iface.RandValue = Math.round(Math.random() * 100);
+        emitItemsChanged();
+
+        // change a setting programmatically
+        const setValueResult = await setValue({
+          path: '/Settings/Basic2/OptionB',
+          value: 'changed via SetValue ' + Math.round(Math.random() * 100),
+          interface: 'com.victronenergy.BusItem',
+          destination: 'com.victronenergy.settings'
+        });
+        console.log('setValueResult', setValueResult);
+
+        // or get a configuration value
+        getValue({
+          path: '/Settings/Basic2/OptionB',
+          interface: 'com.victronenergy.BusItem',
+          destination: 'com.victronenergy.settings'
+        });
+
+      }, 1_000);
+
+      await new Promise((resolve) => {
+        setTimeout(() => {
+          console.log('CLEARING INTERVAL', interval);
+          clearInterval(interval);
+          removeSettings([
+            { path: '/Settings/Basic2/OptionC', default: 'y' },
+            { path: '/Settings/Basic2/OptionD', default: 'y' }
+          ]);
+          resolve();
+        }, 5000);
+      });
+
+    }
+
+    await proceed();
+    sessionBus.connection.end();
+
+    // wait a bit more, until all logs are written
+    await new Promise(res => setTimeout(res, 2_000));
+
+
+  }, /* timeout in milliseconds */ 20_000);
+});

package/src/__tests__/setValueTest.js

@@ -0,0 +1,121 @@
+/* eslint-env node */
+const { addVictronInterfaces } = require('../index');
+
+describe('victron-dbus-virtual, setValue tests', () => {
+
+  it('works for the happy case', async () => {
+    const declaration = { name: 'foo', properties: { StringProp: 's' } };
+    const definition = { StringProp: 'hello' };
+    const bus = {
+      exportInterface: () => { },
+      invoke: function(args, cb) {
+        process.nextTick(() => cb(null, args));
+      }
+    }
+    const { setValue } = addVictronInterfaces(bus, declaration, definition);
+
+    const result = await setValue({
+      path: '/StringProp',
+      value: 'fourty-two',
+      destination: 'foo',
+      interface_: 'foo'
+    });
+    expect(result.member).toBe('SetValue');
+    expect(result.body).toStrictEqual([['s', 'fourty-two']]);
+    expect(result.path).toBe('/StringProp');
+    expect(result.interface).toBe('foo');
+    expect(result.destination).toBe('foo');
+
+    // NOTE: calling setValue() does *not* change the definition. If you want to update the definition,
+    // re-assign it: "definition.StringProp = 'fourty-two';"
+    // ... if you want to notify other processes of the change, you can call emitItemsChanged().
+    // The purpose of setValue() is to change the value in the dbus object, not the definition. This is useful
+    // for settings.
+    expect(definition.StringProp).toBe('hello');
+  });
+
+  it('works for the happy case for settings', async () => {
+    const declaration = { name: 'foo', properties: { StringProp: 's' } };
+    const definition = { StringProp: 'hello' };
+    const bus = {
+      exportInterface: () => { },
+      invoke: function(args, cb) {
+        process.nextTick(() => cb(null, args));
+      }
+    }
+    const { addSettings, setValue, removeSettings } = addVictronInterfaces(bus, declaration, definition);
+
+    // first, add a setting
+    const settingsResult = await addSettings([
+      { path: '/Settings/MySettings/Setting', default: 3, min: 0, max: 10 },
+    ]);
+    expect(settingsResult.member).toBe('AddSettings');
+
+    // then, we set its value
+    const setValueResult = await setValue({
+      path: '/Settings/MySettings/Setting',
+      value: 7,
+      interface: 'com.victronenergy.BusItem',
+      destination: 'com.victronenergy.settings',
+    });
+    expect(setValueResult.member).toBe('SetValue');
+
+    // lastly, we remove the setting
+    const removeSettingsResult = await removeSettings([
+      { path: '/Settings/MySettings/Setting' },
+    ]);
+    expect(removeSettingsResult.member).toBe('RemoveSettings');
+    expect(removeSettingsResult.body).toStrictEqual([['/Settings/MySettings/Setting']]);
+    expect(removeSettingsResult.path).toBe('/');
+    expect(removeSettingsResult.interface).toBe('com.victronenergy.Settings');
+    expect(removeSettingsResult.destination).toBe('com.victronenergy.settings');
+    expect(removeSettingsResult.signature).toBe('as');
+
+  });
+
+  it('works for the happy case when we get called with SetValue', async () => {
+    const declaration = { name: 'foo', properties: { StringProp: 's' } };
+    const definition = { StringProp: 'hello' };
+    const emit = jest.fn();
+    const interfaces = []
+    const bus = {
+      exportInterface: (iface /* , _path, _ifaceDesc */) => {
+        interfaces.push(iface);
+        iface.emit = emit;
+      },
+      invoke: function(args, cb) {
+        process.nextTick(() => cb(null, args));
+      }
+    }
+    addVictronInterfaces(bus, declaration, definition);
+    expect(!!interfaces[1].SetValue).toBe(true);
+    interfaces[1].SetValue([[{ type: 's' }], ['hello']]);
+    expect(emit.mock.calls[0][0]).toBe('ItemsChanged');
+    expect(emit.mock.calls[0][1]).toEqual([['StringProp', [['Value', ['s', 'hello']], ['Text', ['s', 'hello']]]]]);
+  });
+
+  it('fails if the underlying invoke() fails', async () => {
+    const declaration = { name: 'foo', properties: { StringProp: 's' } };
+    const definition = { StringProp: 'hello' };
+    const bus = {
+      exportInterface: () => { },
+      invoke: function(_args, cb) {
+        process.nextTick(() => cb(new Error('testing ... invoke failed')));
+      }
+    }
+    const { setValue } = addVictronInterfaces(bus, declaration, definition);
+
+    try {
+      await setValue({
+        path: '/StringProp',
+        value: 'fourty-two',
+        destination: 'foo',
+        interface_: 'foo',
+      });
+      expect(false, 'should have thrown');
+    } catch (e) {
+      expect(e.message).toBe('testing ... invoke failed');
+    }
+  });
+
+});

package/src/index.js

@@ -0,0 +1,213 @@
+
+function addVictronInterfaces(bus, declaration, definition) {
+
+  const warnings = [];
+
+  if (!declaration.name) {
+    throw new Error('Interface name is required');
+  }
+
+  if (!declaration.name.match(/^[a-zA-Z0-9_.]+$/)) {
+    warnings.push(
+      `Interface name contains problematic characters, only a-zA-Z0-9_ allowed.`
+    );
+  }
+  if (!declaration.name.match(/^com.victronenergy/)) {
+    warnings.push('Interface name should start with com.victronenergy');
+  }
+
+  function wrapValue(t, v) {
+    switch (t) {
+      case 'b':
+        return ['b', v];
+      case 's':
+        return ['s', v];
+      case 'i':
+        return ['i', v];
+      default:
+        return 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]);
+      default:
+        throw new Error(`Unsupported value type: ${JSON.stringify(t)}`);
+    }
+  }
+
+  // we use this for GetItems and ItemsChanged
+  function getProperties() {
+    return Object.entries(declaration.properties || {}).map(([k, v]) => {
+      console.log('getProperties, entries, (k,v):', k, v);
+
+      return [
+        k,
+        [
+          ['Value', wrapValue(v, definition[k])],
+          ['Text', ['s', '' + definition[k]]]
+        ]
+      ];
+    });
+  }
+
+  const iface = {
+    GetItems: function() {
+      return getProperties();
+    },
+    emit: function() { }
+  };
+
+  const ifaceDesc = {
+    name: 'com.victronenergy.BusItem',
+    methods: {
+      GetItems: ['', 'a{sa{sv}}', [], []]
+    },
+    signals: {
+      ItemsChanged: ['a{sa{sv}}', '', [], []]
+    }
+  };
+
+  bus.exportInterface(iface, '/', ifaceDesc);
+
+  // support GetValue for each property
+  for (const [k,] of Object.entries(declaration.properties || {})) {
+    bus.exportInterface(
+      {
+        SetValue: function(value, /* msg */) {
+          console.log(
+            'SetValue',
+            JSON.stringify(arguments[0]),
+            JSON.stringify(arguments[1])
+          );
+          try {
+            definition[k] = unwrapValue(value);
+            iface.emit('ItemsChanged', getProperties());
+            return 0;
+          } catch (e) {
+            console.error(e);
+            return -1;
+          }
+        }
+      },
+      `/${k}`,
+      {
+        name: 'com.victronenergy.BusItem',
+        methods: {
+          SetValue: ['v', 'i', [], []]
+        }
+      }
+    );
+  }
+
+  async function addSettings(settings) {
+    const body = [
+      settings.map(setting => [
+        ['path', wrapValue('s', setting.path)],
+        ['default', wrapValue('s', '' + setting.default)] // TODO: forcing value to be string
+        // 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 }) {
+    return await new Promise((resolve, reject) => {
+      bus.invoke(
+        {
+          interface: interface_,
+          path: path || '/',
+          member: 'SetValue',
+          destination,
+          signature: 'v',
+          body: [wrapValue('s', '' + value)] // TODO: only supports string type for now
+        },
+        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,
+    warnings
+  };
+}
+
+
+module.exports = { addVictronInterfaces };