How to Monitor Factory Machines in Real Time with MQTT and a Self-Hosted Dashboard

Stack Architecture

The monitoring stack follows a layered architecture that is well-established in industrial IIoT deployments. Each layer has a single responsibility and the components are loosely coupled any layer can be replaced or upgraded without rebuilding the others.

Gateway Machine Setup

All software components run on a single gateway machine located inside the factory network. A Raspberry Pi 4 (4 GB RAM), an industrial edge PC, or any Linux machine on the same network segment as the PLCs and sensors is sufficient for a production line with up to several dozen data points. For larger installations with hundreds of devices, a dedicated x86 industrial PC is recommended.

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl wget git

Step 1: Install the Mosquitto MQTT Broker

sudo apt install -y mosquitto mosquitto-clients

sudo systemctl enable mosquitto
sudo systemctl start mosquitto

Create a configuration file with authentication:

sudo nano /etc/mosquitto/conf.d/factory.conf

listener 1883 127.0.0.1
allow_anonymous false
password_file /etc/mosquitto/passwd

Create a user for Node-RED and Telegraf to connect with:

sudo mosquitto_passwd -c /etc/mosquitto/passwd factoryuser

sudo systemctl restart mosquitto

Test that the broker is accepting connections:

mosquitto_sub -h 127.0.0.1 -u factoryuser -P yourpassword -t factory/# &

Step 2: Install InfluxDB

curl https://repos.influxdata.com/influxdata-archive.key | \
  gpg --dearmor | sudo tee /usr/share/keyrings/influxdata-keyring.gpg > /dev/null

echo "deb [signed-by=/usr/share/keyrings/influxdata-keyring.gpg] \
  https://repos.influxdata.com/debian stable main" | \
  sudo tee /etc/apt/sources.list.d/influxdata.list

sudo apt update
sudo apt install -y influxdb2

sudo systemctl enable influxdb
sudo systemctl start influxdb

Complete the initial setup by visiting http://localhost:8086 in a browser on the gateway machine, or run the setup command directly:

influx setup \
  --username admin \
  --password yourpassword \
  --org factory \
  --bucket machines \
  --retention 30d \
  --force

Note the API token generated during setup Telegraf and Grafana both need it to authenticate with InfluxDB.

Step 3: Node-RED Modbus to MQTT Bridge

Node-RED polls Modbus TCP registers from PLCs and sensors, transforms the raw register values into structured JSON payloads, and publishes them to the MQTT broker. This is the protocol translation layer that converts the pull-based Modbus world into the event-driven MQTT world.

# Install Node-RED
sudo npm install -g --unsafe-perm node-red

# Install the Modbus TCP node palette
cd ~/.node-red
npm install node-red-contrib-modbus

# Start Node-RED
node-red

Open the Node-RED editor at http://localhost:1880 and install the Modbus nodes from the Manage Palette menu if you prefer the UI approach.

Building the Modbus to MQTT flow

The flow reads holding registers from a Modbus TCP device and publishes the values to MQTT topics. The example below reads three registers from a PLC at 192.168.10.10: temperature (register 40001), pressure (register 40002), and motor speed (register 40003).

In the Node-RED editor, build a flow with the following nodes connected in sequence:

// Node-RED function node: transform Modbus registers to structured JSON
var registers = msg.payload;

// Apply scaling if raw values need conversion
// Example: register value 2240 represents 22.40 degrees (divide by 100)
msg.payload = {
    temperature: registers[0] / 100,
    pressure: registers[1] / 10,
    motor_speed: registers[2],
    timestamp: new Date().toISOString(),
    line: "line1",
    machine: "press_01"
};

msg.topic = "factory/line1/press_01";

return msg;

Deploy the flow. Open a terminal and verify the data is arriving on the broker:

mosquitto_sub -h 127.0.0.1 -u factoryuser -P yourpassword -t factory/#

You should see JSON payloads arriving every two seconds:

{"temperature":22.4,"pressure":4.7,"motor_speed":1450,"timestamp":"2025-03-10T08:42:01.123Z","line":"line1","machine":"press_01"}

Step 4: Telegraf — MQTT to InfluxDB

Telegraf subscribes to the MQTT broker and writes incoming messages to InfluxDB. It is the persistence layer between the real-time event stream and the historical database.

sudo apt install -y telegraf

Create the Telegraf configuration for this factory setup:

sudo nano /etc/telegraf/telegraf.conf

[agent]
  interval = "10s"
  flush_interval = "10s"

# MQTT input plugin — subscribes to all factory topics
[[inputs.mqtt_consumer]]
  servers = ["tcp://127.0.0.1:1883"]
  topics = ["factory/#"]
  username = "factoryuser"
  password = "yourpassword"
  data_format = "json"
  json_time_key = "timestamp"
  json_time_format = "2006-01-02T15:04:05.000Z"
  tag_keys = ["line", "machine"]

# InfluxDB v2 output plugin
[[outputs.influxdb_v2]]
  urls = ["http://127.0.0.1:8086"]
  token = "YOUR_INFLUXDB_TOKEN"
  organization = "factory"
  bucket = "machines"

sudo systemctl enable telegraf
sudo systemctl start telegraf
sudo systemctl status telegraf

Verify data is being written to InfluxDB by querying the bucket from the InfluxDB UI at http://localhost:8086 or from the CLI:

influx query 'from(bucket:"machines") |> range(start: -5m) |> limit(n:5)'

Step 5: Grafana Dashboard

sudo apt install -y apt-transport-https software-properties-common wget

sudo mkdir -p /etc/apt/keyrings/
wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | \
  sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] \
  https://apt.grafana.com stable main" | \
  sudo tee /etc/apt/sources.list.d/grafana.list

sudo apt update
sudo apt install -y grafana

sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Open http://localhost:3000 and log in with admin and the password you set.

Example Flux query for the latest temperature from line 1:

from(bucket: "machines")
  |> range(start: -1h)
  |> filter(fn: (r) => r["_measurement"] == "mqtt_consumer")
  |> filter(fn: (r) => r["line"] == "line1")
  |> filter(fn: (r) => r["_field"] == "temperature")
  |> aggregateWindow(every: 30s, fn: mean, createEmpty: false)
  |> yield(name: "mean")

Step 6: Remote Access to the Dashboard with Localtonet

The Grafana dashboard at port 3000 is only accessible on the gateway machine and local network by default. To give production managers, maintenance engineers, and off-site personnel access from any browser, create a Localtonet HTTP tunnel for port 3000.

curl -fsSL https://localtonet.com/install.sh | sh
localtonet --authtoken <YOUR_TOKEN>

Go to the HTTP tunnel page, set local IP to 127.0.0.1 and port to 3000. Click Create and start the tunnel. The dashboard shows a public HTTPS URL share it with authorised personnel.

Register Localtonet as a service so the tunnel comes back automatically after a gateway reboot:

sudo localtonet --install-service --authtoken <YOUR_TOKEN>
sudo localtonet --start-service --authtoken <YOUR_TOKEN>

Security Recommendations

# Create a dated backup
influx backup /var/backups/influxdb/$(date +%Y%m%d) \
  --token YOUR_INFLUXDB_TOKEN

Frequently Asked Questions