nodalis-compiler 1.0.0

package/src/compilers/support/jint/nodalis/NodalisEngine/NodalisEngine.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+    <PropertyGroup>
+     <LangVersion>latest</LangVersion>
+    </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Jint" Version="3.0.0-beta-2031" />
+    <PackageReference Include="System.Text.Json" Version="8.0.3" />
+    <PackageReference Include="OPCFoundation.NetStandard.Opc.Ua" Version="1.4.368.49" />
+  </ItemGroup>
+
+</Project>

package/src/compilers/support/jint/nodalis/NodalisEngine/OPCClient.cs

@@ -0,0 +1,172 @@
+// 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.
+
+/// <summary>
+/// OPC client implementation for .NET
+/// </summary>
+
+using Opc.Ua;
+using Opc.Ua.Client;
+using Opc.Ua.Configuration;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Nodalis
+{
+    public class OPCClient : IOClient
+    {
+        private Session? _session;
+        private ApplicationConfiguration? _config;
+
+        public OPCClient() : base("OPCUA") { }
+
+        public override void Connect()
+        {
+            Task.Run(async () =>
+            {
+                try
+                {
+                    var map = mappings[0];
+                    string endpointUrl = map.moduleID;
+
+                    _config = new ApplicationConfiguration
+                    {
+                        ApplicationName = "NodalisOPCUAClient",
+                        ApplicationType = ApplicationType.Client,
+                        SecurityConfiguration = new SecurityConfiguration
+                        {
+                            ApplicationCertificate = new CertificateIdentifier(),
+                            AutoAcceptUntrustedCertificates = true,
+                        },
+                        TransportConfigurations = new TransportConfigurationCollection(),
+                        TransportQuotas = new TransportQuotas { OperationTimeout = 15000 },
+                        ClientConfiguration = new ClientConfiguration { DefaultSessionTimeout = 60000 }
+                    };
+                    await _config.Validate(ApplicationType.Client);
+
+                    var app = new ApplicationInstance { ApplicationName = "NodalisOPCUAClient", ApplicationType = ApplicationType.Client, ApplicationConfiguration = _config };
+                    var endpoint = CoreClientUtils.SelectEndpoint(endpointUrl, false, 15000);
+                    var endpointConfig = EndpointConfiguration.Create(_config);
+                    var endpointDesc = new ConfiguredEndpoint(null, endpoint, endpointConfig);
+
+                    _session = await Session.Create(_config, endpointDesc, false, "", 60000, null, null);
+                    connected = true;
+                    Console.WriteLine("OPC UA connected.");
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine("OPC UA connection error: " + ex.Message);
+                    connected = false;
+                }
+            });
+        }
+
+        private NodeId GetNodeId(string remote) => new NodeId($"s={remote}", 1);
+
+        public override bool ReadBit(string address, out int result)
+        {
+            return ReadValue(address, out result, BuiltInType.Boolean);
+        }
+
+        public override bool WriteBit(string address, int value)
+        {
+            return WriteVal(address, value != 0, BuiltInType.Boolean);
+        }
+
+        public override bool ReadByte(string address, out byte result)
+        {
+            return ReadValue(address, out result, BuiltInType.Byte);
+        }
+
+        public override bool WriteByte(string address, byte value)
+        {
+            return WriteVal(address, value, BuiltInType.Byte);
+        }
+
+        public override bool ReadWord(string address, out ushort result)
+        {
+            return ReadValue(address, out result, BuiltInType.UInt16);
+        }
+
+        public override bool WriteWord(string address, ushort value)
+        {
+            return WriteVal(address, value, BuiltInType.UInt16);
+        }
+
+        public override bool ReadDWord(string address, out uint result)
+        {
+            return ReadValue(address, out result, BuiltInType.UInt32);
+        }
+
+        public override bool WriteDWord(string address, uint value)
+        {
+            return WriteVal(address, value, BuiltInType.UInt32);
+        }
+
+        private bool ReadValue<T>(string address, out T result, BuiltInType type)
+        {
+            result = default!;
+            if (!connected || _session == null) return false;
+
+            try
+            {
+                var nodeId = GetNodeId(address);
+                var value = _session.ReadValue(nodeId);
+                if (value.Value is T cast)
+                {
+                    result = cast;
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Read error [{address}]: {ex.Message}");
+            }
+            return false;
+        }
+
+        private bool WriteVal<T>(string address, T value, BuiltInType type)
+        {
+            if (!connected || this._session == null) return false;
+
+            try
+            {
+                var writeValue = new WriteValue
+                {
+                    NodeId = GetNodeId(address),
+                    AttributeId = Attributes.Value,
+                    Value = new DataValue(new Variant(value))
+                };
+
+                writeValue.Value.StatusCode = StatusCodes.Good;
+                writeValue.Value.ServerTimestamp = DateTime.MinValue;
+                writeValue.Value.SourceTimestamp = DateTime.MinValue;
+
+                var writeResults = _session.Write(null, new WriteValueCollection { writeValue }, out StatusCodeCollection statusCodes, out DiagnosticInfoCollection diag);
+                if (StatusCode.IsBad(statusCodes[0]))
+                {
+                    Console.WriteLine($"Write failed for {address}: {statusCodes[0]}");
+                    return false;
+                }
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Write error [{address}]: {ex.Message}");
+            }
+            return false;
+        }
+    }
+}

package/src/compilers/support/jint/nodalis/NodalisEngine/OPCServer.cs

@@ -0,0 +1,275 @@
+// 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.
+
+/// <summary>
+/// OPC Server implementation for .NET
+/// </summary>
+/// 
+using Opc.Ua;
+using Opc.Ua.Configuration;
+using Opc.Ua.Server;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Nodalis
+{
+    public class OPCServer
+    {
+        private ApplicationInstance _application;
+        private NodalisEngine _engine;
+        private Dictionary<string, string> _addressMap = new();
+        private NodalisNodeManager? _nodeManager;
+        private StandardServer? _server;
+
+        public OPCServer(NodalisEngine engine)
+        {
+            _engine = engine;
+        }
+
+        public void MapVariable(string varName, string address)
+        {
+            _addressMap[varName] = address;
+        }
+
+        public async Task StartAsync()
+        {
+            _application = new ApplicationInstance
+            {
+                ApplicationName = "NodalisServer",
+                ApplicationType = ApplicationType.Server,
+                ConfigSectionName = "NodalisServer"
+            };
+
+            var config = new ApplicationConfiguration
+            {
+                ApplicationName = "NodalisServer",
+                ApplicationType = ApplicationType.Server,
+                ApplicationUri = "urn:localhost:NodalisServer",
+                ServerConfiguration = new ServerConfiguration
+                {
+                    BaseAddresses = { "opc.tcp://localhost:4840/UA/Nodalis" }
+                },
+                TransportQuotas = new TransportQuotas { OperationTimeout = 15000 },
+                SecurityConfiguration = new SecurityConfiguration
+                {
+                    ApplicationCertificate = new CertificateIdentifier(),
+                    AutoAcceptUntrustedCertificates = true
+                },
+                CertificateValidator = new CertificateValidator(),
+                //DiagnosticsConfiguration = new DiagnosticsConfiguration { Enabled = true },
+                Extensions = new XmlElementCollection()
+            };
+
+            await config.Validate(ApplicationType.Server);
+
+            _application.ApplicationConfiguration = config;
+
+            _server = new NodalisServer(_engine, _addressMap);
+            _application.Start(_server);
+
+            Console.WriteLine("OPC UA Server started at: opc.tcp://localhost:4840/UA/Nodalis");
+        }
+
+        public async Task StopAsync()
+        {
+            if (_server != null)
+            {
+                 _server.Stop();
+                Console.WriteLine("OPC UA Server stopped.");
+            }
+        }
+
+        private class NodalisServer : StandardServer
+        {
+            private readonly NodalisEngine _engine;
+            private readonly Dictionary<string, string> _map;
+
+            public NodalisServer(NodalisEngine engine, Dictionary<string, string> map)
+            {
+                _engine = engine;
+                _map = map;
+            }
+
+            protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration config)
+            {
+                var nodeManagers = new List<INodeManager>
+                {
+                    new NodalisNodeManager(server, config, _engine, _map)
+                };
+
+                return new MasterNodeManager(server, config, null, nodeManagers.ToArray());
+            }
+        }
+
+        private class NodalisNodeManager : CustomNodeManager2
+        {
+            private readonly NodalisEngine _engine;
+            private readonly Dictionary<string, string> _addressMap;
+
+            public NodalisNodeManager(IServerInternal server, ApplicationConfiguration config, NodalisEngine engine, Dictionary<string, string> map)
+                : base(server, config, "http://nodalis.local/UA/")
+            {
+                _engine = engine;
+                _addressMap = map;
+                SystemContext.NodeIdFactory = this;
+            }
+
+            private FolderState CreateFolder(
+                NodeState parent,
+                string path,
+                string name,
+                IDictionary<NodeId, IList<IReference>> externalReferences,
+                ushort namespaceIndex)
+            {
+                var folder = new FolderState(parent)
+                {
+                    SymbolicName = name,
+                    ReferenceTypeId = ReferenceTypeIds.Organizes,
+                    TypeDefinitionId = ObjectTypeIds.FolderType,
+                    NodeId = new NodeId(path, namespaceIndex),
+                    BrowseName = new QualifiedName(name, namespaceIndex),
+                    DisplayName = name,
+                    EventNotifier = EventNotifiers.None
+                };
+
+                if (externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out var references))
+                    references.Add(new NodeStateReference(ReferenceTypeIds.Organizes, false, folder.NodeId));
+                else
+                    externalReferences[ObjectIds.ObjectsFolder] = new List<IReference>
+                    {
+                        new NodeStateReference(ReferenceTypeIds.Organizes, false, folder.NodeId)
+                    };
+
+                AddPredefinedNode(SystemContext, folder);
+                return folder;
+            }
+
+            private ServiceResult ReadValueHandler(
+                ISystemContext context,
+                NodeState node,
+                NumericRange indexRange,
+                QualifiedName name,
+                ref object value,
+                ref StatusCode statusCode,
+                ref DateTime timestamp)
+            {
+                if (node is BaseDataVariableState variable &&
+                    _addressMap.TryGetValue(variable.SymbolicName, out var addr))
+                {
+                    try
+                    {
+                        value = ReadFromEngine(addr);
+                        statusCode = StatusCodes.Good;
+                        timestamp = DateTime.UtcNow;
+                        return ServiceResult.Good;
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine($"Read error for {addr}: {ex.Message}");
+                        return StatusCodes.BadUnexpectedError;
+                    }
+                }
+
+                return StatusCodes.BadNodeIdUnknown;
+            }
+
+            public override void CreateAddressSpace(IDictionary<NodeId, IList<IReference>> externalReferences)
+            {
+                var folder = CreateFolder(
+                    null,
+                    "Nodalis",
+                    "Nodalis",
+                    externalReferences,
+                    NamespaceIndex
+                );
+
+                foreach (var entry in _addressMap)
+                {
+                    string name = entry.Key;
+                    string addr = entry.Value;
+                    var dataType = GetDataType(addr);
+
+                    var variable = new BaseDataVariableState(folder)
+                    {
+                        SymbolicName = name,
+                        NodeId = new NodeId(name, NamespaceIndex),
+                        BrowseName = new QualifiedName(name, NamespaceIndex),
+                        DisplayName = name,
+                        DataType = dataType,
+                        TypeDefinitionId = VariableTypeIds.BaseDataVariableType,
+                        ValueRank = ValueRanks.Scalar,
+                        AccessLevel = AccessLevels.CurrentReadOrWrite,
+                        UserAccessLevel = AccessLevels.CurrentReadOrWrite
+                    };
+
+                    // Define read delegate
+                    variable.OnReadValue = ReadValueHandler;
+
+
+                    // Define write delegate
+                    variable.OnSimpleWriteValue = (ISystemContext context, NodeState node, ref object val) =>
+                    {
+                        try
+                        {
+                            WriteToEngine(addr, val);
+                            return ServiceResult.Good;
+                        }
+                        catch (Exception ex)
+                        {
+                            Console.WriteLine($"Write error for {addr}: {ex.Message}");
+                            return StatusCodes.BadUnexpectedError;
+                        }
+                    };
+
+                    AddPredefinedNode(SystemContext, variable);
+                }
+            }
+
+            private object ReadFromEngine(string address)
+            {
+                if (address.Contains(".")) return _engine.ReadBit(address);
+                else if (address.Contains("X")) return _engine.ReadByte(address);
+                else if (address.Contains("W")) return _engine.ReadWord(address);
+                else if (address.Contains("D")) return _engine.ReadDWord(address);
+                return false;
+            }
+
+            private void WriteToEngine(string address, object value)
+            {
+                switch (value)
+                {
+                    case bool b: _engine.WriteBit(address, b); break;
+                    case byte bt: _engine.WriteByte(address, bt); break;
+                    case ushort us: _engine.WriteWord(address, us); break;
+                    case uint ui: _engine.WriteDWord(address, ui); break;
+                    default: throw new InvalidCastException($"Unsupported value type: {value?.GetType()?.Name}");
+                }
+            }
+
+
+            private NodeId GetDataType(string address)
+            {
+                if (address.Contains(".")) return DataTypeIds.Boolean;
+                else if (address.Contains("X")) return DataTypeIds.Byte;
+                else if (address.Contains("W")) return DataTypeIds.UInt16;
+                else if (address.Contains("D")) return DataTypeIds.UInt32;
+                return DataTypeIds.Boolean;
+            }
+
+            
+           
+        }
+    }
+}

package/src/compilers/support/jint/nodalis/NodalisPLC/NodalisPLC.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <RuntimeIdentifiers>win-x64;linux-x64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Jint" Version="3.0.0-beta-2031" />
+    <PackageReference Include="System.Text.Json" Version="8.0.3" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\\NodalisEngine\\NodalisEngine.csproj" />
+  </ItemGroup>
+
+</Project>

package/src/compilers/support/jint/nodalis/NodalisPLC/Program.cs

@@ -0,0 +1,197 @@
+// 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.
+
+/// <summary>
+/// Nodalis PLC .NET Console app
+/// </summary>
+
+using System;
+using System.IO;
+using System.Threading;
+using Jint;
+using Jint.Runtime;
+using Nodalis;
+using System.Text.RegularExpressions;
+
+
+class ProgramEngine : NodalisEngine
+{
+    private static readonly ulong[,] MEMORY = new ulong[64, 16];
+
+    public override bool ReadBit(string address)
+    {
+        var mem = ParseAddress(address);
+        return (GetMemoryCell(mem[0], mem[2]) & (1UL << (mem[3] % 64))) != 0;
+    }
+
+    public override byte ReadByte(string address)
+    {
+        var mem = ParseAddress(address);
+        return (byte)((GetMemoryCell(mem[0], mem[2]) >> (mem[3] % 64)) & 0xFF);
+    }
+
+    public override ushort ReadWord(string address)
+    {
+        var mem = ParseAddress(address);
+        return (ushort)((GetMemoryCell(mem[0], mem[2]) >> (mem[3] % 64)) & 0xFFFF);
+    }
+
+    public override uint ReadDWord(string address)
+    {
+        var mem = ParseAddress(address);
+        return (uint)((GetMemoryCell(mem[0], mem[2])  >> (mem[3] % 64)) & 0xFFFFFFFF);
+    }
+
+    public override void WriteBit(string address, bool value)
+    {
+        var mem = ParseAddress(address);
+        if (value)
+            GetMemoryCell(mem[0], mem[2]) |= (1UL << (mem[3] % 64));
+        else
+            GetMemoryCell(mem[0], mem[2]) &= ~(1UL << (mem[3] % 64));
+    }
+
+    public override void WriteByte(string address, byte value)
+    {
+        WriteGeneric(address, value, 8);
+    }
+
+    public override void WriteWord(string address, ushort value)
+    {
+        WriteGeneric(address, value, 16);
+    }
+
+    public override void WriteDWord(string address, uint value)
+    {
+        WriteGeneric(address, value, 32);
+    }
+
+    public enum MemorySpace
+    {
+        I = 0,
+        Q = 1,
+        M = 2
+    }
+
+    public static ref ulong GetMemoryCell(int space, int addr)
+    {
+        int r = -1, c = 0, b = 0;
+        switch (space)
+        {
+            case 1: // Q
+                r = (addr * 8) / 64;
+                c = 1;
+                b = addr % 8;
+                break;
+            case 0: // I
+                r = (addr * 8) / 64;
+                c = 0;
+                b = addr % 8;
+                break;
+            case 2: // M
+                r = (addr * 8) / (64 * 14);
+                c = (addr / 112) + 2;
+                b = addr % 8;
+                break;
+        }
+
+        if (r >= 0 && r < 64 && c >= 0 && c < 16)
+        {
+            return ref MEMORY[r, c];
+        }
+        throw new ArgumentOutOfRangeException();      
+    }
+
+    public static List<int> ParseAddress(string address)
+    {
+        var pattern = new Regex(@"%([IQM])([XBWDL])(\d+)(?:\.(\d+))?", RegexOptions.IgnoreCase);
+        var match = pattern.Match(address);
+
+        if (!match.Success)
+            throw new ArgumentException($"Invalid address format: {address}");
+
+        string space = match.Groups[1].Value.ToUpperInvariant();  // I, Q, M
+        string type = match.Groups[2].Value.ToUpperInvariant();   // X, W, D, etc.
+        string index = match.Groups[3].Value;                     // 0, 1, ...
+        string bit = match.Groups[4].Success ? match.Groups[4].Value : null;
+
+        int ispace = space switch
+        {
+            "M" => (int)MemorySpace.M,
+            "Q" => (int)MemorySpace.Q,
+            "I" => (int)MemorySpace.I,
+            _ => throw new ArgumentException($"Unknown memory space: {space}")
+        };
+
+        int width = type switch
+        {
+            "X" => 8,
+            "W" => 16,
+            "D" => 32,
+            _ => throw new ArgumentException($"Unknown type: {type}")
+        };
+
+        int addr = int.Parse(index);
+        int ibit = bit != null ? int.Parse(bit) : -1;
+
+        return new List<int> { ispace, width, addr, ibit };
+    }
+
+    private void WriteGeneric(string address, ulong value, int width)
+    {
+        var mem = ParseAddress(address);
+        ulong mask = (1UL << width) - 1;
+        ulong shiftedMask = mask << (mem[3] % 64);
+        ulong location = GetMemoryCell(mem[0], mem[2]);
+        location &= ~shiftedMask;
+        location |= (value & mask) << (mem[3] % 64);
+    }
+}
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        if (args.Length < 1)
+        {
+            Console.WriteLine("Usage: NodalisRuntime <jsfile>");
+            return;
+        }
+
+        var engine = new ProgramEngine();
+        long lastExec = engine.ElapsedMilliseconds;
+        string jsCode = File.ReadAllText(args[0]);
+        try
+        {
+            engine.Load(jsCode);
+            engine.Setup();
+            while (true)
+            {
+                engine.SuperviseIO();
+                if (engine.ElapsedMilliseconds - lastExec >= 100)
+                {
+                    lastExec = engine.ElapsedMilliseconds;
+                    engine.Execute();
+                }
+                Thread.Sleep(1);
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.ToString());
+        }
+        
+    }
+}
+

package/src/compilers/support/jint/nodalis/NodalisPLC/bootstrap.bat

@@ -0,0 +1,5 @@
+@echo off
+set SCRIPT={script}  REM to be replaced by JSCompiler
+
+set DIR=%~dp0
+"%DIR%NodalisPLC.exe" %SCRIPT%

package/src/compilers/support/jint/nodalis/NodalisPLC/bootstrap.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+SCRIPT="{script}" # to be replaced by JSCompiler
+
+DIR="$(cd "$(dirname "$0")" && pwd)"
+"$DIR/NodalisPLC" "$SCRIPT"