Real-Time Vibration Monitoring with ThingsBoard and Calculated Fields

This guide shows how to build a complete end-to-end industrial vibration monitoring system from a real Balluff condition monitoring sensor, through a virtual PLC, to a live ThingsBoard dashboard with ISO 10816-compliant alarms. Unlike the previous article, which used simulated telemetry from Node-RED, this guide uses real vibration data from a physical sensor connected via IO-Link and streamed live to ThingsBoard using OPC UA and MQTT.

By the end of this guide, you will have:

Real X/Y/Z vibration RMS data streaming from a Balluff condition monitoring sensor
A reComputer vPLC reading sensor data via Modbus TCP/IP over IO-Link
A reComputer R1100 bridging data from the vPLC (OPC UA) to ThingsBoard’s MQTT Broker using Node-RED
ThingsBoard Calculated Fields compute ISO 10816 vibration severity and machine health status in real time
A professional dashboard with a color-coded gauge, alarms, and a dynamic machine health card

Hardware & Software Used

Hardware

Component	Model
Edge Computer (vPLC host)	Seeed reComputer R2100 (OpenPLC Runtime)
Edge Gateway and ThingsBoard Host	Seeed reComputer R1100
IO-Link Master	Balluff BNI00L3
Condition Monitoring Sensor	Balluff BCM R15E-001-DI00-01,5-S4

Software

OpenPLC vPLC Runtime (on reComputer R2100)
Node-RED (on reComputer R1100)
ThingsBoard Community Edition (on reComputer R1100)

System Architecture

Before diving into the steps, it’s helpful to understand how data flows through the system.

[Balluff BCM Sensor]
        │
        │  IO-Link
        ▼
[Balluff IO-Link Master — BNI00L3]
        │
        │  Modbus TCP/IP
        ▼
[reComputer R2100 — OpenPLC vPLC]
   - Reads X/Y/Z VRMS + Temperature
   - Byte-swaps Big-Endian floats
   - Exposes values via OPC UA Server
        │
        │  OPC UA
        ▼
[reComputer R1100 — Node-RED]
   - OPC UA Client reads live values
   - Publishes JSON payload via MQTT
        │
        │  MQTT (port 1883)
        ▼
[reComputer R1100 — ThingsBoard]
   - Receives telemetry
   - Runs Calculated Fields (Vibration Severity, Machine Status)
   - Triggers ISO 10816 alarms
   - Displays live dashboard

Why two edge devices? The vPLC (reComputer R2100 running OpenPLC) is dedicated to real-time scan-cycle control and sensor I/O. A separate computer, R1100, handles the edge communication. This separation keeps the PLC runtime clean and follows industrial best practices for separating control logic from data forwarding.

Step 1: Hardware Setup (vPLC + IO-Link)

This step is covered in detail in the Virtual PLC interfacing with IO-Link Master article. In summary, the vPLC:

Connects to the Balluff IO-Link Master over Modbus TCP/IP
Reads X/Y/Z VRMS and Temperature from registers IW1–IW8
Uses a custom C++ WTOR function block to byte-swap Big-Endian 32-bit floats into usable REAL values
Stores the results in rX_VRMS, rY_VRMS, rZ_VRMS, and rTemp

Key point: The Balluff sensor sends each float split across 2 × 16-bit Modbus registers in Big-Endian format. A direct cast to REAL gives garbage values — the byte swap is mandatory. The WTOR function block handles this automatically.

Once the vPLC is running and reading correct values, proceed to Step 2.

Step 2: Expose vPLC Data via OPC UA

The vPLC exposes its runtime variables as an OPC UA Server. This allows the reComputer R1100 to read live values without changing the PLC program.

OpenPLC Runtime includes a built-in OPC UA server. No additional configuration is required; variables declared in the PLC program are automatically available as OPC UA nodes.

Note the OPC UA server address of the vPLC; you will need this in the next step:

opc.tcp://192.168.100.10:4840

Replace 192.168.100.10 with the actual IP address of your vPLC.

Step 3: Bridge OPC UA to MQTT using Node-RED

The reComputer R1100 runs Node-RED as the middleware layer. It acts as an OPC UA client that reads vibration values from the vPLC and publishes them to ThingsBoard’s MQTT broker every second.

Install the OPC UA node in Node-RED

Open the Node-RED palette manager and install:

node-red-contrib-opcua

Build the flow

Real-Time Vibration Monitoring with ThingsBoard and Calculated Fields

The flow consists of three parts:

Trigger (every 1 second)

Use an Inject node set to repeat every 1 second.

Create a Device Profile in ThingsBoard

Device profiles in ThingsBoard enable administrators to define and centrally manage common settings for multiple devices. This greatly simplifies the management of a large number of similar devices, making it especially valuable in IoT solutions where numerous devices share identical configurations and behaviors.Learn more about the device profile here

Go to Profiles → Device Profiles in the left menu → click + → Create new device profile

Create a new device

Create a new device and link that to the device profile created above. In our case, the new device is named ‘OpenPLC’, linked to the device profile ‘Vibration Sensor’.

How to Link your device to the “Vibration Sensor” device Profile

Step 1: Go to Entities → DevicesStep 2: Click on OpenPLC (your device) to open its detailsStep 3: Click the pencil/edit icon () in the top right of the details panelStep 4: Find the “Device profile” field — currently shows defaultStep 5: Click on it and select “Vibration Sensor” from the dropdown

Step 6: Click Save / Apply changes

Format and publish the PLC data to the MQTT Broker

Add a Function node in the Node-RED to format the payload:

// Build payload
msg.payload = {
    // OpenPLC
    plc_rThresholdHigh: msg.payload["ns=2;i=6"].toFixed(3),
    plc_rThresholdLow: msg.payload["ns=2;i=5"].toFixed(3),
    plc_rSensortemp: msg.payload["ns=2;i=7"].toFixed(3),
    plc_iVibrationState: msg.payload["ns=2;i=4"],
    plc_rSensorX_vrms: msg.payload["ns=2;i=1"].toFixed(3),
    plc_rSensorY_vrms: msg.payload["ns=2;i=2"].toFixed(3),
    plc_rSensorZ_vrms: msg.payload["ns=2;i=3"].toFixed(3),
};
return msg;

Add an MQTT Out node with the ThingsBoard connection details as shown below.

Setting	Value
Broker	`192.168.0.227` (IP of reComputer R1100)
Port	`1883`
Topic	`v1/devices/me/telemetry`
Username	Your ThingsBoard device username. Check this step to learn how to get the username.
Password	(leave blank)

Verify data is arriving in ThingsBoard

Go to your ThingsBoard device → Latest Telemetry tab. You should see the four keys updating every second:

Step 4: Create Calculated Fields in ThingsBoard

This is where the raw sensor data becomes actionable. ThingsBoard v4.0 introduced Calculated Fields, a built-in logic layer that transforms incoming telemetry in real time without any external scripts or rule chains. We will create two calculated fields:

Overall Vibration Severity: combines X/Y/Z into a single ISO 10816 metric
Machine Status: classifies the severity into a human-readable health state

Best Practice Note: Instead of attaching a calculated field to a specific device (e.g., IoT1), it is recommended to attach it to a Device Profile. This way, the calculated field automatically applies to all devices sharing that profile, making your setup scalable and maintainable without duplicating configuration.

Create the calculated fields

Go to Profiles → Device Profiles → Open your device profile (‘Vibration Sensor’)Navigate to the Calculated Fields tab inside the profile. Click + and create a calculated field

Calculated Field 1: Overall Vibration Severity (ISO 10816)

Navigate to your Left tree menu→ Calculated Fields tab → click +.General settings:

Setting	Value
Title	Overall Vibration Severity (ISO 10816 compliant)
Type	Script

Add three arguments:

Argument name	Type	Key
plc_rSensorX_vrms	Latest telemetry	`plc_rSensorX_vrms`
plc_rSensorY_vrms	Latest telemetry	`plc_rSensorY_vrms`
plc_rSensorZ_vrms	Latest telemetry	`plc_rSensorZ_vrms`

Add this Script:

var vibration_severity = Math.sqrt(plc_rSensorX_vrms * 
    plc_rSensorX_vrms + plc_rSensorY_vrms * plc_rSensorY_vrms + 
    plc_rSensorZ_vrms * plc_rSensorZ_vrms);
return {
    "vibration_severity":  toFixed(vibration_severity,3)
}

Output: Time series

Why vector magnitude? Using sqrt(X² + Y² + Z²) rather than the maximum individual axis, it gives you the true Euclidean magnitude of the vibration vector. This is the correct approach for ISO 10816 compliance and eliminates false negatives, a situation where all three axes are below threshold individually, but combined vibration is dangerously high.

Calculated Field 2: Machine Status

Navigate to Calculated Fields → click + again.General settings:

Setting	Value
Title	Machine Status
Type	Script

Arguments:

Argument name	Type	Key	Default value
vibration_severity	Latest telemetry	`vibration_severity`	`0`

Setting a default value of 0 is important. Without it, if vibration_severity has not yet been computed, the argument receives null, the comparison fails, and the status incorrectly shows CRITICAL.

Add this Script:

if (vibration_severity < 2.3) {
        return { "machine_status": "HEALTHY" };
    } else if (vibration_severity < 4.5) {
        return { "machine_status": "WARNING" };
    } else if (vibration_severity < 7.1) {
        return { "machine_status": "CRITICAL" };
    } else {
        return { "machine_status": "EMERGENCY" };
    }

ISO 10816-3 zone reference:

Zone	Severity range	Status	Meaning
A	0 – 2.3 mm/s	HEALTHY	Good - new or recently serviced
B	2.3 – 4.5 mm/s	WARNING	Acceptable - monitor closely
C	4.5 – 7.1 mm/s	CRITICAL	Unsatisfactory - schedule maintenance
D	> 7.1 mm/s	EMERGENCY	Unacceptable - risk of damage

Step 5: Configure Alarms

Navigate to your Device Profile → Alarm Rules tab. Create three alarm rules based on vibration_severity:

Alarm 1: Motor Vibration Warning

Setting	Value
Condition	`return (vibration_severity > 2.3)`

Additional info:

[WARNING] Motor Vibration entering Zone B (ISO 10816) Severity: ${vibration_severity} mm/s | Threshold: 2.3 mm/s Axis breakdown — X: ${plc_rSensorX_vrms} mm/s | Y: ${plc_rSensorY_vrms} mm/s | Z: ${plc_rSensorZ_vrms} mm/s Action: Monitor closely. Schedule inspection if sustained.

Alarm 2: Motor Vibration Critical

Setting	Value
Condition	`return (vibration_severity > 4.5)`

Additional info:

[CRITICAL] Motor Vibration in Zone C — Maintenance Required (ISO 10816) Severity: ${vibration_severity} mm/s | Threshold: 4.5 mm/s Axis breakdown — X: ${plc_rSensorX_vrms} mm/s | Y: ${plc_rSensorY_vrms} mm/s | Z: ${plc_rSensorZ_vrms} mm/s Action: Reduce load and schedule immediate inspection.

Alarm 3: Motor Vibration Emergency

Setting	Value
Condition	`return (vibration_severity > 7.1`

Additional info:

[EMERGENCY] Motor Vibration in Zone D — Shutdown Risk (ISO 10816) Severity: ${vibration_severity_r} mm/s | Threshold: 7.1 mm/s Axis breakdown — X: ${plc_rSensorX_vrms_r} mm/s | Y: ${plc_rSensorY_vrms_r} mm/s | Z: ${plc_rSensorZ_vrms_r} mm/s Action: Stop machine immediately. Risk of mechanical damage.

Why use vibration_severity for alarms instead of individual axes?Alarming on individual X/Y/Z values creates two problems: false negatives (all axes below threshold but combined severity is dangerous) and false positives (one axis spikes from a single knock while overall severity stays in Zone A). The combined severity metric is ISO-compliant and gives a much cleaner alarm signal.

Step 6: Build the Dashboard

Machine Health card (HTML Value Card)

Add widget → Cards → HTML Value CardType: EntityData key: machine_statusNavigate to ‘Appearance’. Paste the following into the HTML section:

<!DOCTYPE html>
<html>
<head></head>
<body style="margin:0; padding:0;">
<div class="card" id="statusCard">
  <div class="content">
    <div style="text-align:center; width:100%;">
      <div style="font-size:13px; color:white; opacity:0.8;">Machine Health</div>
      <div style="font-size:28px; font-weight:bold; color:white;">${machine_status}</div>
    </div>
  </div>
</div>

<script>
  var status = '${machine_status}';
  var card = document.getElementById('statusCard');
  if (status === 'HEALTHY') {
    card.style.backgroundColor = '#4CAF50';
  } else if (status === 'WARNING') {
    card.style.backgroundColor = '#FFEB3B';
  } else if (status === 'CRITICAL') {
    card.style.backgroundColor = '#FF9800';
  } else {
    card.style.backgroundColor = '#F44336';
  }
</script>
</body>
</html>

Replace the CSS section with:

.card {
    width: 100%;
    height: 100%;
    box-sizing: border-box;
    border: none;
}

.card .content {
    padding: 20px;
    display: flex;
    flex-direction: row;
    align-items: center;
    justify-content: center;
    height: 100%;
}

Widget 1: Warning Card

Click + Add widget → Cards → Alarm count
Configure:

Setting	Value
Label	Warnings
Alarm severity filter	Warning
Alarm status filter	Active
Icon	Warning triangle, Size 20px
Icon color	White
Icon background	`#2E7D6B` (dark teal, as shown)

Widget 2: Critical Alarms Card

Same steps as above but:

Setting	Value
Label	Critical Alarms
Alarm severity filter	Critical
Icon background	`#C62828` (dark red)

Widget 3: Motor Image

Click + Add widget → Traditional SCADA Fluid system→ Right motor pump

Setting	Value
Running	`True`
Warning State	Use alarm status: Warning Alarm Type: Motor Vibration
Critical State	Use alarm status: Critical and Major Alarm Type: Motor Vibration

Vibration Severity Gauge (ISO 10816 bands)

Add widget → Gauges → Speed GaugeType: EntityAntity Alias: OpenPLCData key: vibration_severityConfigure the colour bands to match ISO 10816 zones in the Scale settings:

From	To	Colour
0	2.3	`#4CAF50` (green)
2.3	4.5	`#FFEB3B` (yellow)
4.5	7.1	`#FF9800` (orange)
7.1	10.0	`#F44336` (red)

Additional settings:

Setting	Value
Min	`0`
Max	`10`
Decimals	`1`
Units	`mm/s`
Title	`Vibration Severity (ISO 10816)`

Tri-Axial Vibration Chart

Add widget → Charts → Time series chartData keys: plc_rSensorX_vrms, plc_rSensorY_vrms, plc_rSensorZ_vrms

Motor Temperature Trend

Similarly, you can also make a trend of Motor Temperature

Vibration Severity Trend Chart

Add widget → Charts → Time series chartData key: vibration_severityAdd threshold lines at 2.3, 4.5, and 7.1 mm/s so operators can immediately see how close the severity is to each ISO zone boundary.

Add Alarm Table

Add widget → Tables→ Alarms table

Setting	Value
Time window	Use widget time window
Alarm source	Entity Alias > MachineData
Alarm Status list	Active Cleared Acknowledged Unacknowledged
Alarm Severity list	Critical Major Warning
Alarm type list	Motor Vibration

Final dashboard layout

Arrange the widgets as follows for the clearest operator view:

┌─────────────────┬──────────────────────────┬──────────────────────────┐
│ Machine Health  │ Tri-Axial Vibration       │ Motor Temperature Trend  │
│ (colour card)   │ (X/Y/Z time series)       │ (line chart)             │
│                 │                           │                          │
│ Warnings: 0     ├──────────────────────────┼──────────────────────────┤
│                 │ Vibration Severity        │ Vibration Severity       │
│ Critical: 0     │ (trend chart with         │ (ISO 10816 gauge)        │
│                 │  ISO threshold lines)     │                          │
│ Motor image     │                           │                          │
│                 ├───────────────────────────┴──────────────────────────┤
│ Temperature     │ Alarms table (full width)                            │
└─────────────────┴──────────────────────────────────────────────────────┘

Reading order:The left column gives instant health status. The centre column shows the vibration detail over time. The right column shows the temperature and the ISO-calibrated gauge. The alarms table at the bottom provides a full audit history.

How It All Connects

Looking back at the full pipeline:

The Balluff BCM sensor measures tri-axial vibration (X/Y/Z RMS) and temperature continuously
The Balluff IO-Link Master exposes sensor data over Modbus TCP
The reComputer vPLC reads registers every scan cycle, byte-swaps Big-Endian floats, and exposes clean REAL values via its OPC UA server
Node-RED on the reComputer R1100 polls the OPC UA server every second and publishes a JSON payload to ThingsBoard via MQTT
ThingsBoard Calculated Fields compute vibration severity (sqrt(X²+Y²+Z²)) and classify machine health (HEALTHY / WARNING / CRITICAL / EMERGENCY) in real time, no external scripts needed
Alarm rules fire when severity crosses ISO 10816 zone boundaries, with structured alarm messages including rounded axis values
The dashboard gives operators instant visual feedback through a colour-coded health card, ISO-banded gauge, and trend charts

Resources

ThingsBoard Dashboard

machine_dashboard (1).json

To learn how to import a dashboard, kindly refer to the last article here ThingsBoard (Edge Setup)

Work With Me

I regularly test industrial automation and IIoT devices. If you’d like me to review your product or showcase it in my courses and YouTube channel: Email: rajvir@codeandcompile.com or drop me a message on LinkedIn

Smart platforms

Virtual PLCs

MQTT and edge data

IoT platforms and alerts

Real-Time Vibration Monitoring with ThingsBoard and Calculated Fields

Hardware & Software Used

Hardware

Software

System Architecture

Step 1: Hardware Setup (vPLC + IO-Link)

Step 2: Expose vPLC Data via OPC UA

Step 3: Bridge OPC UA to MQTT using Node-RED

How to Link your device to the “Vibration Sensor” device Profile

Step 4: Create Calculated Fields in ThingsBoard

Step 5: Configure Alarms

Alarm 1: Motor Vibration Warning

Alarm 2: Motor Vibration Critical

Alarm 3: Motor Vibration Emergency

Step 6: Build the Dashboard

How It All Connects

Resources

ThingsBoard Dashboard

machine_dashboard (1).json

Work With Me

​Want to get started with ThingsBoard? Sign up here.

​Hardware & Software Used

​Hardware

​Software

​System Architecture

​Step 1: Hardware Setup (vPLC + IO-Link)

​Step 2: Expose vPLC Data via OPC UA

​Step 3: Bridge OPC UA to MQTT using Node-RED

​How to Link your device to the “Vibration Sensor” device Profile

​Step 4: Create Calculated Fields in ThingsBoard

​Step 5: Configure Alarms

​Alarm 1: Motor Vibration Warning

​Alarm 2: Motor Vibration Critical

​Alarm 3: Motor Vibration Emergency

​Step 6: Build the Dashboard

​How It All Connects

​Resources

​ThingsBoard Dashboard

machine_dashboard (1).json

​Work With Me

Want to get started with ThingsBoard? Sign up here.

Hardware & Software Used

Hardware

Software

System Architecture

Step 1: Hardware Setup (vPLC + IO-Link)

Step 2: Expose vPLC Data via OPC UA

Step 3: Bridge OPC UA to MQTT using Node-RED

How to Link your device to the “Vibration Sensor” device Profile

Step 4: Create Calculated Fields in ThingsBoard

Step 5: Configure Alarms

Alarm 1: Motor Vibration Warning

Alarm 2: Motor Vibration Critical

Alarm 3: Motor Vibration Emergency

Step 6: Build the Dashboard

How It All Connects

Resources

ThingsBoard Dashboard

Work With Me