@fa_yoshinobu/node-red-contrib-plc-comm-slmp 0.2.1

package/lib/slmp/constants.js

@@ -0,0 +1,121 @@
+"use strict";
+
+const FRAME_3E_REQUEST_SUBHEADER = Buffer.from([0x50, 0x00]);
+const FRAME_3E_RESPONSE_SUBHEADER = Buffer.from([0xd0, 0x00]);
+const FRAME_4E_REQUEST_SUBHEADER = Buffer.from([0x54, 0x00]);
+const FRAME_4E_RESPONSE_SUBHEADER = Buffer.from([0xd4, 0x00]);
+
+const FrameType = Object.freeze({
+  FRAME_3E: "3e",
+  FRAME_4E: "4e",
+});
+
+const PLCSeries = Object.freeze({
+  QL: "ql",
+  IQR: "iqr",
+});
+
+const DeviceUnit = Object.freeze({
+  BIT: "bit",
+  WORD: "word",
+});
+
+const ModuleIONo = Object.freeze({
+  OWN_STATION: 0x03ff,
+  CONTROL_CPU: 0x03ff,
+  MULTIPLE_CPU_1: 0x03e0,
+  MULTIPLE_CPU_2: 0x03e1,
+  MULTIPLE_CPU_3: 0x03e2,
+  MULTIPLE_CPU_4: 0x03e3,
+  CONTROL_SYSTEM_CPU: 0x03d0,
+  STANDBY_SYSTEM_CPU: 0x03d1,
+  SYSTEM_A_CPU: 0x03d2,
+  SYSTEM_B_CPU: 0x03d3,
+  REMOTE_HEAD_1: 0x03e0,
+  REMOTE_HEAD_2: 0x03e1,
+  CONTROL_SYSTEM_REMOTE_HEAD: 0x03d0,
+  STANDBY_SYSTEM_REMOTE_HEAD: 0x03d1,
+});
+
+const Command = Object.freeze({
+  DEVICE_READ: 0x0401,
+  DEVICE_WRITE: 0x1401,
+  DEVICE_READ_RANDOM: 0x0403,
+  DEVICE_WRITE_RANDOM: 0x1402,
+  READ_TYPE_NAME: 0x0101,
+});
+
+const SUBCOMMAND_DEVICE_WORD_QL = 0x0000;
+const SUBCOMMAND_DEVICE_BIT_QL = 0x0001;
+const SUBCOMMAND_DEVICE_WORD_IQR = 0x0002;
+const SUBCOMMAND_DEVICE_BIT_IQR = 0x0003;
+
+const SUBCOMMAND_DEVICE_WORD_QL_EXT = 0x0080;
+const SUBCOMMAND_DEVICE_BIT_QL_EXT = 0x0081;
+const SUBCOMMAND_DEVICE_WORD_IQR_EXT = 0x0082;
+const SUBCOMMAND_DEVICE_BIT_IQR_EXT = 0x0083;
+
+const DEVICE_CODES = Object.freeze({
+  SM: { code: 0x0091, radix: 10, unit: DeviceUnit.BIT },
+  SD: { code: 0x00a9, radix: 10, unit: DeviceUnit.WORD },
+  X: { code: 0x009c, radix: 16, unit: DeviceUnit.BIT },
+  Y: { code: 0x009d, radix: 16, unit: DeviceUnit.BIT },
+  M: { code: 0x0090, radix: 10, unit: DeviceUnit.BIT },
+  L: { code: 0x0092, radix: 10, unit: DeviceUnit.BIT },
+  F: { code: 0x0093, radix: 10, unit: DeviceUnit.BIT },
+  V: { code: 0x0094, radix: 10, unit: DeviceUnit.BIT },
+  B: { code: 0x00a0, radix: 16, unit: DeviceUnit.BIT },
+  D: { code: 0x00a8, radix: 10, unit: DeviceUnit.WORD },
+  W: { code: 0x00b4, radix: 16, unit: DeviceUnit.WORD },
+  TS: { code: 0x00c1, radix: 10, unit: DeviceUnit.BIT },
+  TC: { code: 0x00c0, radix: 10, unit: DeviceUnit.BIT },
+  TN: { code: 0x00c2, radix: 10, unit: DeviceUnit.WORD },
+  LTS: { code: 0x0051, radix: 10, unit: DeviceUnit.BIT },
+  LTC: { code: 0x0050, radix: 10, unit: DeviceUnit.BIT },
+  LTN: { code: 0x0052, radix: 10, unit: DeviceUnit.WORD },
+  STS: { code: 0x00c7, radix: 10, unit: DeviceUnit.BIT },
+  STC: { code: 0x00c6, radix: 10, unit: DeviceUnit.BIT },
+  STN: { code: 0x00c8, radix: 10, unit: DeviceUnit.WORD },
+  LSTS: { code: 0x0059, radix: 10, unit: DeviceUnit.BIT },
+  LSTC: { code: 0x0058, radix: 10, unit: DeviceUnit.BIT },
+  LSTN: { code: 0x005a, radix: 10, unit: DeviceUnit.WORD },
+  CS: { code: 0x00c4, radix: 10, unit: DeviceUnit.BIT },
+  CC: { code: 0x00c3, radix: 10, unit: DeviceUnit.BIT },
+  CN: { code: 0x00c5, radix: 10, unit: DeviceUnit.WORD },
+  LCS: { code: 0x0055, radix: 10, unit: DeviceUnit.BIT },
+  LCC: { code: 0x0054, radix: 10, unit: DeviceUnit.BIT },
+  LCN: { code: 0x0056, radix: 10, unit: DeviceUnit.WORD },
+  SB: { code: 0x00a1, radix: 16, unit: DeviceUnit.BIT },
+  SW: { code: 0x00b5, radix: 16, unit: DeviceUnit.WORD },
+  DX: { code: 0x00a2, radix: 16, unit: DeviceUnit.BIT },
+  DY: { code: 0x00a3, radix: 16, unit: DeviceUnit.BIT },
+  Z: { code: 0x00cc, radix: 10, unit: DeviceUnit.WORD },
+  LZ: { code: 0x0062, radix: 10, unit: DeviceUnit.WORD },
+  R: { code: 0x00af, radix: 10, unit: DeviceUnit.WORD },
+  ZR: { code: 0x00b0, radix: 10, unit: DeviceUnit.WORD },
+  RD: { code: 0x002c, radix: 10, unit: DeviceUnit.WORD },
+  G: { code: 0x00ab, radix: 10, unit: DeviceUnit.WORD },
+  HG: { code: 0x002e, radix: 10, unit: DeviceUnit.WORD },
+});
+
+module.exports = {
+  Command,
+  DEVICE_CODES,
+  DeviceUnit,
+  FRAME_3E_REQUEST_SUBHEADER,
+  FRAME_3E_RESPONSE_SUBHEADER,
+  FRAME_4E_REQUEST_SUBHEADER,
+  FRAME_4E_RESPONSE_SUBHEADER,
+  FrameType,
+  ModuleIONo,
+  PLCSeries,
+  SUBCOMMAND_DEVICE_BIT_IQR,
+  SUBCOMMAND_DEVICE_BIT_IQR_EXT,
+  SUBCOMMAND_DEVICE_BIT_QL,
+  SUBCOMMAND_DEVICE_BIT_QL_EXT,
+  SUBCOMMAND_DEVICE_WORD_IQR,
+  SUBCOMMAND_DEVICE_WORD_IQR_EXT,
+  SUBCOMMAND_DEVICE_WORD_QL,
+  SUBCOMMAND_DEVICE_WORD_QL_EXT,
+};
+

package/lib/slmp/core.js

@@ -0,0 +1,406 @@
+"use strict";
+
+const {
+  DEVICE_CODES,
+  FRAME_3E_REQUEST_SUBHEADER,
+  FRAME_3E_RESPONSE_SUBHEADER,
+  FRAME_4E_REQUEST_SUBHEADER,
+  FRAME_4E_RESPONSE_SUBHEADER,
+  FrameType,
+  ModuleIONo,
+  PLCSeries,
+  SUBCOMMAND_DEVICE_BIT_IQR,
+  SUBCOMMAND_DEVICE_BIT_IQR_EXT,
+  SUBCOMMAND_DEVICE_BIT_QL,
+  SUBCOMMAND_DEVICE_BIT_QL_EXT,
+  SUBCOMMAND_DEVICE_WORD_IQR,
+  SUBCOMMAND_DEVICE_WORD_IQR_EXT,
+  SUBCOMMAND_DEVICE_WORD_QL,
+  SUBCOMMAND_DEVICE_WORD_QL_EXT,
+} = require("./constants");
+const { SlmpError } = require("./errors");
+
+function normalizeFrameType(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === FrameType.FRAME_3E || normalized === FrameType.FRAME_4E) {
+    return normalized;
+  }
+  throw new ValueError(`Unsupported frame type: ${value}`);
+}
+
+function normalizePlcSeries(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === PLCSeries.QL || normalized === PLCSeries.IQR) {
+    return normalized;
+  }
+  throw new ValueError(`Unsupported PLC series: ${value}`);
+}
+
+function normalizeTransport(value) {
+  const normalized = String(value || "tcp").trim().toLowerCase();
+  if (normalized === "tcp" || normalized === "udp") {
+    return normalized;
+  }
+  throw new ValueError(`Unsupported transport: ${value}`);
+}
+
+function parseNumber(value, name, options = {}) {
+  const { defaultValue, base = 10 } = options;
+  if (value === undefined || value === null || value === "") {
+    if (defaultValue !== undefined) {
+      return defaultValue;
+    }
+    throw new ValueError(`${name} is required`);
+  }
+
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new ValueError(`${name} must be finite`);
+    }
+    return Math.trunc(value);
+  }
+
+  const text = String(value).trim();
+  if (!text) {
+    if (defaultValue !== undefined) {
+      return defaultValue;
+    }
+    throw new ValueError(`${name} is required`);
+  }
+
+  let radix = base;
+  let normalized = text;
+  if (/^0x/i.test(text)) {
+    radix = 16;
+    normalized = text.slice(2);
+  } else if (/[a-f]/i.test(text)) {
+    radix = 16;
+  }
+
+  const parsed = Number.parseInt(normalized, radix);
+  if (!Number.isFinite(parsed)) {
+    throw new ValueError(`${name} must be numeric: ${value}`);
+  }
+  return parsed;
+}
+
+function ensureRange(value, min, max, name) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new ValueError(`${name} out of range (${min}..${max}): ${value}`);
+  }
+  return value;
+}
+
+function normalizeTarget(target = {}) {
+  const moduleIOSource = target.moduleIO ?? target.module_io ?? ModuleIONo.OWN_STATION;
+  return {
+    network: ensureRange(parseNumber(target.network, "target.network", { defaultValue: 0x00 }), 0, 0xff, "target.network"),
+    station: ensureRange(parseNumber(target.station, "target.station", { defaultValue: 0xff }), 0, 0xff, "target.station"),
+    moduleIO: ensureRange(
+      parseNumber(moduleIOSource, "target.moduleIO", { defaultValue: ModuleIONo.OWN_STATION, base: 16 }),
+      0,
+      0xffff,
+      "target.moduleIO"
+    ),
+    multidrop: ensureRange(parseNumber(target.multidrop, "target.multidrop", { defaultValue: 0x00 }), 0, 0xff, "target.multidrop"),
+  };
+}
+
+function parseDevice(value) {
+  if (value && typeof value === "object" && typeof value.code === "string" && Number.isInteger(value.number)) {
+    return { code: value.code.toUpperCase(), number: value.number };
+  }
+
+  const text = String(value || "").trim().toUpperCase();
+  const match = /^([A-Z]+)([0-9A-F]+)$/.exec(text);
+  if (!match) {
+    throw new ValueError(
+      `Invalid SLMP device string ${JSON.stringify(value)}. Expected <DeviceCode><Number> such as D100 or X1F.`
+    );
+  }
+
+  const [, code, numberText] = match;
+  const deviceCode = DEVICE_CODES[code];
+  if (!deviceCode) {
+    throw new ValueError(`Unknown SLMP device code '${code}' in ${JSON.stringify(value)}`);
+  }
+  return {
+    code,
+    number: Number.parseInt(numberText, deviceCode.radix),
+  };
+}
+
+function deviceToString(value) {
+  const ref = parseDevice(value);
+  const info = DEVICE_CODES[ref.code];
+  if (!info) {
+    return `${ref.code}${ref.number}`;
+  }
+  if (info.radix === 16) {
+    return `${ref.code}${ref.number.toString(16).toUpperCase()}`;
+  }
+  return `${ref.code}${ref.number}`;
+}
+
+function encode3ERequest({ target, monitoringTimer, command, subcommand, data = Buffer.alloc(0) }) {
+  const normalizedTarget = normalizeTarget(target);
+  const payload = Buffer.from(data);
+  ensureRange(monitoringTimer, 0, 0xffff, "monitoringTimer");
+  ensureRange(command, 0, 0xffff, "command");
+  ensureRange(subcommand, 0, 0xffff, "subcommand");
+
+  const reqLength = 2 + 2 + 2 + payload.length;
+  ensureRange(reqLength, 0, 0xffff, "requestDataLength");
+
+  const header = Buffer.alloc(11);
+  FRAME_3E_REQUEST_SUBHEADER.copy(header, 0);
+  header.writeUInt8(normalizedTarget.network, 2);
+  header.writeUInt8(normalizedTarget.station, 3);
+  header.writeUInt16LE(normalizedTarget.moduleIO, 4);
+  header.writeUInt8(normalizedTarget.multidrop, 6);
+  header.writeUInt16LE(reqLength, 7);
+  header.writeUInt16LE(monitoringTimer, 9);
+
+  const commandBuffer = Buffer.alloc(4);
+  commandBuffer.writeUInt16LE(command, 0);
+  commandBuffer.writeUInt16LE(subcommand, 2);
+  return Buffer.concat([header, commandBuffer, payload]);
+}
+
+function encode4ERequest({ serial, target, monitoringTimer, command, subcommand, data = Buffer.alloc(0) }) {
+  const normalizedTarget = normalizeTarget(target);
+  const payload = Buffer.from(data);
+  ensureRange(serial, 0, 0xffff, "serial");
+  ensureRange(monitoringTimer, 0, 0xffff, "monitoringTimer");
+  ensureRange(command, 0, 0xffff, "command");
+  ensureRange(subcommand, 0, 0xffff, "subcommand");
+
+  const reqLength = 2 + 2 + 2 + payload.length;
+  ensureRange(reqLength, 0, 0xffff, "requestDataLength");
+
+  const header = Buffer.alloc(15);
+  FRAME_4E_REQUEST_SUBHEADER.copy(header, 0);
+  header.writeUInt16LE(serial, 2);
+  header.writeUInt16LE(0x0000, 4);
+  header.writeUInt8(normalizedTarget.network, 6);
+  header.writeUInt8(normalizedTarget.station, 7);
+  header.writeUInt16LE(normalizedTarget.moduleIO, 8);
+  header.writeUInt8(normalizedTarget.multidrop, 10);
+  header.writeUInt16LE(reqLength, 11);
+  header.writeUInt16LE(monitoringTimer, 13);
+
+  const commandBuffer = Buffer.alloc(4);
+  commandBuffer.writeUInt16LE(command, 0);
+  commandBuffer.writeUInt16LE(subcommand, 2);
+  return Buffer.concat([header, commandBuffer, payload]);
+}
+
+function encodeRequest({ frameType, serial, target, monitoringTimer, command, subcommand, data = Buffer.alloc(0) }) {
+  const normalizedFrameType = normalizeFrameType(frameType);
+  if (normalizedFrameType === FrameType.FRAME_3E) {
+    return encode3ERequest({ target, monitoringTimer, command, subcommand, data });
+  }
+  return encode4ERequest({ serial, target, monitoringTimer, command, subcommand, data });
+}
+
+function decode3EResponse(frame) {
+  const buffer = Buffer.from(frame);
+  if (buffer.length < 11) {
+    throw new SlmpError(`response too short: ${buffer.length} bytes`);
+  }
+  if (!buffer.subarray(0, 2).equals(FRAME_3E_RESPONSE_SUBHEADER)) {
+    throw new SlmpError(`unexpected 3E response subheader: ${buffer.subarray(0, 2).toString("hex")}`);
+  }
+  const responseDataLength = buffer.readUInt16LE(7);
+  if (buffer.length !== 9 + responseDataLength) {
+    throw new SlmpError(
+      `response size mismatch: actual=${buffer.length}, expected=${9 + responseDataLength}, responseDataLength=${responseDataLength}`
+    );
+  }
+  return {
+    serial: 0,
+    target: normalizeTarget({
+      network: buffer.readUInt8(2),
+      station: buffer.readUInt8(3),
+      moduleIO: buffer.readUInt16LE(4),
+      multidrop: buffer.readUInt8(6),
+    }),
+    endCode: buffer.readUInt16LE(9),
+    data: buffer.subarray(11),
+    raw: buffer,
+  };
+}
+
+function decode4EResponse(frame) {
+  const buffer = Buffer.from(frame);
+  if (buffer.length < 15) {
+    throw new SlmpError(`response too short: ${buffer.length} bytes`);
+  }
+  if (!buffer.subarray(0, 2).equals(FRAME_4E_RESPONSE_SUBHEADER)) {
+    throw new SlmpError(`unexpected 4E response subheader: ${buffer.subarray(0, 2).toString("hex")}`);
+  }
+  const responseDataLength = buffer.readUInt16LE(11);
+  if (buffer.length !== 13 + responseDataLength) {
+    throw new SlmpError(
+      `response size mismatch: actual=${buffer.length}, expected=${13 + responseDataLength}, responseDataLength=${responseDataLength}`
+    );
+  }
+  return {
+    serial: buffer.readUInt16LE(2),
+    target: normalizeTarget({
+      network: buffer.readUInt8(6),
+      station: buffer.readUInt8(7),
+      moduleIO: buffer.readUInt16LE(8),
+      multidrop: buffer.readUInt8(10),
+    }),
+    endCode: buffer.readUInt16LE(13),
+    data: buffer.subarray(15),
+    raw: buffer,
+  };
+}
+
+function decodeResponse(frame, options) {
+  const normalizedFrameType = normalizeFrameType(options.frameType);
+  if (normalizedFrameType === FrameType.FRAME_3E) {
+    return decode3EResponse(frame);
+  }
+  return decode4EResponse(frame);
+}
+
+function resolveDeviceSubcommand({ bitUnit, series, extension = false }) {
+  const normalizedSeries = normalizePlcSeries(series);
+  if (extension) {
+    if (normalizedSeries === PLCSeries.QL) {
+      return bitUnit ? SUBCOMMAND_DEVICE_BIT_QL_EXT : SUBCOMMAND_DEVICE_WORD_QL_EXT;
+    }
+    return bitUnit ? SUBCOMMAND_DEVICE_BIT_IQR_EXT : SUBCOMMAND_DEVICE_WORD_IQR_EXT;
+  }
+  if (normalizedSeries === PLCSeries.QL) {
+    return bitUnit ? SUBCOMMAND_DEVICE_BIT_QL : SUBCOMMAND_DEVICE_WORD_QL;
+  }
+  return bitUnit ? SUBCOMMAND_DEVICE_BIT_IQR : SUBCOMMAND_DEVICE_WORD_IQR;
+}
+
+function encodeDeviceSpec(device, options) {
+  const ref = parseDevice(device);
+  const info = DEVICE_CODES[ref.code];
+  const normalizedSeries = normalizePlcSeries(options.series);
+  if (!info) {
+    throw new ValueError(`Unknown SLMP device code '${ref.code}'`);
+  }
+  if (ref.code === "R" && ref.number > 32767) {
+    throw new ValueError(`R device number out of supported range (0..32767): ${ref.number}`);
+  }
+  if (normalizedSeries === PLCSeries.QL) {
+    ensureRange(ref.number, 0, 0xffffff, "device.number");
+    const buffer = Buffer.alloc(4);
+    buffer.writeUIntLE(ref.number, 0, 3);
+    buffer.writeUInt8(info.code & 0xff, 3);
+    return buffer;
+  }
+
+  ensureRange(ref.number, 0, 0xffffffff, "device.number");
+  const buffer = Buffer.alloc(6);
+  buffer.writeUInt32LE(ref.number, 0);
+  buffer.writeUInt16LE(info.code, 4);
+  return buffer;
+}
+
+function decodeDeviceWords(data) {
+  const buffer = Buffer.from(data);
+  if (buffer.length % 2 !== 0) {
+    throw new SlmpError(`word data length must be even: ${buffer.length}`);
+  }
+  const values = [];
+  for (let index = 0; index < buffer.length; index += 2) {
+    values.push(buffer.readUInt16LE(index));
+  }
+  return values;
+}
+
+function decodeDeviceDwords(data) {
+  const buffer = Buffer.from(data);
+  if (buffer.length % 4 !== 0) {
+    throw new SlmpError(`dword data length must be multiple of 4: ${buffer.length}`);
+  }
+  const values = [];
+  for (let index = 0; index < buffer.length; index += 4) {
+    values.push(buffer.readUInt32LE(index));
+  }
+  return values;
+}
+
+function packBitValues(values) {
+  const bits = Array.from(values, (value) => (value ? 1 : 0));
+  const packed = [];
+  for (let index = 0; index < bits.length; index += 2) {
+    const hi = bits[index] & 0x1;
+    const lo = index + 1 < bits.length ? bits[index + 1] & 0x1 : 0;
+    packed.push((hi << 4) | lo);
+  }
+  return Buffer.from(packed);
+}
+
+function unpackBitValues(data, count) {
+  const buffer = Buffer.from(data);
+  const values = [];
+  for (const byte of buffer) {
+    values.push(Boolean((byte >> 4) & 0x1));
+    if (values.length >= count) {
+      return values;
+    }
+    values.push(Boolean(byte & 0x1));
+    if (values.length >= count) {
+      return values;
+    }
+  }
+  if (values.length !== count) {
+    throw new SlmpError(`bit data too short: needed ${count}, got ${values.length}`);
+  }
+  return values;
+}
+
+function extractFrameFromBuffer(buffer, options) {
+  const normalizedFrameType = normalizeFrameType(options.frameType);
+  const source = Buffer.from(buffer);
+  const headSize = normalizedFrameType === FrameType.FRAME_4E ? 13 : 9;
+  if (source.length < headSize) {
+    return null;
+  }
+  const responseDataLength = source.readUInt16LE(headSize - 2);
+  const totalLength = headSize + responseDataLength;
+  if (source.length < totalLength) {
+    return null;
+  }
+  return {
+    frame: source.subarray(0, totalLength),
+    rest: source.subarray(totalLength),
+  };
+}
+
+class ValueError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValueError";
+  }
+}
+
+module.exports = {
+  ValueError,
+  decodeDeviceDwords,
+  decodeDeviceWords,
+  decodeResponse,
+  deviceToString,
+  encodeDeviceSpec,
+  encodeRequest,
+  extractFrameFromBuffer,
+  normalizeFrameType,
+  normalizePlcSeries,
+  normalizeTarget,
+  normalizeTransport,
+  packBitValues,
+  parseDevice,
+  parseNumber,
+  resolveDeviceSubcommand,
+  unpackBitValues,
+};

package/lib/slmp/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+
+class SlmpError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "SlmpError";
+    if (options.endCode !== undefined) {
+      this.endCode = options.endCode;
+    }
+    if (options.data !== undefined) {
+      this.data = options.data;
+    }
+    if (options.cause !== undefined) {
+      this.cause = options.cause;
+    }
+  }
+}
+
+module.exports = {
+  SlmpError,
+};