optolink-bridge 1.0.0

package/tools/convert_poll_items.js

@@ -0,0 +1,91 @@
+/*
+ * Use this script to convert optolink-splitter poll items into a optolink-bridge data points format.
+ *
+ * See 'convert_poll_items_example.txt' and use the filename as an input to this script:
+ * 
+ * yarn node convert_poll_items.js convert_poll_items_example.txt
+ * 
+ * Input data format from:
+ * 
+ * https://github.com/philippoo66/optolink-splitter/blob/main/settings_ini.py
+ */
+
+
+import fs from 'node:fs/promises';
+import readline from 'node:readline';
+import { basename } from 'node:path';
+import { exists } from '../utils.js';
+
+const path = process.argv[2];
+if (!path || !(await exists(path))) {
+  console.error(`Usage: ${basename(process.argv[1])} <dps-file>`);
+  process.exit(1);
+}
+
+const file = await fs.open(path, 'r');
+const lines = readline.createInterface({
+  input: file.createReadStream(),
+  crlfDelay: Infinity,
+});
+
+const warnings = [];
+for await (let line of lines) {
+  const item = line.match(/(?<=\().*(?=\))/g)?.[0]?.split(/\s*,\s*/);
+  if (!item) {
+    continue;
+  }
+
+  let [poll_cycle, name, address, length, byte_bit_filter, scale_or_type, signed] = item;
+  if (!isFinite(poll_cycle)) {
+    [name, address, length, byte_bit_filter, scale_or_type, signed] = item;
+    poll_cycle = undefined;
+  }
+
+  name = name.match(/(?<=\").*(?=\")/g)[0];
+
+  if (!/^\s*"b:/.test(byte_bit_filter)) {
+    [scale_or_type, signed] = [byte_bit_filter, scale_or_type];
+    byte_bit_filter = undefined;
+  } else {
+    byte_bit_filter = byte_bit_filter.match(/(?<=\").*(?=\")/g)[0];
+  }
+
+  let scale = 1, type;
+  if (isFinite(scale_or_type)) {
+    scale = parseFloat(scale_or_type);
+  } else {
+    type = scale_or_type.match(/(?<=\").*(?=\")/g)[0];
+  }
+
+  signed = signed === 'True';
+
+  if (!type) {
+    type = `int${(parseInt(length) * 8)}`;
+    if (!signed) {
+      type = `u${type}`;
+    }
+  }
+
+  if (byte_bit_filter) {
+    warnings.push(`Byte-bit filters are currently not supported by optolink-bridge, using "raw" type for "${name}"`);
+    type = 'raw';
+  }
+  if (poll_cycle) {
+    warnings.push(`Poll-cycles are not required for optolink-bridge, "${name}" will be published when it is sent via the Optolink interface`);
+  }
+
+  console.log(`  ["${name}", ${address}, "${type}"${ scale !== 1 ? `, ${scale}` : '' }],`);
+}
+
+try {
+  await file.close();
+} catch {
+  // nothing to do here
+}
+
+if (warnings.length) {
+  console.log();
+  for (const warning of warnings) {
+    console.warn(warning);
+  }
+}

package/tools/convert_poll_items_example.txt

@@ -0,0 +1,42 @@
+("aussentemperatur", 0x0101, 2, 0.1, True),
+
+("betriebsart", 0xB000, 1, "raw", False,),
+
+("heizkreisumwalzpumpe", 0x048D, 1, 1, True),
+("heizkreisumwalzpumpe_betriebsstunden", 0x058D, 4, 0.0002777777777777778, False),
+
+("hkl_niveau", 0x2006, 2, 0.1, True),
+("hkl_neigung", 0x2007, 2, 0.1, True),
+("hysterese", 0x7203, 2, 0.1, True),
+
+("puffer_temperatur", 0x010B, 2, 0.1, True),
+
+("primarkreis_vorlauftemperatur", 0x0103, 2, 0.1, True),
+("sekundarkreis_vorlauftemperatur", 0x0105, 2, 0.1, True),
+("rucklauftemperatur", 0x0106, 2, 0.1, True),
+
+("ww_temperatur_speicher", 0x010D, 2, 0.1, True),
+("ww_temperatur_soll", 0x6000, 2, 0.1, True),
+("ww_temperatur_soll2", 0x600C, 2, 0.1, True),
+("ww_zirkulationspumpe", 0x0490, 1, 1, True),
+
+("raum_temperatur_soll_normal", 0x2000, 2, 0.1, True),
+("raum_temperatur_soll_reduziert", 0x2001, 2, 0.1, True),
+("raum_temperatur_soll_party", 0x2022, 2, 0.1, True),
+
+("kompressor", 0x0480, 1, 1, True),
+("kompressor_phase", 0x0E1A, 3, "raw", False),
+("kompressor_starts", 0x0500, 4, 1, True),
+("kompressor_betriebsstunden", 0x0580, 4, 0.0002777777777777778, False),
+
+("einmalig_ww", 0xB020, 1, "raw", False),
+
+("energie_faktor", 0x163F, 1, 1, True),
+("energie_heizen", 0x1640, 4, 1, False),
+("energie_ww", 0x1650, 4, 1, False),
+("energie_heizen_elektro", 0x1660, 4, 1, False),
+("energie_ww_elektro", 0x1670, 4, 1, False),
+
+("jahresarbeitszahl", 0x1680, 1, 0.1, True),
+("jahresarbeitszahl_heizen", 0x1681, 1, 0.1, True),
+("jahresarbeitszahl_ww", 0x1682, 1, 0.1, True),

package/utils.js

@@ -0,0 +1,141 @@
+import fs from 'fs/promises';
+import { watch } from 'chokidar';
+import { parse as parseToml } from 'smol-toml';
+import { parseValue } from './parse_vs2.js';
+import { fromOptoToVito, fromVitoToOpto } from './serial.js';
+
+export const fromLocalToOpto = 0b0100; // Local → Optolink
+export const fromOptoToLocal = 0b1000; // Optolink → Local
+
+export const toOpto = 0b0101; // → Optolink (check with & toOpto)
+export const fromOpto = 0b1010; // Optolink → (check with & fromOpto)
+
+/**
+ * Check if a file (/ directory) exists on the file system.
+ *
+ * @param {string} path the path to check to exist
+ * @returns {boolean} true if the file exists, false otherwise
+ */
+export async function exists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return false;
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Read the configuration file (config.toml / local_config.toml) and parse the TOML.
+ *
+ * @param {function} [watchCallback] a function to call when the configuration file changes
+ * @returns {object} the parsed TOML configuration
+ */
+export async function readConfig(watchCallback) {
+  const configFile = (await exists('local_config.toml')) ?
+    'local_config.toml' : 'config.toml';
+
+  if (typeof watchCallback === 'function') {
+    watch(configFile, {
+      awaitWriteFinish: true,
+      persistent: false, // do not keep the process running
+      encoding: 'utf8'
+    }).on('change', async () => {
+      await watchCallback(await readConfig());
+    });
+  }
+
+  return parseToml(await fs.readFile(configFile, 'utf8'));
+}
+
+/**
+ * Return a date / time string in the current timezone in ISO format w/o "TZ" separators.
+ *
+ * @returns {string} a date time string
+ */
+const tzOffset = new Date().getTimezoneOffset();
+export function dateTimeString(date = Date.now()) {
+  return new Date((+date) - tzOffset * 60 * 1000)
+    .toISOString().replaceAll(/[TZ]/g, ' ').trim();
+}
+
+/**
+ * Format a address by padding it to a 4 character hex string.
+ * 
+ * @param {number} addr the address to format
+ * @returns {string} the formatted address
+ */
+export function formatAddr(addr, prefix = '0x') {
+  if (typeof addr !== 'number') {
+    throw new TypeError(`Expected address to be a number, got ${typeof addr}`);
+  }
+  return `${prefix}${addr.toString(16).padStart(4, '0')}`;
+}
+
+/**
+ * Format the direction of data transfer to a human-readable string.
+ *
+ * @param {number} direction the direction to format
+ * @returns {string} the formatted direction
+ */
+export function directionName(direction) {
+  switch (direction) {
+    case fromVitoToOpto:
+      return 'Vitoconnect → Optolink';
+    case fromOptoToVito:
+      return 'Optolink → Vitoconnect';
+    case fromLocalToOpto:
+      return 'Local → Optolink';
+    case fromOptoToLocal:
+      return 'Optolink → Local';
+    default:
+      return 'Unknown';
+  }
+}
+
+/**
+ * Create a `Map` from a given array of data points, mapping the data point address to the data point.
+ * 
+ * @param {Array<object>} dps the data points to create a map for
+ * @param {Map} [map] the map to add the data points to
+ * @returns {Map} the map of data points
+ */
+export function mapDataPoints(dps, map = new Map()) {
+  for (const dp of (dps ?? [])) {
+    let [name, addr, type, scale] = dp;
+
+    if (typeof type === 'number') {
+      const signed = !!scale;
+      scale = type;
+      type = 'int';
+      if (!signed) {
+        type = `u${type}`;
+      }
+    }
+
+    if (map.has(addr)) {
+      throw new TypeError(`Duplicate data point "${name}" with address ${formatAddr(addr)}`);
+    }
+
+    map.set(addr, {
+      name, addr, type, scale, parse: data => {
+        let value = parseValue(type, data);
+        if (Number.isFinite(scale)) {
+          if (typeof value === 'number') {
+            value *= scale;
+          } else if (typeof value === 'bigint') {
+            value *= BigInt(scale);
+          }
+        }
+      
+        return value;
+      }
+    });
+  }
+
+  return map;
+}