nodalis-compiler 1.0.0

package/src/compilers/support/jint/nodalis/build.bat

@@ -0,0 +1,25 @@
+@echo off
+echo Building NodalisEngine...
+dotnet build NodalisEngine/NodalisEngine.csproj
+
+echo Publishing NodalisPLC for Windows...
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r win-x64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/win-x64
+copy "NodalisPLC/bootstrap.bat" publish/win-x64/bootstrap.bat
+
+echo Publishing NodalisPLC for Linux...
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r linux-x64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/linux-x64
+copy "NodalisPLC/bootstrap.sh" publish/linux-x64/bootstrap.sh
+
+echo Publishing NodalisPLC for macOS...
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r osx-x64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/osx-x64
+copy "NodalisPLC/bootstrap.sh" publish/osx-x64/bootstrap.sh
+
+echo Publishing NodalisPLC for Linux ARM 32-bit...
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r linux-arm --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/linux-arm
+copy "NodalisPLC/bootstrap.sh" publish/linux-arm/bootstrap.sh
+
+echo Publishing NodalisPLC for Linux ARM 64-bit...
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r linux-arm64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/linux-arm64
+copy "NodalisPLC/bootstrap.sh" publish/linux-arm64/bootstrap.sh
+
+echo Build complete.

package/src/compilers/support/jint/nodalis/build.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+set -e
+
+echo "Building NodalisEngine..."
+dotnet build NodalisEngine/NodalisEngine.csproj
+
+echo "Publishing NodalisPLC for Windows..."
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r win-x64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/win-x64
+cp "NodalisPLC/bootstrap.bat" publish/win-x64/bootstrap.bat
+
+echo "Publishing NodalisPLC for Linux..."
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r linux-x64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/linux-x64
+cp "NodalisPLC/bootstrap.sh" publish/linux-x64/bootstrap.sh
+
+echo "Publishing NodalisPLC for macOS..."
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r osx-x64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/osx-x64
+cp "NodalisPLC/bootstrap.sh" publish/osx-x64/bootstrap.sh
+
+echo "Publishing NodalisPLC for macOS ARM64..."
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r osx-arm64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/osx-arm64
+cp "NodalisPLC/bootstrap.sh" publish/osx-arm64/bootstrap.sh
+
+echo Publishing NodalisPLC for Linux ARM 32-bit...
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r linux-arm --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/linux-arm
+cp "NodalisPLC/bootstrap.sh" publish/linux-arm/bootstrap.sh
+
+echo Publishing NodalisPLC for Linux ARM 64-bit...
+dotnet publish NodalisPLC/NodalisPLC.csproj -c Release -r linux-arm64 --self-contained true /p:PublishSingleFile=true /p:Trim=true -o publish/linux-arm64
+cp "NodalisPLC/bootstrap.sh" publish/linux-arm64/bootstrap.sh
+
+echo "Build complete."

package/src/compilers/support/nodejs/IOClient.js

@@ -0,0 +1,110 @@
+let elapsed = () => {return Date.now();};
+let readBit = null;
+let writeBit = null;
+let readByte = null;
+let writeByte = null;
+let readWord = null;
+let writeWord = null;
+let readDWord = null;
+let writeDWord = null;
+
+export function setTiming(el){
+    elapsed = el;
+}
+
+export function setMemoryAccess(options){
+    const { readBitFunc, readByteFunc, readWordFunc, readDWordFunc, writeBitFunc, writeByteFunc, writeWordFunc, writeDWordFunc } = options;
+    readBit = readBitFunc;
+    readByte = readByteFunc;
+    readWord = readWordFunc;
+    readDWord = readDWordFunc;
+    writeBit = writeBitFunc;
+    writeByte = writeByteFunc;
+    writeWord = writeWordFunc;
+    writeDWord = writeDWordFunc;
+}
+
+export class IOMap {
+  constructor(jsonStr) {
+    const j = JSON.parse(jsonStr);
+    this.moduleID = j.ModuleID;
+    this.modulePort = j.ModulePort;
+    this.localAddress = j.InternalAddress;
+    this.remoteAddress = j.RemoteAddress;
+    this.width = parseInt(j.RemoteSize);
+    this.interval = parseInt(j.PollTime);
+    this.protocol = j.Protocol;
+    this.additionalProperties = j.AdditionalProperties || {};
+    this.direction = this.localAddress.includes("%Q") ? "Output" : "Input";
+    this.lastPoll = elapsed();
+    this.bit = -1;
+  }
+}
+
+export class IOClient {
+  constructor(protocol) {
+    this.protocol = protocol;
+    this.connected = false;
+    this.moduleID = "";
+    this.lastAttempt = 0;
+    this.mappings = [];
+  }
+
+  addMapping(map) {
+    if (!this.hasMapping(map.localAddress)) {
+      if (this.mappings.length === 0) {
+        this.moduleID = map.moduleID;
+      }
+      console.log(`Adding map for ${map.moduleID}:${map.modulePort}->${map.localAddress}`);
+      this.mappings.push(map);
+    }
+  }
+
+  hasMapping(localAddress) {
+    return this.mappings.some(m => m.localAddress === localAddress);
+  }
+
+  poll() {
+    if (this.connected) {
+      for (const map of this.mappings) {
+        try {
+          if (elapsed() - map.lastPoll > map.interval) {
+            map.lastPoll = elapsed();
+            if (map.direction === "Output") {
+              let val;
+              switch (map.width) {
+                case 1: val = readBit(map.localAddress); this.writeBit(map.remoteAddress, val ? 1 : 0); break;
+                case 8: val = readByte(map.localAddress); this.writeByte(map.remoteAddress, val); break;
+                case 16: val = readWord(map.localAddress); this.writeWord(map.remoteAddress, val); break;
+                case 32: val = readDWord(map.localAddress); this.writeDWord(map.remoteAddress, val); break;
+              }
+            } else if (map.direction === "Input") {
+              switch (map.width) {
+                case 1: this.readBit(map.remoteAddress, (bit) => writeBit(map.localAddress, !!bit)); break;
+                case 8: this.readByte(map.remoteAddress, (val) => writeByte(map.localAddress, val)); break;
+                case 16: this.readWord(map.remoteAddress, (val) => writeWord(map.localAddress, val)); break;
+                case 32: this.readDWord(map.remoteAddress, (val) => writeDWord(map.localAddress, val)); break;
+              }
+            }
+          }
+        } catch (e) {
+          console.error("IO Poll Error:", e);
+        }
+      }
+    } else if (elapsed() - this.lastAttempt >= 15000) {
+      this.lastAttempt = elapsed();
+      this.connect();
+    }
+  }
+
+  // Abstract methods
+  readBit(remote, callback) {}
+  writeBit(remote, value) {}
+  readByte(remote, callback) {}
+  writeByte(remote, value) {}
+  readWord(remote, callback) {}
+  writeWord(remote, value) {}
+  readDWord(remote, callback) {}
+  writeDWord(remote, value) {}
+  connect() {}
+}

package/src/compilers/support/nodejs/modbus.js

@@ -0,0 +1,115 @@
+// Copyright [2025] Nathan Skipper
+//
+// 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.
+
+
+/**
+ * @description Modbus Client for NodeJS
+ * @author Nathan Skipper, MTI
+ * @version 1.0.2
+ * @copyright Apache 2.0
+ */
+import * as Modbus from "jsmodbus";
+import * as net from "net";
+import {IOClient, IOMap} from "./IOClient.js";
+
+export class ModbusClient extends IOClient {
+  constructor() {
+    super('MODBUS-TCP');
+    this.socket = null;
+    this.client = null;
+  }
+
+  connect() {
+    try {
+      this.socket = new net.Socket();
+      this.client = new Modbus.client.TCP(this.socket);
+      const map = this.mappings[0];
+      const [host, port] = [map.moduleID, map.modulePort];
+      this.socket.connect({ host, port: parseInt(port) }, () => {
+        console.log('Modbus connected to', host, port);
+        this.connected = true;
+      });
+      this.socket.on('error', err => {
+        console.error('Modbus socket error:', err.message);
+        this.connected = false;
+      });
+      this.socket.on('close', () => {
+        this.connected = false;
+      });
+    } catch (e) {
+      console.error('Connect error:', e.message);
+      this.connected = false;
+    }
+  }
+
+  readBit(address, cb) {
+    const reg = parseInt(address);
+    this.client.readDiscreteInputs(reg, 1)
+      .then(res => 
+        cb(res.response._body.valuesAsArray[0]))
+      .catch(err => console.error('readBit error', err.message));
+  }
+
+  writeBit(address, value) {
+    const reg = parseInt(address);
+    this.client.writeSingleCoil(reg, value)
+      .catch(err => console.error('writeBit error', err.message));
+  }
+
+  readByte(address, cb) {
+    const reg = parseInt(address);
+    this.client.readHoldingRegisters(reg, 1)
+      .then(res => cb(res.response._body.valuesAsBuffer[1]))
+      .catch(err => console.error('readByte error', err.message));
+  }
+
+  writeByte(address, value) {
+    const reg = parseInt(address);
+    this.client.writeSingleRegister(reg, value)
+      .catch(err => console.error('writeByte error', err.message));
+  }
+
+  readWord(address, cb) {
+    const reg = parseInt(address);
+    this.client.readHoldingRegisters(reg, 1)
+      .then(res => cb(res.response._body.valuesAsBuffer.readUInt16BE(0)))
+      .catch(err => console.error('readWord error', err.message));
+  }
+
+  writeWord(address, value) {
+    const reg = parseInt(address);
+    this.client.writeSingleRegister(reg, value)
+      .catch(err => console.error('writeWord error', err.message));
+  }
+
+  readDWord(address, cb) {
+    const reg = parseInt(address);
+    this.client.readHoldingRegisters(reg, 2)
+      .then(res => {
+        const b = res.response._body.valuesAsBuffer;
+        const val = b.readUInt32BE(0);
+        cb(val);
+      })
+      .catch(err => console.error('readDWord error', err.message));
+  }
+
+  writeDWord(address, value) {
+    const reg = parseInt(address);
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(value);
+    this.client.writeMultipleRegisters(reg, buf)
+      .catch(err => console.error('writeDWord error', err.message));
+  }
+}
+