A Modular Event-Driven Software Architecture for Open-Source Industrial IoT Edge Gateways

The gist: This paper presents a modular event-driven software architecture designed for open-source IIoT edge gateways that abstracts serial protocol management and network configuration into a responsive web interface.

Proposed System Architecture

The proposed system architecture separates the system into three distinct layers: (i) Edge Hardware Interface, (ii) Application Middleware, and (iii) Cloud Orchestration Layer The high-level operational architecture of the proposed IIoT edge gateway is illustrated in Figure 1 Industrial field devices connect to the gateway via established fieldbus protocols, while the aggregated and processed data is transmitted to the cloud using MQTT

Hardware Infrastructure

The primary edge node utilized in this investigation is the IRIV PiControl system This industrial-grade controller integrates a Raspberry Pi Compute Module 4 (CM4) It features isolated RS-485 interfaces, which mitigate the risk of electrical noise disrupting serial communications in harsh factory environments The hardware includes dual Gigabit Ethernet ports and expandable NVMe storage, providing the necessary bandwidth and memory for localized data buffering

Application Middleware and Technology Stack

The Application Middleware resides entirely on the CM4 and handles all computational logic, protocol translation, and state management The backend orchestrator was developed using Node.js and the Express.js framework Node.js utilizes an asynchronous, event-driven runtime environment, making it highly suitable for handling concurrent I/O operations without thread blocking MongoDB was implemented as the localized database engine This document stores network parameters, mapped Modbus registers, and user-defined automation rules The frontend interface was built utilizing React.js This component-based JavaScript framework allows technicians to interact dynamically with the backend API

Protocol Translation Workflow

The software operates as a deterministic and bidirectional translation engine During the uplink cycle, the Node.js polling engine iterates through the MongoDB collection of registered field devices It dispatches read requests over the RS-485 bus utilizing the Modbus RTU protocol Upon receiving the hexadecimal serial payload, the backend decodes the data based on user-defined function codes, such as Read Holding Registers The system wraps the decoded values into a structured JSON payload and publishes it to the designated MQTT broker under specific Quality of Service (QoS) parameters During the downlink cycle, the Node.js client subscribes to command topics on the MQTT broker When a cloud application issues an execution command, the middleware parses the JSON structure and translates it into the corresponding Modbus write command It then transmits this command to the physical actuator

Automated Linkage Event Engine

A localized linkage event engine is engineered to facilitate rapid, autonomous decision-making at the edge Sending raw sensor data to the cloud for simple threshold evaluation introduces unnecessary latency and consumes bandwidth The system formalizes this event engine as a finite state evaluation process Let St represent the continuous state of an analog sensor at time t Let τupper and τlower represent the user-defined upper and lower execution thresholds The system determines the discrete actuation state A(St) of a coupled digital output device using the following piecewise function A(St) =







1 if St ≥ τupper

0 if St ≤ τlower

Aprev otherwise The Node.js backend evaluates this logic locally during every polling cycle When St breaches a threshold, the system triggers the corresponding digital output via the CM4 GPIO pins instantaneously, ensuring critical safety or operational thresholds are met regardless of cloud latency

Performance and Usability Evaluation

The software architecture demonstrated exceptional stability during the validation phase The backend maintained a continuous polling cycle across the Modbus network while simultaneously publishing the JSON payloads to AWS IoT without packet loss The asynchronous Node.js backend maintained a minimal resource footprint During continuous bidirectional communication, the CPU load on the ARM Cortex-A72 processor remained low, leaving substantial computational headroom for future integration The primary pilot achievement is the reduction in deployment overhead Traditional command-line configuration of network interfaces, database schemas, and MQTT daemons on a Linux SBC typically requires several hours of expert engineering time Utilizing our unified RESTful API and graphical interface, technicians can configure the entire data pipeline directly in the web GUI

Conclusions and Future Work

In this paper, a highly adaptable event-driven software architecture is presented that simplifies the deployment of open-source IIoT edge gateways towards new network-centric paradigms such as Cloud-Fog Automation This framework addresses the complexities of manual coding by abstracting serial protocol management and network configuration into a responsive web interface The system effectively bridges the gap between legacy industrial equipment and modern cloud infrastructure The integration of localized threshold evaluation further ensures deterministic response times for critical operations, thus reducing reliance on cloud processing Despite demonstrating reliable performance in device management and automated event controls, the current system scope has several limitations The hardware dependency on RS-485 for physical connectivity restricts network scalability in remote or highly distributed deployments Additionally, the software currently translates exclusively between Modbus and MQTT, limiting interoperability with other prevalent industrial communication standards Future work will address these limitations by expanding both the hardware connectivity and the software’s computational capabilities The authors plan to integrate configuration support for extended wireless modules such as LoRa and 4G/5G to leverage the full connectivity suite of the edge controller They will also implement security mechanisms for the edge-based containerized framework and focus on horizontal scalability by incorporating agentic automation protocols in the era of Large AI models This advancement will enable dynamic task placement and collaborative decision-making across a distributed swarm of networked edge gateways The paper establishes a robust software foundation for real-time edge-based industrial automation by enabling seamless integration with modern industrial infrastructure

How it works

The system is structured into three distinct layers: (i) Edge Hardware Interface, (ii) Application Middleware, and (iii) Cloud Orchestration Layer The hardware infrastructure utilizes the IRIV PiControl system as the primary edge node This controller integrates a Raspberry Pi Compute Module 4 (CM4) It features isolated RS-485 interfaces, mitigating the risk of electrical noise disrupting serial communications in harsh factory environments

Protocol Translation and Event Processing

The protocol translation workflow is deterministic and bidirectional During the uplink cycle, a Node.

1. The system can reduce system integration time by allowing technicians to configure the entire data pipeline, from bare-metal hardware connection to active cloud telemetry, directly in the web GUI as shown in Fig 3. This capability eliminates the traditional command-line configuration of network interfaces, database schemas, and MQTT daemons on a Linux SBC typically requires several hours of expert engineering time.

2. The localized event engine can enable rapid, autonomous decision-making at the edge by implementing a piecewise function: A(St) = 1 if St ≥ τupper / 0 if St ≤ τlower / Aprev otherwise, triggering actuation instantly based on local sensor states rather than waiting for cloud processing.

3. The architecture can achieve high operational stability by storing all configuration state locally in MongoDB, which ensures the edge gateway maintains autonomous operation even during severe network partitions, an industrial requirement for reliability.

Integrating legacy industrial machinery into modern cloud infrastructures poses a significant software engineering challenge. Industrial Internet of Things (IIoT) deployments frequently rely on rigid and proprietary edge controllers that require extensive manual configuration. Open-source single-board computers (SBCs) offer a highly adaptable hardware alternative, but they still lack standardized software deployment frameworks capable of bridging localized serial protocols with global cloud environments. In this paper, we present a modular event-driven software architecture designed specifically for open-source IIoT edge gateways. We built a containerized web stack to provide a unified architecture that abstracts the complexities of Modbus-to-MQTT protocol translation, enabling rapid configuration of telemetry streams to cloud platforms such as Amazon Web Services (AWS) IoT. Furthermore, we designed a localized event engine that processes conditional logic directly at the edge layer, which significantly reducing network latency. The proposed architecture is preliminarily deployed and validated on an industrial-grade Raspberry Pi Compute Module 4 (CM4) to investigate its robustness, scalability and user-friendliness. Experimental results demonstrate a substantial reduction in system integration time and high operational stability, thus establishing a robust software foundation for real-time edge-based industrial automation. This paper contributes to extending the lifespan of legacy machinery by enabling seamless integration with modern industrial infrastructure.