ThingsBoard (Edge Setup)

This guide shows how to build a complete end-to-end IIoT system using ThingsBoard running on an edge device and simulated telemetry data.

Unlike fragmented solutions that require multiple tools glued together, ThingsBoard provides the full system operators actually use, from device connectivity to role-based dashboards, out of the box.

By the end of this guide, you will have:

• ThingsBoard running on a reComputer R2100

• A device connected via MQTT

• Simulated telemetry generated from Node-RED. In our guide, we will be using Node-RED to emulate device data for this setup. Learn more about Node-RED here

• A live industrial dashboard (motor, energy, vibration, etc.)

• Optional RPC control from the dashboard to the device

Want to get started with ThingsBoard? Sign up here.

Hardware & Software Used

Hardware

• reComputer R2100 (Edge device) from Seeed Studio

• Development PC / Laptop

Software

• ThingsBoard Community Edition (CE)

• Node-RED (for sending simulated telemetry data)

• MQTT Broker (built into ThingsBoard)

---

Step 1 – Install ThingsBoard on the reComputer R2100

You can use any Linux-based edge device with at least 4GB of RAM. Get more information here

1

Log in to reComputer via Putty

2

Install ThingsBoard

You can follow the instructions given on thingsBoard documentation here: https://thingsboard.io/docs/user-guide/install/rpi/?utm_source=inf&utm_medium=rjvr&utm_campaign=edgesetup

Once you have finished installing ThingsBoard, come back here.

Step 2- Start ThingsBoard and open the WebUI

1

Start ThingsBoard on your edge device

sudo service thingsboard start

2

Open WebUI

Open this on your browser: http://192.168.0.195:8080 where 192.168.0.195 is the IP address of the edge device.

3

Log in as Admin

Log in using the following credentials:

• Username: [e-mail]

• Password: sysadmin

4

Create a new Tenant

Multitenancy in ThingsBoard enables you to manage multiple organizations within a single system. Each tenant works like an independent environment with its own users, devices, and dashboards.

The steps to create the tenant are given here: https://thingsboard.io/docs/user-guide/ui/tenants/?utm_source=inf&utm_medium=rjvr&utm_campaign=edgesetup

5

Add the user in the Tenant as 'Admin'

The System administrator can also create multiple users with the Tenant Administrator role in each tenant.

6

Log in as 'Tenant user.'

Step 3- Add a new device and send a test value

Let's add a device that sends telemetry data to ThingsBoard.

1

Add a device

The detailed steps of instructions on adding a device are given here: https://thingsboard.io/docs/getting-started-guides/helloworld/?utm_source=inf&utm_medium=rjvr&utm_campaign=edgesetup

2

Select the communication protocol

There are multiple ways to connect to the ThingsBoard device. In our example, we will use MQTT.

3

Get ThingsBoard MQTT connection details

The ThingsBoard has an internal MQTT Broker running on port 1883. You will find more details for the connection in the wizard.

mosquitto_pub -d -q 1 -h 192.168.0.195 -p 1883 -t v1/devices/me/telemetry -u "IPOJzEMJHs0wWhzz2K3R" -m "{temperature:25}"

In the above lines of code, we can extract the following information needed to send telemetry data to ThingsBoard via MQTT:

• Broker URL: 192.168.0.195 (IP Address of the edge device)

• MQTT Port: 1883

• MQTT Topic: v1/devices/me/telemetry

• Username: IPOJzEMJHs0wWhzz2K3R

• Password: — leave blank --

4

Send a test value to ThingsBoard via MQTT

Take the inject node as 'Timestamp' with an interval of 1 second.

Add a function node to simulate temperature value

let number = Number((Math.random() * 100).toFixed(2));
msg.payload = {
    temperature: number
}
return msg;

Take the MQTT out node and set up the ThingsBoard's MQTT broker parameters as shown in the image:

Enter the username:

Define the MQTT topic:

Once the connection is established, send a test value as 'temperature':

Open the telemetry log to view the temperature value. Navigate to Entities > Devices > IoT1 > Latest Telemetry

Step 4- Update telemetry data in the Node-RED

To visualize multiple parameters on the ThingsBoard dashboard, we need additional telemetry data. Use the following code in the function node of Node-RED.

// Rich telemetry generator for ThingBoard dashboards
// Put this in a Function node and trigger it every 1s-5s with an Inject node.

let s = context.get('s') || {
    t: 0,
    baseTemp: 24,
    baseHum: 48,
    motorOn: true,
    speedRpm: 900,
    energyKWh: 0,
    runtimeSec: 0,
    cycleCount: 0,
    lastCycleT: 0,
    fault: false,
    faultCode: 0
};

s.t += 1;

// Helpers
function clamp(v, min, max) { return Math.max(min, Math.min(max, v)); }
function rand(min, max) { return min + Math.random() * (max - min); }
function chance(p) { return Math.random() < p; }

// ---- Motor state machine (feels realistic)
if (chance(0.02)) s.motorOn = !s.motorOn;              // occasional start/stop
if (chance(0.01) && !s.fault) {                        // rare fault event
    s.fault = true;
    s.faultCode = [101, 202, 303, 404][Math.floor(Math.random() * 4)];
}
if (s.fault && chance(0.15)) {                         // fault clears after some time
    s.fault = false;
    s.faultCode = 0;
}

// Speed ramping
let targetRpm = s.motorOn && !s.fault ? rand(800, 1450) : 0;
s.speedRpm = s.speedRpm + (targetRpm - s.speedRpm) * 0.15;
s.speedRpm = clamp(s.speedRpm, 0, 1600);

// ---- Environmental signals (slow drift + small noise)
let dayWave = Math.sin(s.t / 120) * 1.5;               // slow wave
s.baseTemp += rand(-0.02, 0.02);
s.baseHum += rand(-0.05, 0.05);

let temperature = clamp(s.baseTemp + dayWave + rand(-0.2, 0.2), 18, 35);
let humidity    = clamp(s.baseHum - dayWave + rand(-0.5, 0.5), 30, 70);

// ---- Vibration rises with RPM + faults
let vibBase = (s.speedRpm / 1600) * 4.0;               // 0..4 mm/s
let vibrationRms = vibBase + rand(0.1, 0.5);
if (s.fault) vibrationRms += rand(2, 5);               // big increase when faulty
vibrationRms = clamp(vibrationRms, 0, 12);

// ---- Current / Power / Energy
let currentA = s.motorOn && !s.fault ? clamp((s.speedRpm / 1600) * 7 + rand(0, 1), 0, 10) : rand(0, 0.3);
if (s.fault) currentA += rand(2, 4);

let voltageV = 230 + rand(-3, 3);
let powerW = clamp(voltageV * currentA * 0.85, 0, 4000);   // rough PF/efficiency

// energy integration: Wh per second -> kWh
s.energyKWh += (powerW / 1000) / 3600;

// ---- Production-ish signals
if (s.motorOn && !s.fault) s.runtimeSec += 1;

// create a "cycle" every ~15-35 seconds when running
if (s.motorOn && !s.fault && (s.t - s.lastCycleT) > rand(15, 35)) {
    s.cycleCount += 1;
    s.lastCycleT = s.t;
}
let cycleTimeSec = s.motorOn && !s.fault ? clamp((s.t - s.lastCycleT), 0, 60) : null;

// ---- Quality / OEE-ish
let rejectRate = s.fault ? rand(3, 12) : rand(0.3, 2.0);   // %
let goodParts = Math.round(s.cycleCount * (1 - rejectRate / 100));
let availability = clamp((s.runtimeSec / s.t) * 100, 0, 100);

// ---- Alarm levels (nice for color-changing widgets)
let alarmLevel = 0;
if (temperature > 30 || vibrationRms > 7) alarmLevel = 1;
if (s.fault || vibrationRms > 9) alarmLevel = 2;

// Build payload
msg.payload = {
    // Environment
    temperature: Number(temperature.toFixed(2)),          // °C
    humidity: Number(humidity.toFixed(2)),                // %

    // Machine
    motorOn: s.motorOn && !s.fault,                       // boolean
    speedRpm: Math.round(s.speedRpm),
    vibrationRms: Number(vibrationRms.toFixed(2)),        // mm/s
    currentA: Number(currentA.toFixed(2)),                // A
    voltageV: Number(voltageV.toFixed(1)),                // V
    powerW: Math.round(powerW),                           // W
    energyKWh: Number(s.energyKWh.toFixed(3)),            // kWh

    // Production / KPIs
    cycleCount: s.cycleCount,
    cycleTimeSec: cycleTimeSec === null ? null : Number(cycleTimeSec.toFixed(1)),
    goodParts: goodParts,
    rejectRate: Number(rejectRate.toFixed(2)),            // %
    availability: Number(availability.toFixed(1)),        // %

    // Faults / Alarms
    fault: s.fault,
    faultCode: s.faultCode,
    alarmLevel: alarmLevel                               // 0 normal, 1 warn, 2 critical
};

context.set('s', s);
return msg;

This updated code will give you multiple simulated values as shown below:

Step 5- Create Dashboard

We will now create a dashboard to visualize telemetry data. The step-by-step information on creating the dashboard is given here: https://thingsboard.io/docs/user-guide/dashboards/?utm_source=inf&utm_medium=rjvr&utm_campaign=edgesetup

1

Add new widget

Open your dashboard and click on 'Add new widget'

2

Select 'Cards' in the widget bundle

3

Select Label & value card

4

Configure the parameters

• Locate your IoT device. In our case, it is 'IoT1.'

• Update the label to 'Temperature.'

• Update the icon and color as required.

• Click on 'Add'

💡 Best practice (recommended for shared dashboards)

In production or reusable dashboards, avoid selecting a fixed Device. Instead, use an Entity Alias resolved from the dashboard state.

This allows the same dashboard to work across different devices and instances.

5

Visualize the Dashboard

You will instantly see the Temperature value on the dashboard

Step 6- Import dashboard

ThingsBoard makes it really easy to share a dashboard. Follow these steps to duplicate my ThingsBoard dashboard.

1

Click on Add Dashboard > Import

2

Download my dashboard

Click on the file below to keep a copy of the dashboard

dashboard.json

147KB

Open

3

🔁 About Entity Alias & Reusability (Important)

This dashboard is exported using an entity alias instead of a fixed device.

What this means:

• The dashboard is not hard-coded to a specific device

• It can be reused across different ThingsBoard instances

• All widgets dynamically resolve the device from the dashboard state

During import, ThingsBoard will automatically use the default state entity defined in the dashboard. You can change this at any time to point the dashboard to your own device.

---

Importing Dashboard

Drag and drop the file into the wizard, then click 'Import.' You will find the imported dashboard in the list.

---

After importing the dashboard

If your device name is different from IoT1, follow these steps:

1. Open the imported dashboard

2. Click Edit → Aliases

3. Select the alias (for example: IoT1)

4. Choose your own Device

5. Save the dashboard

All widgets will update automatically. Click it to view all sample telemetry data on your screen.

Enjoy exploring the dashboard elements.

---

Why Entity Alias is recommended

Using Entity Alias instead of selecting a device directly:

• Makes dashboards portable and shareable

• Prevents broken widgets after import

• Allows the same dashboard to work with multiple devices

• Follows ThingsBoard's best practices for production dashboards

♥️ 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: [e-mail] or drop me a message on LinkedIn