nodalis-compiler 1.0.0

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

@@ -0,0 +1,378 @@
+// 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 Nodalis PLC Modbus
+ * @author Nathan Skipper, MTI
+ * @version 1.0.2
+ * @copyright Apache 2.0
+ */
+#include "modbus.h"
+#include <cstring>
+#include <iostream>
+#ifdef _WIN32
+    #include <winsock2.h>
+    #include <ws2tcpip.h>
+    #pragma comment(lib, "ws2_32.lib")
+#else
+    #include <errno.h>
+#endif
+
+// ========== Server Implementation ==========
+
+ModbusServer::ModbusServer() {}
+
+void ModbusServer::setCoil(uint16_t address, bool value) {
+    coils[address] = value;
+}
+
+bool ModbusServer::getCoil(uint16_t address) {
+    return coils[address];
+}
+
+void ModbusServer::setDiscreteInput(uint16_t address, bool value) {
+    discreteInputs[address] = value;
+}
+
+bool ModbusServer::getDiscreteInput(uint16_t address) {
+    return discreteInputs[address];
+}
+
+void ModbusServer::setRegister(uint16_t address, uint16_t value) {
+    holdingRegisters[address] = value;
+}
+
+uint16_t ModbusServer::getRegister(uint16_t address) {
+    return holdingRegisters[address];
+}
+
+ModbusResponse ModbusServer::handleRequest(const ModbusRequest& request) {
+    ModbusResponse res;
+    res.address = request.address;
+    res.function = request.function;
+    res.exceptionCode = 0;
+
+    switch (request.function) {
+        case READ_COILS:
+        case READ_DISCRETE_INPUTS: {
+            for (uint16_t i = 0; i < request.quantity; ++i) {
+                bool bit = (request.function == READ_COILS)
+                    ? getCoil(request.startAddress + i)
+                    : getDiscreteInput(request.startAddress + i);
+                if (i % 8 == 0)
+                    res.data.push_back(0);
+                if (bit)
+                    res.data[i / 8] |= (1 << (i % 8));
+            }
+            break;
+        }
+
+        case READ_HOLDING_REGISTERS:
+        case READ_INPUT_REGISTERS: {
+            for (uint16_t i = 0; i < request.quantity; ++i) {
+                uint16_t val = getRegister(request.startAddress + i);
+                res.data.push_back(val >> 8);
+                res.data.push_back(val & 0xFF);
+            }
+            break;
+        }
+
+        case WRITE_SINGLE_COIL: {
+            if (request.data.size() < 2) { res.exceptionCode = 0x03; break; }
+            bool value = (request.data[0] == 0xFF);
+            setCoil(request.startAddress, value);
+            res.data = request.data;
+            break;
+        }
+
+        case WRITE_SINGLE_REGISTER: {
+            if (request.data.size() < 2) { res.exceptionCode = 0x03; break; }
+            uint16_t value = (request.data[0] << 8) | request.data[1];
+            setRegister(request.startAddress, value);
+            res.data = request.data;
+            break;
+        }
+
+        default:
+            res.exceptionCode = 0x01;
+            break;
+    }
+
+    return res;
+}
+
+// ========== Client Implementation ==========
+
+ModbusClient::ModbusClient(const std::string& ip, uint16_t port, uint8_t unitId)
+    : IOClient("MODBUS-TCP"), deviceAddress(unitId), sockfd(-1), ip(ip), port(port) {
+#ifdef _WIN32
+    WSADATA wsa;
+    WSAStartup(MAKEWORD(2,2), &wsa);
+#endif
+        if(ip != "") connectTCP(ip, port);
+}
+
+ModbusClient::~ModbusClient() {
+    disconnect();
+}
+
+void ModbusClient::connect(){
+    if(connected){
+        disconnect();
+    }
+    if(ip == "" || port == 0){
+        if(mappings.size() > 0){
+            IOMap& map = mappings[0];
+            ip = map.moduleID;
+            port = std::atoi(map.modulePort.c_str());
+        }
+    }
+    if(ip != "" && port > 0){
+        moduleID = ip;
+        connectTCP(ip, port);
+    }
+}
+
+bool ModbusClient::connectTCP(const std::string& ip, uint16_t port) {
+    std::cout << "Modbus-TCP attempting to connect to " << ip.c_str() << ":" << port << "\n";
+    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    if (sockfd < 0) return false;
+
+    sockaddr_in serverAddr;
+    memset(&serverAddr, 0, sizeof(serverAddr));
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(port);
+    inet_pton(AF_INET, ip.c_str(), &serverAddr.sin_addr);
+    
+    int err = ::connect(sockfd, (sockaddr*)&serverAddr, sizeof(serverAddr));
+    if (err < 0) {
+        disconnect();
+        #ifdef _WIN32
+            int wsaErr = WSAGetLastError();
+            std::cerr << "Connect failed: WSA Error " << wsaErr << "\n";
+        #else
+            std::cerr << "Connect failed: " << strerror(errno)
+                    << " (errno = " << errno << ")\n";
+        #endif
+        return false;
+    }
+    std::cout << "Modbus-TCP connected to " << ip.c_str() << ":" << port << "\n";
+    connected = true;
+    return true;
+}
+
+void ModbusClient::disconnect() {
+    if (connected) {
+#ifdef _WIN32
+        closesocket(sockfd);
+#else
+        close(sockfd);
+#endif
+        connected = false;
+    }
+}
+
+ModbusRequest ModbusClient::createReadRequest(uint8_t function, uint16_t startAddress, uint16_t quantity) {
+    return { deviceAddress, function, startAddress, quantity, {} };
+}
+
+ModbusRequest ModbusClient::createWriteSingleCoil(uint16_t address, bool value) {
+    std::vector<uint8_t> data = value ? std::vector<uint8_t>{0xFF, 0x00} : std::vector<uint8_t>{0x00, 0x00};
+    return { deviceAddress, WRITE_SINGLE_COIL, address, 0, data };
+}
+
+ModbusRequest ModbusClient::createWriteSingleRegister(uint16_t address, uint16_t value) {
+    std::vector<uint8_t> data = { static_cast<uint8_t>(value >> 8), static_cast<uint8_t>(value & 0xFF) };
+    return { deviceAddress, WRITE_SINGLE_REGISTER, address, 1, data };
+}
+
+bool ModbusClient::sendRequest(const ModbusRequest& req, ModbusResponse& resp) {
+    std::vector<uint8_t> pdu;
+
+    // Handle function-specific encoding
+    if (req.function == WRITE_SINGLE_COIL) {
+        // Function 0x05: Write Single Coil
+        pdu = {
+            req.function,
+            static_cast<uint8_t>(req.startAddress >> 8),
+            static_cast<uint8_t>(req.startAddress & 0xFF)
+        };
+        if (req.data.size() == 2) {
+            pdu.push_back(req.data[0]);  // Hi byte (0xFF or 0x00)
+            pdu.push_back(req.data[1]);  // Lo byte (always 0x00)
+        } else {
+            std::cerr << "Invalid data size for Write Single Coil (expected 2 bytes).\n";
+            return false;
+        }
+    } else {
+        // Default encoding for most function codes
+        pdu = {
+            req.function,
+            static_cast<uint8_t>(req.startAddress >> 8),
+            static_cast<uint8_t>(req.startAddress & 0xFF),
+            static_cast<uint8_t>(req.quantity >> 8),
+            static_cast<uint8_t>(req.quantity & 0xFF)
+        };
+        pdu.insert(pdu.end(), req.data.begin(), req.data.end());
+    }
+
+    std::vector<uint8_t> response;
+    if (!sendRaw(pdu, response)) return false;
+
+    if (response.size() < 2) return false;
+
+    resp.address = req.address;
+    resp.function = response[0];
+    resp.data.assign(response.begin() + 1, response.end());
+    resp.exceptionCode = (resp.function & 0x80) ? resp.data[0] : 0;
+
+    if (resp.exceptionCode > 0) {
+        std::cerr << "MODBUS exception code: " << static_cast<int>(resp.exceptionCode) << "\n";
+        return false;
+    }
+
+    return true;
+}
+
+bool ModbusClient::sendRaw(const std::vector<uint8_t>& pdu, std::vector<uint8_t>& response) {
+    if (!connected) return false;
+
+    // MBAP header (7 bytes): Transaction ID, Protocol ID, Length, Unit ID
+    uint8_t mbap[7] = {
+        0x00, 0x01, 0x00, 0x00,
+        static_cast<uint8_t>((pdu.size() + 1) >> 8),
+        static_cast<uint8_t>((pdu.size() + 1) & 0xFF),
+        deviceAddress
+    };
+
+    std::vector<uint8_t> packet(mbap, mbap + 7);
+    packet.insert(packet.end(), pdu.begin(), pdu.end());
+
+    // Send the packet
+    ssize_t bytesSent = send(sockfd, reinterpret_cast<const char*>(packet.data()), packet.size(), 0);
+    if (bytesSent < 0) {
+#ifdef _WIN32
+        int err = WSAGetLastError();
+        std::cerr << "Send failed: WSA error " << err << "\n";
+#else
+        std::cerr << "Send failed: " << strerror(errno) << " (errno = " << errno << ")\n";
+#endif
+        disconnect();
+        connected = false;
+        return false;
+    }
+
+    // Receive response
+    uint8_t buf[260] = {0};
+    ssize_t len = recv(sockfd, reinterpret_cast<char*>(buf), sizeof(buf), 0);
+    if (len < 0) {
+#ifdef _WIN32
+        int err = WSAGetLastError();
+        std::cerr << "Receive failed: WSA error " << err << "\n";
+#else
+        std::cerr << "Receive failed: " << strerror(errno) << " (errno = " << errno << ")\n";
+#endif
+        disconnect();
+        connected = false;
+        return false;
+    }
+
+    if (len < 9) {
+        std::cerr << "Incomplete MODBUS response (len = " << len << ")\n";
+        disconnect();
+        connected = false;
+        return false;
+    }
+
+    response.assign(buf + 7, buf + len);
+    return true;
+}
+
+bool ModbusClient::readBit(const std::string& remote, int& result) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    ModbusRequest req = createReadRequest(READ_DISCRETE_INPUTS, addr, 1);
+    ModbusResponse res;
+    if (!sendRequest(req, res)) return false;
+
+    result = (res.data[1] & 0x01) ? 1 : 0;
+    return true;
+}
+
+bool ModbusClient::writeBit(const std::string& remote, int value) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    ModbusRequest req = createWriteSingleCoil(addr, value != 0);
+    ModbusResponse res;
+    return sendRequest(req, res);
+}
+
+bool ModbusClient::readByte(const std::string& remote, uint8_t& result) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    ModbusRequest req = createReadRequest(READ_HOLDING_REGISTERS, addr, 1);
+    ModbusResponse res;
+    if (!sendRequest(req, res)) return false;
+
+    // Read only low byte
+    result = res.data.size() >= 2 ? res.data[1] : 0;
+    return true;
+}
+
+bool ModbusClient::writeByte(const std::string& remote, uint8_t value) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    // Store value in lower byte; high byte = 0
+    std::vector<uint8_t> data = { 0x00, value };
+    ModbusRequest req = { deviceAddress, WRITE_SINGLE_REGISTER, addr, 1, data };
+    ModbusResponse res;
+    return sendRequest(req, res);
+}
+
+bool ModbusClient::readWord(const std::string& remote, uint16_t& result) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    ModbusRequest req = createReadRequest(READ_HOLDING_REGISTERS, addr, 1);
+    ModbusResponse res;
+    if (!sendRequest(req, res)) return false;
+
+    result = (res.data[0] << 8) | res.data[1];
+    return true;
+}
+
+bool ModbusClient::writeWord(const std::string& remote, uint16_t value) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    ModbusRequest req = createWriteSingleRegister(addr, value);
+    ModbusResponse res;
+    return sendRequest(req, res);
+}
+
+bool ModbusClient::readDWord(const std::string& remote, uint32_t& result) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    ModbusRequest req = createReadRequest(READ_HOLDING_REGISTERS, addr, 2);
+    ModbusResponse res;
+    if (!sendRequest(req, res)) return false;
+
+    result = (res.data[0] << 24) | (res.data[1] << 16) | (res.data[2] << 8) | res.data[3];
+    return true;
+}
+
+bool ModbusClient::writeDWord(const std::string& remote, uint32_t value) {
+    uint16_t addr = static_cast<uint16_t>(std::stoi(remote));
+    std::vector<uint8_t> data = {
+        static_cast<uint8_t>(value >> 24),
+        static_cast<uint8_t>((value >> 16) & 0xFF),
+        static_cast<uint8_t>((value >> 8) & 0xFF),
+        static_cast<uint8_t>(value & 0xFF)
+    };
+
+    ModbusRequest req = { deviceAddress, WRITE_MULTIPLE_REGISTERS, addr, 2, data };
+    ModbusResponse res;
+    return sendRequest(req, res);
+}

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

@@ -0,0 +1,124 @@
+// 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 Nodalis PLC Modbus
+ * @author Nathan Skipper, MTI
+ * @version 1.0.2
+ * @copyright Apache 2.0
+ */
+#pragma once
+#ifndef MODBUS_H
+#define MODBUS_H
+
+#include <cstdint>
+#include <vector>
+#include <map>
+#include <string>
+#include "nodalis.h"
+
+#ifdef _WIN32
+    #include <winsock2.h>
+    typedef int socklen_t;
+#else
+    #include <sys/socket.h>
+    #include <arpa/inet.h>
+    #include <unistd.h>
+#endif
+
+// MODBUS function codes
+enum ModbusFunctionCode {
+    READ_COILS = 0x01,
+    READ_DISCRETE_INPUTS = 0x02,
+    READ_HOLDING_REGISTERS = 0x03,
+    READ_INPUT_REGISTERS = 0x04,
+    WRITE_SINGLE_COIL = 0x05,
+    WRITE_SINGLE_REGISTER = 0x06,
+    WRITE_MULTIPLE_COILS = 0x0F,
+    WRITE_MULTIPLE_REGISTERS = 0x10
+};
+
+struct ModbusRequest {
+    uint8_t address;
+    uint8_t function;
+    uint16_t startAddress;
+    uint16_t quantity;
+    std::vector<uint8_t> data;
+};
+
+struct ModbusResponse {
+    uint8_t address;
+    uint8_t function;
+    std::vector<uint8_t> data;
+    uint8_t exceptionCode;
+};
+
+// Server implementation
+class ModbusServer {
+public:
+    ModbusServer();
+
+    void setCoil(uint16_t address, bool value);
+    bool getCoil(uint16_t address);
+
+    void setDiscreteInput(uint16_t address, bool value);
+    bool getDiscreteInput(uint16_t address);
+
+    void setRegister(uint16_t address, uint16_t value);
+    uint16_t getRegister(uint16_t address);
+
+    ModbusResponse handleRequest(const ModbusRequest& request);
+
+private:
+    std::map<uint16_t, bool> coils;
+    std::map<uint16_t, bool> discreteInputs;
+    std::map<uint16_t, uint16_t> holdingRegisters;
+};
+
+// Client implementation
+class ModbusClient : public IOClient{
+public:
+    ModbusClient(const std::string& ip = "", uint16_t port = 502, uint8_t unitId = 1);
+    ~ModbusClient();
+
+    bool connectTCP(const std::string& ip, uint16_t port);
+    void disconnect();
+
+    ModbusRequest createReadRequest(uint8_t function, uint16_t startAddress, uint16_t quantity);
+    ModbusRequest createWriteSingleCoil(uint16_t address, bool value);
+    ModbusRequest createWriteSingleRegister(uint16_t address, uint16_t value);
+
+    bool sendRequest(const ModbusRequest& request, ModbusResponse& response);
+
+protected:
+    std::string ip;
+    uint16_t port;
+    bool readBit(const std::string& remote, int& result) override;
+    bool writeBit(const std::string& remote, int value) override;
+    bool readByte(const std::string& remote, uint8_t& result) override;
+    bool writeByte(const std::string& remote, uint8_t value) override;
+    bool readWord(const std::string& remote, uint16_t& result) override;
+    bool writeWord(const std::string& remote, uint16_t value) override;
+    bool readDWord(const std::string& remote, uint32_t& result) override;
+    bool writeDWord(const std::string& remote, uint32_t value) override;
+    void connect() override;   
+
+private:
+    int sockfd;
+    uint8_t deviceAddress;
+
+    bool sendRaw(const std::vector<uint8_t>& requestPDU, std::vector<uint8_t>& responsePDU);
+};
+
+#endif // MODBUS_H