Node.js in modern SCADA architectures: benefits, limits, and use cases

  • Node.js
  • Gabriele Romanato

SCADA (Supervisory Control and Data Acquisition) architectures represent a fundamental pillar in monitoring and controlling industrial systems. Traditionally composed of PLCs, RTUs, HMIs, and central SCADA servers, these architectures are progressively evolving to embrace modern technologies, including Node.js. This article explores in detail the role of Node.js in a SCADA system, its advantages, potential limitations, and real-world use cases.

1. What is Node.js and Why Consider it in SCADA

Node.js is a JavaScript runtime environment based on Chrome’s V8 engine. It is designed to build scalable and responsive applications, thanks to its event-driven, non-blocking model. In SCADA environments, Node.js is often used to:

  • Create modern and interactive HMI web interfaces
  • Collect and normalize real-time data
  • Integrate with industrial protocols via specific modules
  • Bridge edge devices and the cloud

2. Placement of Node.js in the SCADA Architecture

Node.js can be integrated at various levels of the SCADA architecture:

Edge Level

At the level closest to physical devices (sensors, PLCs), Node.js can run on embedded devices or gateways to collect data via industrial protocols such as Modbus, OPC UA, or MQTT. Below is an example of Modbus TCP reading:


const ModbusRTU = require("modbus-serial");
const client = new ModbusRTU();

client.connectTCP("192.168.0.10", { port: 502 })
  .then(() => client.setID(1))
  .then(() => client.readHoldingRegisters(0, 10))
  .then(data => console.log("Read values:", data.data))
  .catch(err => console.error(err));

Supervisor / Middleware Level

Node.js can act as middleware between field devices and central SCADA servers, normalizing and transforming data. Thanks to WebSocket, REST APIs, and MQTT brokers, it can distribute data to HMI clients, dashboards, or MES/ERP systems.


const express = require('express');
const app = express();
const mqtt = require('mqtt');
const client = mqtt.connect('mqtt://broker.hivemq.com');

client.on('connect', () => {
  client.subscribe('factory/temperature');
});

client.on('message', (topic, message) => {
  console.log(`Data received: ${message.toString()}`);
});

// REST API to provide data to the SCADA client
app.get('/api/temperature', (req, res) => {
  res.json({ value: currentTemperature });
});

app.listen(3000);

HMI / Front-end Level

Node.js can support HMI applications built with HTML5, Vue.js, or React, acting as a backend. Modern interfaces can receive real-time data via WebSocket or Server-Sent Events (SSE).


// WebSocket to transmit SCADA data in real time
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

setInterval(() => {
  const mockData = { timestamp: Date.now(), rpm: Math.random() * 3000 };
  wss.clients.forEach(ws => ws.send(JSON.stringify(mockData)));
}, 1000);

3. Advantages of Node.js in SCADA Context

  • Responsiveness: Non-blocking event loop ideal for I/O-intensive operations
  • Scalability: Excellent for handling high-frequency data streams
  • Modularity: Vast NPM ecosystem for protocols, interfaces, and connectors
  • Portability: Can run on Linux, Windows, ARM (e.g., Raspberry Pi)

4. Limitations and Considerations

  • Hard real-time: Node.js is not suitable for strict real-time tasks, such as direct actuator control
  • Industrial reliability: Requires proper failover and monitoring architecture
  • Maintenance: The lifecycle of open-source libraries can be unstable without IT governance

5. Real Use Cases

  • Remote monitoring: Web dashboards developed in Node.js with live PLC data via MQTT
  • Edge computing: Node.js on ARM gateways for data preprocessing and filtering
  • Data bridge: Node.js gateway to convert from Modbus to OPC UA

Conclusions

Node.js represents a powerful and versatile technology within modern SCADA architectures. While not intended for direct control, its use as an interface, middleware, or data aggregation tool opens new perspectives in terms of scalability, interoperability, and user experience. When properly integrated, it can radically enhance the responsiveness and accessibility of complex industrial systems.

Back to top