nodalis-compiler 1.0.27 → 1.0.28

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.0.28] 2026-03-23
+- Improved support for Arduino, fully tested Arduino compile -> program stack.
+- Added a command line interface for nodalis on Arduino to use in setting IP, read/write of bits, and map info.
+
 ## [1.0.27] 2026-03-20
 - Corrected issues with SSH Programmer.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodalis-compiler",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "description": "Compiles IEC-61131-3/10 languages into code that can be used as a PLC on multiple platforms.",
   "icon": "nodalis.png",
   "main": "src/nodalis.js",

package/src/compilers/ArduinoCompiler.js

@@ -219,20 +219,62 @@ export class ArduinoCompiler extends Compiler {
 
         const inoCode = `#include "nodalis.h"
 #include <stdint.h>
+#include <Ethernet.h>
 #include "modbus.h"
+#include "network_config.h"
 
 NodalisModbusTcpServer modbusServer;
+IPAddress localIp;
+
+#if defined(LEDR)
+const int NODALIS_HEARTBEAT_LED_PIN = LEDR;
+#elif defined(LED_BUILTIN)
+const int NODALIS_HEARTBEAT_LED_PIN = LED_BUILTIN;
+#else
+const int NODALIS_HEARTBEAT_LED_PIN = -1;
+#endif
+
+void nodalisHeartbeatTask() {
+  if (NODALIS_HEARTBEAT_LED_PIN < 0) {
+    return;
+  }
+
+  static uint64_t lastToggle = 0;
+  static bool ledState = false;
+  const uint64_t now = elapsed();
+  if (now - lastToggle < 500) {
+    return;
+  }
+
+  lastToggle = now;
+  ledState = !ledState;
+  digitalWrite(NODALIS_HEARTBEAT_LED_PIN, ledState ? HIGH : LOW);
+}
 ${transpiledCode}
 
 void setup() {
+  Serial.begin(115200);
+  nodalisLogInfo("Setup starting");
+  if (NODALIS_HEARTBEAT_LED_PIN >= 0) {
+    pinMode(NODALIS_HEARTBEAT_LED_PIN, OUTPUT);
+    digitalWrite(NODALIS_HEARTBEAT_LED_PIN, LOW);
+  }
+  localIp = nodalisLoadIpAddress();
+  nodalisBeginEthernet(localIp);
+  nodalisLogInfo("Ethernet initialized");
   ${globals.join('\n')}
-  modbusServer.start();
+  if (!modbusServer.start()) {
+    nodalisLogError("Modbus server start failed");
+  }
   ${mapCode}
+  nodalisLogInfo("Setup complete");
 }
 
 void loop() {
+  nodalisPollSerialIpConfig(localIp);
   modbusServer.poll();
   superviseIO();
+  nodalisHeartbeatTask();
   ${taskCode}
   delay(1);
   PROGRAM_COUNT++;
@@ -254,6 +296,8 @@ void loop() {
         fs.cpSync(path.join(supportDir, 'modbus.cpp'), path.join(outputPath, 'modbus.cpp'), { force: true });
         fs.cpSync(path.join(supportDir, 'gpio.h'), path.join(outputPath, 'gpio.h'), { force: true });
         fs.cpSync(path.join(supportDir, 'gpio.cpp'), path.join(outputPath, 'gpio.cpp'), { force: true });
+        fs.cpSync(path.join(supportDir, 'network_config.h'), path.join(outputPath, 'network_config.h'), { force: true });
+        fs.cpSync(path.join(supportDir, 'network_config.cpp'), path.join(outputPath, 'network_config.cpp'), { force: true });
         fs.cpSync(path.join(supportDir, 'json.hpp'), path.join(outputPath, 'json.hpp'), { force: true });
 
         if (this.isExecutableOutput()) {

package/src/compilers/support/arduino/gpio.cpp

@@ -19,6 +19,7 @@ void NodalisGPIOClient::onMappingAdded(const IOMap &map)
     uint8_t startPin = 0;
     if (!parsePin(map.remoteAddress, startPin))
     {
+        logErrorThrottled("Invalid GPIO pin mapping " + describeMapping(map));
         return;
     }
 

package/src/compilers/support/arduino/modbus.cpp

@@ -55,7 +55,7 @@ ModbusResponse NodalisModbusServer::handleRequest(const ModbusRequest &request)
 NodalisModbusClient::NodalisModbusClient(const std::string &ip, uint16_t port, uint8_t unitId)
     : IOClient("MODBUS-TCP"),
       ip(ip),
-      port(port == 0 ? 502 : port),
+      port(port),
       modbusTcpClient(tcpClient),
       deviceAddress(unitId == 0 ? 1 : unitId),
       serverResolved(false)
@@ -63,6 +63,10 @@ NodalisModbusClient::NodalisModbusClient(const std::string &ip, uint16_t port, u
     if (!ip.empty())
     {
         serverResolved = parseIp(ip, serverIp);
+        if (!serverResolved)
+        {
+            logErrorThrottled("Invalid remote IP " + ip);
+        }
     }
 }
 
@@ -109,7 +113,7 @@ void NodalisModbusClient::onMappingAdded(const IOMap &map)
     {
         ip = map.moduleID;
     }
-    if (port == 0 && !map.modulePort.empty())
+    if (!map.modulePort.empty())
     {
         port = static_cast<uint16_t>(std::atoi(map.modulePort.c_str()));
     }
@@ -126,6 +130,10 @@ void NodalisModbusClient::connect()
     if (!ip.empty() && !serverResolved)
     {
         serverResolved = parseIp(ip, serverIp);
+        if (!serverResolved)
+        {
+            logErrorThrottled("Could not parse target IP " + ip);
+        }
     }
     connected = ensureConnected();
 }
@@ -133,7 +141,7 @@ void NodalisModbusClient::connect()
 bool NodalisModbusClient::connectTCP(const std::string &newIp, uint16_t newPort)
 {
     ip = newIp;
-    port = (newPort == 0) ? 502 : newPort;
+    port = newPort;
     serverResolved = parseIp(ip, serverIp);
     connected = ensureConnected();
     return connected;
@@ -143,13 +151,20 @@ bool NodalisModbusClient::ensureConnected()
 {
     if (!serverResolved)
     {
+        logErrorThrottled("Server IP is unresolved");
         return false;
     }
     if (modbusTcpClient.connected())
     {
         return true;
     }
-    return modbusTcpClient.begin(serverIp, port) == 1;
+    const uint16_t effectivePort = (port == 0) ? 502 : port;
+    const bool started = modbusTcpClient.begin(serverIp, effectivePort) == 1;
+    if (!started)
+    {
+        logErrorThrottled("TCP connect failed to " + ip + ":" + std::to_string(effectivePort));
+    }
+    return started;
 }
 
 void NodalisModbusClient::disconnect()
@@ -183,15 +198,16 @@ bool NodalisModbusClient::sendRequest(const ModbusRequest &request, ModbusRespon
     return false;
 }
 
-uint16_t NodalisModbusClient::parseRemoteAddress(const std::string &remote) const
+bool NodalisModbusClient::parseRemoteAddress(const std::string &remote, uint16_t &address) const
 {
     char *endPtr = nullptr;
     const long parsed = std::strtol(remote.c_str(), &endPtr, 10);
-    if (endPtr == remote.c_str() || parsed < 0)
+    if (endPtr == remote.c_str() || *endPtr != '\0' || parsed < 0 || parsed > 65535)
     {
-        return 0;
+        return false;
     }
-    return static_cast<uint16_t>(parsed & 0xFFFF);
+    address = static_cast<uint16_t>(parsed & 0xFFFF);
+    return true;
 }
 
 bool NodalisModbusClient::readBit(const std::string &remote, int &result)
@@ -200,10 +216,17 @@ bool NodalisModbusClient::readBit(const std::string &remote, int &result)
     {
         return false;
     }
-    const uint16_t addr = parseRemoteAddress(remote);
-    const long val = modbusTcpClient.coilRead(deviceAddress, addr);
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote bit address \"" + remote + "\"");
+        return false;
+    }
+    const long val = modbusTcpClient.discreteInputRead(deviceAddress, addr);
     if (val < 0)
     {
+        logErrorThrottled("Discrete input read failed remote=\"" + remote + "\" parsed=" + std::to_string(addr) +
+                          " unit=" + std::to_string(deviceAddress) + ": " + modbusTcpClient.lastError());
         return false;
     }
     result = (val == 0) ? 0 : 1;
@@ -216,8 +239,20 @@ bool NodalisModbusClient::writeBit(const std::string &remote, int value)
     {
         return false;
     }
-    const uint16_t addr = parseRemoteAddress(remote);
-    return modbusTcpClient.coilWrite(deviceAddress, addr, value != 0) == 1;
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote bit address \"" + remote + "\"");
+        return false;
+    }
+    const int rc = modbusTcpClient.coilWrite(deviceAddress, addr, value != 0);
+    if (rc != 1)
+    {
+        logErrorThrottled("Coil write failed remote=\"" + remote + "\" parsed=" + std::to_string(addr) +
+                          " unit=" + std::to_string(deviceAddress) + ": " + modbusTcpClient.lastError());
+        return false;
+    }
+    return true;
 }
 
 bool NodalisModbusClient::readByte(const std::string &remote, uint8_t &result)
@@ -242,10 +277,17 @@ bool NodalisModbusClient::readWord(const std::string &remote, uint16_t &result)
     {
         return false;
     }
-    const uint16_t addr = parseRemoteAddress(remote);
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote register address \"" + remote + "\"");
+        return false;
+    }
     const long val = modbusTcpClient.holdingRegisterRead(deviceAddress, addr);
     if (val < 0)
     {
+        logErrorThrottled("Holding register read failed remote=\"" + remote + "\" parsed=" + std::to_string(addr) +
+                          " unit=" + std::to_string(deviceAddress) + ": " + modbusTcpClient.lastError());
         return false;
     }
     result = static_cast<uint16_t>(val & 0xFFFF);
@@ -258,15 +300,32 @@ bool NodalisModbusClient::writeWord(const std::string &remote, uint16_t value)
     {
         return false;
     }
-    const uint16_t addr = parseRemoteAddress(remote);
-    return modbusTcpClient.holdingRegisterWrite(deviceAddress, addr, value) == 1;
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote register address \"" + remote + "\"");
+        return false;
+    }
+    const int rc = modbusTcpClient.holdingRegisterWrite(deviceAddress, addr, value);
+    if (rc != 1)
+    {
+        logErrorThrottled("Holding register write failed remote=\"" + remote + "\" parsed=" + std::to_string(addr) +
+                          " unit=" + std::to_string(deviceAddress) + ": " + modbusTcpClient.lastError());
+        return false;
+    }
+    return true;
 }
 
 bool NodalisModbusClient::readDWord(const std::string &remote, uint32_t &result)
 {
     uint16_t hi = 0;
     uint16_t lo = 0;
-    const uint16_t addr = parseRemoteAddress(remote);
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote register address \"" + remote + "\"");
+        return false;
+    }
 
     if (!readWord(std::to_string(addr), hi))
     {
@@ -283,7 +342,12 @@ bool NodalisModbusClient::readDWord(const std::string &remote, uint32_t &result)
 
 bool NodalisModbusClient::writeDWord(const std::string &remote, uint32_t value)
 {
-    const uint16_t addr = parseRemoteAddress(remote);
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote register address \"" + remote + "\"");
+        return false;
+    }
     const uint16_t hi = static_cast<uint16_t>((value >> 16) & 0xFFFF);
     const uint16_t lo = static_cast<uint16_t>(value & 0xFFFF);
 
@@ -296,7 +360,12 @@ bool NodalisModbusClient::writeDWord(const std::string &remote, uint32_t value)
 
 bool NodalisModbusClient::readLWord(const std::string &remote, uint64_t &result)
 {
-    const uint16_t addr = parseRemoteAddress(remote);
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote register address \"" + remote + "\"");
+        return false;
+    }
     uint16_t regs[4] = {0, 0, 0, 0};
 
     for (uint16_t i = 0; i < 4; ++i)
@@ -316,7 +385,12 @@ bool NodalisModbusClient::readLWord(const std::string &remote, uint64_t &result)
 
 bool NodalisModbusClient::writeLWord(const std::string &remote, uint64_t value)
 {
-    const uint16_t addr = parseRemoteAddress(remote);
+    uint16_t addr = 0;
+    if (!parseRemoteAddress(remote, addr))
+    {
+        logErrorThrottled("Invalid remote register address \"" + remote + "\"");
+        return false;
+    }
     const uint16_t regs[4] = {
         static_cast<uint16_t>((value >> 48) & 0xFFFF),
         static_cast<uint16_t>((value >> 32) & 0xFFFF),
@@ -404,6 +478,7 @@ bool NodalisModbusTcpServer::start(uint8_t serverId)
 
     if (modbusServer.begin(serverId) != 1)
     {
+        nodalisLogError("Failed to start Modbus TCP server");
         return false;
     }
 
@@ -418,6 +493,7 @@ bool NodalisModbusTcpServer::start(uint8_t serverId)
 
     tcpServer.begin();
     started = true;
+    nodalisLogInfo("Modbus TCP server started");
 
     for (size_t i = 0; i < globals.size(); ++i)
     {
@@ -441,6 +517,7 @@ void NodalisModbusTcpServer::poll()
     EthernetClient client = tcpServer.available();
     if (client)
     {
+        nodalisLogInfo("Accepted Modbus TCP client");
         modbusServer.accept(client);
     }
     modbusServer.poll();

package/src/compilers/support/arduino/modbus.h

@@ -108,7 +108,7 @@ private:
     uint8_t deviceAddress;
     bool serverResolved;
 
-    uint16_t parseRemoteAddress(const std::string &remote) const;
+    bool parseRemoteAddress(const std::string &remote, uint16_t &address) const;
     uint8_t parseUnitId(const IOMap &map) const;
     bool ensureConnected();
     bool parseIp(const std::string &value, IPAddress &out) const;

package/src/compilers/support/arduino/network_config.cpp

@@ -0,0 +1,502 @@
+#include "network_config.h"
+#include "nodalis.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#if defined(ARDUINO_ARCH_MBED) && __has_include(<BlockDevice.h>) && __has_include(<MBRBlockDevice.h>) && __has_include(<LittleFileSystem.h>) && __has_include(<FATFileSystem.h>)
+#include <BlockDevice.h>
+#include <MBRBlockDevice.h>
+#include <LittleFileSystem.h>
+#include <FATFileSystem.h>
+#define NODALIS_HAS_OPTA_FS 1
+#else
+#define NODALIS_HAS_OPTA_FS 0
+#endif
+
+#if defined(ARDUINO_ARCH_MBED) && __has_include(<kvstore_global_api.h>)
+#include <kvstore_global_api.h>
+#define NODALIS_HAS_KVSTORE 1
+#else
+#define NODALIS_HAS_KVSTORE 0
+#endif
+
+#if !NODALIS_HAS_KVSTORE && __has_include(<EEPROM.h>)
+#include <EEPROM.h>
+#define NODALIS_HAS_EEPROM 1
+#else
+#define NODALIS_HAS_EEPROM 0
+#endif
+
+namespace
+{
+const uint8_t DEFAULT_MAC[6] = {0x02, 0x4E, 0x4F, 0x44, 0x41, 0x4C};
+const int EEPROM_BASE = 0;
+const uint8_t EEPROM_MAGIC_0 = 0x4E;
+const uint8_t EEPROM_MAGIC_1 = 0x49;
+const uint8_t EEPROM_VERSION = 0x01;
+const size_t SERIAL_BUFFER_LIMIT = 48;
+const char *KVSTORE_IP_KEY = "/kv/nodalis_ip";
+const char *USERDATA_IP_PATH = "/user/nodalis_ip.bin";
+
+String serialBuffer;
+
+bool nodalisIsBitAddress(const String &address)
+{
+    const std::vector<int> parts = parseAddress(std::string(address.c_str()));
+    return parts.size() == 4 && parts[0] >= 0 && parts[2] >= 0 && parts[3] >= 0;
+}
+
+void nodalisPrintBitValue(const String &address)
+{
+    Serial.print(address);
+    Serial.print(" = ");
+    Serial.println(readBit(std::string(address.c_str())) ? 1 : 0);
+}
+
+bool nodalisHandleBitCommand(const String &command, const String &upper)
+{
+    if (upper == "MAPS")
+    {
+        nodalisDumpMappings();
+        return true;
+    }
+
+    if (upper.startsWith("READBIT "))
+    {
+        String address = command.substring(8);
+        address.trim();
+        if (!nodalisIsBitAddress(address))
+        {
+            Serial.println("Invalid bit address.");
+            return true;
+        }
+        nodalisPrintBitValue(address);
+        return true;
+    }
+
+    if (upper.startsWith("WRITEBIT "))
+    {
+        const int splitIndex = command.lastIndexOf(' ');
+        if (splitIndex <= 8)
+        {
+            Serial.println("Usage: WRITEBIT %IX0.0 1");
+            return true;
+        }
+
+        String address = command.substring(9, splitIndex);
+        String valueText = command.substring(splitIndex + 1);
+        address.trim();
+        valueText.trim();
+
+        if (!nodalisIsBitAddress(address) || (valueText != "0" && valueText != "1"))
+        {
+            Serial.println("Usage: WRITEBIT %IX0.0 1");
+            return true;
+        }
+
+        writeBit(std::string(address.c_str()), valueText == "1");
+        nodalisPrintBitValue(address);
+        return true;
+    }
+
+    return false;
+}
+
+bool nodalisParseIpString(const String &input, IPAddress &ip)
+{
+    unsigned int octets[4] = {0, 0, 0, 0};
+    int octetIndex = 0;
+    unsigned int current = 0;
+    bool hasDigit = false;
+
+    for (size_t i = 0; i < input.length(); ++i)
+    {
+        const char ch = input.charAt(i);
+        if (ch >= '0' && ch <= '9')
+        {
+            hasDigit = true;
+            current = (current * 10U) + static_cast<unsigned int>(ch - '0');
+            if (current > 255U)
+            {
+                return false;
+            }
+            continue;
+        }
+
+        if (ch != '.' || !hasDigit || octetIndex >= 3)
+        {
+            return false;
+        }
+
+        octets[octetIndex++] = current;
+        current = 0;
+        hasDigit = false;
+    }
+
+    if (!hasDigit || octetIndex != 3)
+    {
+        return false;
+    }
+
+    octets[octetIndex] = current;
+    ip = IPAddress(octets[0], octets[1], octets[2], octets[3]);
+    return true;
+}
+
+String nodalisNormalizeCommand(String value)
+{
+    value.trim();
+    while (value.startsWith(" "))
+    {
+        value.remove(0, 1);
+    }
+    return value;
+}
+
+uint8_t nodalisChecksum(const IPAddress &ip)
+{
+    return static_cast<uint8_t>(ip[0] ^ ip[1] ^ ip[2] ^ ip[3] ^ EEPROM_VERSION);
+}
+
+#if NODALIS_HAS_OPTA_FS || NODALIS_HAS_KVSTORE
+struct PersistentIpRecord
+{
+    uint8_t magic0;
+    uint8_t magic1;
+    uint8_t version;
+    uint8_t ip[4];
+    uint8_t checksum;
+};
+#endif
+
+#if NODALIS_HAS_OPTA_FS
+template <typename FileSystemType>
+bool nodalisReadRecordFromFileSystem(mbed::MBRBlockDevice &userData, FileSystemType &fs, PersistentIpRecord &record)
+{
+    if (fs.mount(&userData) != 0)
+    {
+        return false;
+    }
+
+    bool success = false;
+    FILE *fp = fopen(USERDATA_IP_PATH, "rb");
+    if (fp)
+    {
+        const size_t readCount = fread(&record, sizeof(record), 1, fp);
+        fclose(fp);
+        success = (readCount == 1);
+    }
+    fs.unmount();
+    return success;
+}
+
+template <typename FileSystemType>
+bool nodalisWriteRecordToFileSystem(mbed::MBRBlockDevice &userData, FileSystemType &fs, const PersistentIpRecord &record)
+{
+    if (fs.mount(&userData) != 0)
+    {
+        return false;
+    }
+
+    bool success = false;
+    FILE *fp = fopen(USERDATA_IP_PATH, "wb");
+    if (fp)
+    {
+        const size_t writeCount = fwrite(&record, sizeof(record), 1, fp);
+        fflush(fp);
+        fclose(fp);
+        success = (writeCount == 1);
+    }
+    fs.unmount();
+    return success;
+}
+
+bool nodalisReadStoredIpFromUserData(IPAddress &ip)
+{
+    mbed::BlockDevice *root = mbed::BlockDevice::get_default_instance();
+    if (!root || root->init() != 0)
+    {
+        return false;
+    }
+
+    mbed::MBRBlockDevice userData(root, 4);
+    mbed::LittleFileSystem littleFs("user");
+    mbed::FATFileSystem fatFs("user");
+    PersistentIpRecord record = {};
+
+    const bool readOk = nodalisReadRecordFromFileSystem(userData, littleFs, record) ||
+                        nodalisReadRecordFromFileSystem(userData, fatFs, record);
+    root->deinit();
+
+    if (!readOk)
+    {
+        return false;
+    }
+
+    if (record.magic0 != EEPROM_MAGIC_0 || record.magic1 != EEPROM_MAGIC_1 || record.version != EEPROM_VERSION)
+    {
+        return false;
+    }
+
+    IPAddress stored(record.ip[0], record.ip[1], record.ip[2], record.ip[3]);
+    if (record.checksum != nodalisChecksum(stored))
+    {
+        return false;
+    }
+
+    ip = stored;
+    return true;
+}
+
+bool nodalisWriteStoredIpToUserData(const IPAddress &ip)
+{
+    mbed::BlockDevice *root = mbed::BlockDevice::get_default_instance();
+    if (!root || root->init() != 0)
+    {
+        return false;
+    }
+
+    mbed::MBRBlockDevice userData(root, 4);
+    mbed::LittleFileSystem littleFs("user");
+    mbed::FATFileSystem fatFs("user");
+    const PersistentIpRecord record = {
+        EEPROM_MAGIC_0,
+        EEPROM_MAGIC_1,
+        EEPROM_VERSION,
+        {ip[0], ip[1], ip[2], ip[3]},
+        nodalisChecksum(ip)
+    };
+
+    const bool writeOk = nodalisWriteRecordToFileSystem(userData, littleFs, record) ||
+                         nodalisWriteRecordToFileSystem(userData, fatFs, record);
+    root->deinit();
+    return writeOk;
+}
+#endif
+
+#if NODALIS_HAS_KVSTORE
+
+bool nodalisReadStoredIp(IPAddress &ip)
+{
+#if NODALIS_HAS_OPTA_FS
+    if (nodalisReadStoredIpFromUserData(ip))
+    {
+        return true;
+    }
+#endif
+    PersistentIpRecord record = {};
+    size_t actualSize = 0;
+    const int readResult = kv_get(KVSTORE_IP_KEY, &record, sizeof(record), &actualSize);
+    if (readResult != 0 || actualSize != sizeof(record))
+    {
+        return false;
+    }
+
+    if (record.magic0 != EEPROM_MAGIC_0 || record.magic1 != EEPROM_MAGIC_1 || record.version != EEPROM_VERSION)
+    {
+        return false;
+    }
+
+    IPAddress stored(record.ip[0], record.ip[1], record.ip[2], record.ip[3]);
+    if (record.checksum != nodalisChecksum(stored))
+    {
+        return false;
+    }
+
+    ip = stored;
+    return true;
+}
+
+bool nodalisWriteStoredIp(const IPAddress &ip)
+{
+#if NODALIS_HAS_OPTA_FS
+    if (nodalisWriteStoredIpToUserData(ip))
+    {
+        return true;
+    }
+#endif
+    PersistentIpRecord record = {
+        EEPROM_MAGIC_0,
+        EEPROM_MAGIC_1,
+        EEPROM_VERSION,
+        {ip[0], ip[1], ip[2], ip[3]},
+        nodalisChecksum(ip)
+    };
+    return kv_set(KVSTORE_IP_KEY, &record, sizeof(record), 0) == 0;
+}
+
+#elif NODALIS_HAS_EEPROM
+bool nodalisReadStoredIp(IPAddress &ip)
+{
+    if (EEPROM.read(EEPROM_BASE) != EEPROM_MAGIC_0 || EEPROM.read(EEPROM_BASE + 1) != EEPROM_MAGIC_1 || EEPROM.read(EEPROM_BASE + 2) != EEPROM_VERSION)
+    {
+        return false;
+    }
+
+    IPAddress stored(
+        EEPROM.read(EEPROM_BASE + 3),
+        EEPROM.read(EEPROM_BASE + 4),
+        EEPROM.read(EEPROM_BASE + 5),
+        EEPROM.read(EEPROM_BASE + 6));
+
+    if (EEPROM.read(EEPROM_BASE + 7) != nodalisChecksum(stored))
+    {
+        return false;
+    }
+
+    ip = stored;
+    return true;
+}
+
+bool nodalisWriteStoredIp(const IPAddress &ip)
+{
+    EEPROM.update(EEPROM_BASE, EEPROM_MAGIC_0);
+    EEPROM.update(EEPROM_BASE + 1, EEPROM_MAGIC_1);
+    EEPROM.update(EEPROM_BASE + 2, EEPROM_VERSION);
+    EEPROM.update(EEPROM_BASE + 3, ip[0]);
+    EEPROM.update(EEPROM_BASE + 4, ip[1]);
+    EEPROM.update(EEPROM_BASE + 5, ip[2]);
+    EEPROM.update(EEPROM_BASE + 6, ip[3]);
+    EEPROM.update(EEPROM_BASE + 7, nodalisChecksum(ip));
+    return true;
+}
+#endif
+
+void nodalisProcessSerialCommand(String command, IPAddress &currentIp)
+{
+    command = nodalisNormalizeCommand(command);
+    if (command.length() == 0)
+    {
+        return;
+    }
+
+    String upper = command;
+    upper.toUpperCase();
+
+    if (nodalisHandleBitCommand(command, upper))
+    {
+        return;
+    }
+
+    if (upper == "HELP" || upper == "IP HELP")
+    {
+        nodalisPrintNetworkConfigHelp();
+        return;
+    }
+
+    if (upper == "IP?" || upper == "SHOW IP")
+    {
+        nodalisPrintCurrentIp(currentIp);
+        return;
+    }
+
+    String ipText = command;
+    if (upper.startsWith("SETIP "))
+    {
+        ipText = command.substring(6);
+        ipText.trim();
+    }
+    else if (upper.startsWith("IP "))
+    {
+        ipText = command.substring(3);
+        ipText.trim();
+    }
+
+    IPAddress newIp;
+    if (!nodalisParseIpString(ipText, newIp))
+    {
+        Serial.println("Invalid IP. Use SETIP a.b.c.d or IP?");
+        return;
+    }
+
+    const bool ipChanged = !(newIp == currentIp);
+    currentIp = newIp;
+#if NODALIS_HAS_KVSTORE || NODALIS_HAS_EEPROM
+    if (nodalisWriteStoredIp(currentIp))
+    {
+        Serial.println(ipChanged ? "Stored new IP address." : "Stored current IP address.");
+    }
+    else
+    {
+        Serial.println("Failed to store IP address.");
+    }
+#else
+    Serial.println(ipChanged ? "Persistent storage not available. IP will reset on reboot." : "IP address unchanged and persistent storage not available.");
+#endif
+    Serial.println(ipChanged ? "Applying IP address..." : "IP address unchanged.");
+    nodalisBeginEthernet(currentIp);
+    nodalisPrintCurrentIp(currentIp);
+}
+} // namespace
+
+IPAddress nodalisDefaultIpAddress()
+{
+    return IPAddress(192, 168, 1, 15);
+}
+
+IPAddress nodalisLoadIpAddress()
+{
+    IPAddress ip = nodalisDefaultIpAddress();
+#if NODALIS_HAS_KVSTORE || NODALIS_HAS_EEPROM
+    IPAddress stored;
+    if (nodalisReadStoredIp(stored))
+    {
+        ip = stored;
+    }
+#endif
+    return ip;
+}
+
+void nodalisBeginEthernet(const IPAddress &ip)
+{
+#if defined(ARDUINO_ARCH_MBED)
+    Ethernet.begin(ip);
+#else
+    Ethernet.begin(const_cast<uint8_t *>(DEFAULT_MAC), ip);
+#endif
+}
+
+void nodalisPrintCurrentIp(const IPAddress &ip)
+{
+    Serial.print("Ethernet IP: ");
+    Serial.println(ip);
+}
+
+void nodalisPrintNetworkConfigHelp()
+{
+    Serial.println("Serial commands: HELP, IP?, SETIP a.b.c.d, MAPS, READBIT %IX0.0, WRITEBIT %IX0.0 1");
+}
+
+void nodalisPollSerialIpConfig(IPAddress &currentIp)
+{
+    while (Serial.available() > 0)
+    {
+        const char ch = static_cast<char>(Serial.read());
+        if (ch == '\r')
+        {
+            continue;
+        }
+
+        if (ch == '\n')
+        {
+            nodalisProcessSerialCommand(serialBuffer, currentIp);
+            serialBuffer = "";
+            continue;
+        }
+
+        if (isPrintable(static_cast<unsigned char>(ch)))
+        {
+            if (serialBuffer.length() < SERIAL_BUFFER_LIMIT)
+            {
+                serialBuffer += ch;
+            }
+            else
+            {
+                serialBuffer = "";
+                Serial.println("Command too long.");
+            }
+        }
+    }
+}

package/src/compilers/support/arduino/network_config.h

@@ -0,0 +1,20 @@
+// 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.
+
+#pragma once
+#ifndef NODALIS_NETWORK_CONFIG_H
+#define NODALIS_NETWORK_CONFIG_H
+
+#include <Arduino.h>
+#include <Ethernet.h>
+
+IPAddress nodalisDefaultIpAddress();
+IPAddress nodalisLoadIpAddress();
+void nodalisBeginEthernet(const IPAddress &ip);
+void nodalisPrintCurrentIp(const IPAddress &ip);
+void nodalisPrintNetworkConfigHelp();
+void nodalisPollSerialIpConfig(IPAddress &currentIp);
+
+#endif

package/src/compilers/support/arduino/nodalis.cpp

@@ -11,6 +11,31 @@ uint64_t elapsed()
     return static_cast<uint64_t>(millis());
 }
 
+bool nodalisSerialReady()
+{
+    return static_cast<bool>(Serial);
+}
+
+static void nodalisLog(const char *level, const String &message)
+{
+    if (!nodalisSerialReady())
+        return;
+    Serial.print("[Nodalis][");
+    Serial.print(level);
+    Serial.print("] ");
+    Serial.println(message);
+}
+
+void nodalisLogInfo(const String &message)
+{
+    nodalisLog("INFO", message);
+}
+
+void nodalisLogError(const String &message)
+{
+    nodalisLog("ERROR", message);
+}
+
 static bool validAddressParts(const std::vector<int> &parts, int expectedWidth, bool allowBit)
 {
     if (parts.size() != 4)
@@ -196,6 +221,11 @@ void IOClient::addMapping(const IOMap &map)
             moduleID = map.moduleID;
         mappings.push_back(map);
         onMappingAdded(mappings.back());
+        logInfo("Added map " + describeMapping(mappings.back()));
+    }
+    else
+    {
+        logInfo("Skipping duplicate map " + describeMapping(map));
     }
 }
 
@@ -209,9 +239,43 @@ bool IOClient::hasMapping(std::string localAddress)
     return false;
 }
 
+void IOClient::dumpMappings() const
+{
+    nodalisLogInfo(String(protocol.c_str()) + ": mapping dump begin");
+    for (size_t i = 0; i < mappings.size(); ++i)
+    {
+        nodalisLogInfo(String(protocol.c_str()) + ": " + describeMapping(mappings[i]).c_str());
+    }
+    nodalisLogInfo(String(protocol.c_str()) + ": mapping dump end");
+}
+
 const std::string &IOClient::getProtocol() const { return protocol; }
 const std::string &IOClient::getModuleID() const { return moduleID; }
 
+void IOClient::logInfo(const std::string &message) const
+{
+    nodalisLogInfo(String(protocol.c_str()) + ": " + message.c_str());
+}
+
+void IOClient::logErrorThrottled(const std::string &message)
+{
+    const uint64_t now = elapsed();
+    if (now - lastErrorReport < 2000)
+        return;
+    lastErrorReport = now;
+    nodalisLogError(String(protocol.c_str()) + ": " + message.c_str());
+}
+
+std::string IOClient::describeMapping(const IOMap &map) const
+{
+    std::string text = map.localAddress + " <= " + map.remoteAddress + " [" + map.protocol + "]";
+    if (!map.moduleID.empty())
+        text += " module=" + map.moduleID;
+    if (!map.modulePort.empty())
+        text += ":" + map.modulePort;
+    return text;
+}
+
 void IOClient::poll()
 {
     if (!connected)
@@ -219,7 +283,12 @@ void IOClient::poll()
         if (elapsed() - lastAttempt >= 15000)
         {
             lastAttempt = elapsed();
+            logInfo("Attempting connection");
             connect();
+            if (connected)
+                logInfo("Connection ready");
+            else
+                logErrorThrottled("Connection attempt failed");
         }
         return;
     }
@@ -232,71 +301,84 @@ void IOClient::poll()
 
         if (map.direction == IOType::Output)
         {
+            bool success = true;
             switch (map.width)
             {
             case 1:
-                writeBit(map.remoteAddress, ::readBit(map.localAddress) ? 1 : 0);
+                success = writeBit(map.remoteAddress, ::readBit(map.localAddress) ? 1 : 0);
                 break;
             case 8:
-                writeByte(map.remoteAddress, ::readByte(map.localAddress));
+                success = writeByte(map.remoteAddress, ::readByte(map.localAddress));
                 break;
             case 16:
-                writeWord(map.remoteAddress, ::readWord(map.localAddress));
+                success = writeWord(map.remoteAddress, ::readWord(map.localAddress));
                 break;
             case 32:
-                writeDWord(map.remoteAddress, ::readDWord(map.localAddress));
+                success = writeDWord(map.remoteAddress, ::readDWord(map.localAddress));
                 break;
             case 64:
-                writeLWord(map.remoteAddress, ::readLWord(map.localAddress));
+                success = writeLWord(map.remoteAddress, ::readLWord(map.localAddress));
                 break;
             default:
+                success = false;
                 break;
             }
+            if (!success)
+                logErrorThrottled("Write failed for " + describeMapping(map));
             continue;
         }
 
         if (map.direction == IOType::Input)
         {
+            bool success = true;
             switch (map.width)
             {
             case 1:
             {
                 int val = 0;
-                if (readBit(map.remoteAddress, val))
-                    writeBit(map.localAddress, val != 0);
+                success = readBit(map.remoteAddress, val);
+                if (success)
+                    ::writeBit(map.localAddress, val != 0);
                 break;
             }
             case 8:
             {
                 uint8_t val = 0;
-                if (readByte(map.remoteAddress, val))
-                    writeByte(map.localAddress, val);
+                success = readByte(map.remoteAddress, val);
+                if (success)
+                    ::writeByte(map.localAddress, val);
                 break;
             }
             case 16:
             {
                 uint16_t val = 0;
-                if (readWord(map.remoteAddress, val))
-                    writeWord(map.localAddress, val);
+                success = readWord(map.remoteAddress, val);
+                if (success)
+                    ::writeWord(map.localAddress, val);
                 break;
             }
             case 32:
             {
                 uint32_t val = 0;
-                if (readDWord(map.remoteAddress, val))
-                    writeDWord(map.localAddress, val);
+                success = readDWord(map.remoteAddress, val);
+                if (success)
+                    ::writeDWord(map.localAddress, val);
                 break;
             }
             case 64:
             {
                 uint64_t val = 0;
-                if (readLWord(map.remoteAddress, val))
-                    writeLWord(map.localAddress, val);
+                success = readLWord(map.remoteAddress, val);
+                if (success)
+                    ::writeLWord(map.localAddress, val);
                 break;
             }
             default:
+                success = false;
                 break;
             }
+            if (!success)
+                logErrorThrottled("Read failed for " + describeMapping(map));
         }
     }
 }
@@ -337,12 +419,20 @@ std::unique_ptr<IOClient> createClient(IOMap &map)
 void mapIO(std::string map)
 {
     IOMap newMap(map);
+    nodalisLogInfo(String("Loading map: ") + newMap.localAddress.c_str() + " <= " + newMap.remoteAddress.c_str() + " [" + newMap.protocol.c_str() + "]");
     IOClient *existing = findClient(newMap);
     if (!existing)
     {
         std::unique_ptr<IOClient> client = createClient(newMap);
         if (client)
+        {
+            nodalisLogInfo(String("Created IO client for protocol ") + newMap.protocol.c_str());
             Clients.push_back(std::move(client));
+        }
+        else
+        {
+            nodalisLogError(String("Unsupported IO protocol: ") + newMap.protocol.c_str());
+        }
     }
 }
 
@@ -353,3 +443,17 @@ void superviseIO()
         Clients[i]->poll();
     }
 }
+
+void nodalisDumpMappings()
+{
+    if (Clients.empty())
+    {
+        nodalisLogInfo("No IO clients loaded");
+        return;
+    }
+
+    for (size_t i = 0; i < Clients.size(); ++i)
+    {
+        Clients[i]->dumpMappings();
+    }
+}

package/src/compilers/support/arduino/nodalis.h

@@ -46,6 +46,9 @@ extern uint64_t PROGRAM_COUNT;
 extern uint64_t MEMORY[64][16];
 
 uint64_t elapsed();
+bool nodalisSerialReady();
+void nodalisLogInfo(const String &message);
+void nodalisLogError(const String &message);
 
 inline std::string toLowerCase(const std::string &input)
 {
@@ -264,6 +267,7 @@ void setBit(RefVar<T> &var, int bit, bool value)
 }
 
 void superviseIO();
+void nodalisDumpMappings();
 
 enum class IOType
 {
@@ -300,6 +304,7 @@ public:
     void addMapping(const IOMap &map);
     bool hasMapping(std::string localAddress);
     void poll();
+    void dumpMappings() const;
 
     const std::string &getProtocol() const;
     const std::string &getModuleID() const;
@@ -309,6 +314,7 @@ protected:
     std::string moduleID;
     std::vector<IOMap> mappings;
     uint64_t lastAttempt = 0;
+    uint64_t lastErrorReport = 0;
 
     virtual bool readBit(const std::string &remote, int &result) = 0;
     virtual bool writeBit(const std::string &remote, int value) = 0;
@@ -325,6 +331,10 @@ protected:
     {
         (void)map;
     }
+
+    void logInfo(const std::string &message) const;
+    void logErrorThrottled(const std::string &message);
+    std::string describeMapping(const IOMap &map) const;
 };
 
 extern std::vector<std::unique_ptr<IOClient>> Clients;

package/src/compilers/support/generic/gpio.cpp

@@ -40,6 +40,10 @@ void GPIOClient::onMappingAdded(const IOMap &map)
         {
             return;
         }
+        if (!ensureActiveLow(pin))
+        {
+            return;
+        }
         if (!ensureDirection(pin, direction))
         {
             return;
@@ -364,6 +368,11 @@ bool GPIOClient::ensureDirection(int globalPin, const std::string &direction) co
     return writeTextFile("/sys/class/gpio/gpio" + std::to_string(globalPin) + "/direction", direction);
 }
 
+bool GPIOClient::ensureActiveLow(int globalPin) const
+{
+    return writeTextFile("/sys/class/gpio/gpio" + std::to_string(globalPin) + "/active_low", "1");
+}
+
 bool GPIOClient::resolveGlobalPin(const IOMap &map, int &globalPin) const
 {
     const std::string chipName = normalizeChipName(map.moduleID);

package/src/compilers/support/generic/gpio.h

@@ -40,6 +40,7 @@ private:
     bool readIntFile(const std::string &path, int &value) const;
     bool writeTextFile(const std::string &path, const std::string &value) const;
     bool ensureExported(int globalPin) const;
+    bool ensureActiveLow(int globalPin) const;
     bool ensureDirection(int globalPin, const std::string &direction) const;
     bool resolveGlobalPin(const IOMap &map, int &globalPin) const;
     bool resolveRemotePin(const std::string &remote, int &globalPin) const;

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

@@ -74,6 +74,9 @@ export class GPIOClient extends IOClient {
       if (!this.ensureExported(pin)) {
         return;
       }
+      if (!writeTextFile(`/sys/class/gpio/gpio${pin}/active_low`, "1")) {
+        return;
+      }
       if (!writeTextFile(`/sys/class/gpio/gpio${pin}/direction`, direction)) {
         return;
       }

package/src/programmers/ArduinoProgrammer.js

@@ -18,6 +18,36 @@ import { Programmer } from './Programmer.js';
 import { runCommand } from './utils.js';
 import { getManagedArduinoCliExecOptions, getManagedArduinoCliPath } from '../toolchains.js';
 
+const ARDUINO_UPLOAD_NON_FATAL_STDERR_PATTERNS = [
+  /dfu-util:\s*Warning:\s*Invalid DFU suffix signature/i,
+  /dfu-util:\s*A valid DFU suffix will be required in a future dfu-util release/i
+];
+
+function classifyUploadStderr(stderrText) {
+  const lines = String(stderrText || '')
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean);
+
+  if (lines.length === 0) {
+    return { fatal: [], nonFatal: [] };
+  }
+
+  const fatal = [];
+  const nonFatal = [];
+
+  for (const line of lines) {
+    const isKnownNonFatal = ARDUINO_UPLOAD_NON_FATAL_STDERR_PATTERNS.some(pattern => pattern.test(line));
+    if (isKnownNonFatal) {
+      nonFatal.push(line);
+      continue;
+    }
+    fatal.push(line);
+  }
+
+  return { fatal, nonFatal };
+}
+
 export class ArduinoProgrammer extends Programmer {
   constructor(options) {
     super(options);
@@ -69,7 +99,13 @@ export class ArduinoProgrammer extends Programmer {
       console.log(stdout.trim());
     }
     if (stderr) {
-      console.error(stderr.trim());
+      const { fatal, nonFatal } = classifyUploadStderr(stderr);
+      if (nonFatal.length > 0) {
+        console.log(nonFatal.join('\n'));
+      }
+      if (fatal.length > 0) {
+        console.error(fatal.join('\n'));
+      }
     }
 
     return true;

package/src/programmers/SSHProgrammer.js

@@ -130,6 +130,13 @@ export class SSHProgrammer extends Programmer {
         ? `cp -a ${quoteForPosixSingle(`${remoteStagingPath}/.`)} ${quoteForPosixSingle(`${remotePath}/`)}`
         : `cp -a ${quoteForPosixSingle(path.posix.join(remoteStagingPath, path.basename(sourcePath)))} ${quoteForPosixSingle(`${remotePath}/`)}`;
 
+      await this.#runSsh(credentials.password, [
+        '-p',
+        sshPort,
+        `${credentials.username}@${host}`,
+        this.#buildSudoCommand(credentials.password, this.#buildStopProgramCommand(remoteProgramPath, runtime))
+      ]);
+
       await this.#runSsh(credentials.password, [
         '-p',
         sshPort,
@@ -256,6 +263,48 @@ export class SSHProgrammer extends Programmer {
     return `sudo sh -lc ${quoteForPosixSingle(command)}`;
   }
 
+  #buildStopProgramCommand(remoteProgramPath, runtime) {
+    const quotedPath = quoteForPosixSingle(remoteProgramPath);
+    const quotedProgramName = quoteForPosixSingle(path.posix.basename(remoteProgramPath));
+    return `
+if command -v pgrep >/dev/null 2>&1; then
+  if [ ${quoteForPosixSingle(runtime)} = 'node' ]; then
+    pids=$(ps -eo pid=,args= | awk '
+      index($0, ${quotedPath}) > 0 && $1 != "'$$'" && $1 != "'"$PPID"'" { print $1 }
+    ' 2>/dev/null || true)
+  else
+    pids=$(pgrep -x -- ${quotedProgramName} 2>/dev/null || true)
+  fi
+
+  target_pids=""
+  for pid in $pids; do
+    if [ "$pid" = "$$" ] || [ "$pid" = "$PPID" ]; then
+      continue
+    fi
+    target_pids="$target_pids $pid"
+  done
+
+  if [ -n "$target_pids" ]; then
+    kill $target_pids >/dev/null 2>&1 || true
+    for _ in 1 2 3 4 5; do
+      sleep 1
+      remaining=""
+      for pid in $target_pids; do
+        if kill -0 "$pid" >/dev/null 2>&1; then
+          remaining="$remaining $pid"
+        fi
+      done
+      if [ -z "$remaining" ]; then
+        exit 0
+      fi
+      target_pids="$remaining"
+    done
+    kill -9 $target_pids >/dev/null 2>&1 || true
+  fi
+fi
+`.trim();
+  }
+
   async #cleanupRemoteStaging(credentials, host, sshPort, remoteStagingPath) {
     if (!remoteStagingPath) {
       return;
@@ -286,8 +335,7 @@ export class SSHProgrammer extends Programmer {
           SSH_ASKPASS: askPassPath,
           SSH_ASKPASS_REQUIRE: 'force',
           DISPLAY: process.env.DISPLAY || 'nodalis:0'
-        },
-        stdio: ['ignore', 'inherit', 'inherit']
+        }
       });
     }
     finally {

package/src/programmers/utils.js

@@ -65,18 +65,43 @@ export async function runCommand(command, args = [], options = {}) {
 
 export async function runCommandInteractive(command, args = [], options = {}) {
   return new Promise((resolve, reject) => {
+    const childStdio = options.stdio ?? ['inherit', 'pipe', 'pipe'];
     const child = spawn(command, args, {
-      stdio: 'inherit',
+      stdio: childStdio,
       ...options
     });
 
+    let stdout = '';
+    let stderr = '';
+
+    if (child.stdout) {
+      child.stdout.on('data', data => {
+        const text = data.toString();
+        stdout += text;
+        process.stdout.write(text);
+      });
+    }
+
+    if (child.stderr) {
+      child.stderr.on('data', data => {
+        const text = data.toString();
+        stderr += text;
+        process.stderr.write(text);
+      });
+    }
+
     child.on('error', reject);
     child.on('close', code => {
       if (code === 0) {
         resolve({ code });
         return;
       }
-      reject(new Error(`Command failed (${command} ${args.join(' ')}) with exit code ${code}`));
+      const detail = (stderr || stdout).trim();
+      reject(new Error(
+        detail
+          ? `Command failed (${command} ${args.join(' ')}) with exit code ${code}: ${detail}`
+          : `Command failed (${command} ${args.join(' ')}) with exit code ${code}`
+      ));
     });
   });
 }