> ## Documentation Index
> Fetch the complete documentation index at: https://wiki.codeandcompile.com/llms.txt
> Use this file to discover all available pages before exploring further.
# From Prompt to Live Dashboard with ThingsBoard AI
> Build a live motor dashboard with ThingsBoard AI in about 90 minutes: one prompt for an RPM gauge, a Node-RED simulation over secure MQTT, an AI-expanded overview and AI-created alarm rules.
**Build a live motor dashboard with AI in about 90 minutes.**
Start with one RPM gauge, then expand it with AI. Your PC sends simulated motor data from Node-RED; no physical motor is needed.
You will use prompts to create the device, dashboard and alarm rules, then approve the proposed changes. Node-RED supplies the data; AI designs the display. Start with the simple gauge so you can check the connection before adding more widgets.
> [!NOTE]
>
> **Part of the Code & Compile ThingsBoard series.** [ThingsBoard (Edge Setup)](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/thingsboard-edge-setup.md) built the same simulated motor on a local ThingsBoard Edge, and [Real-Time Vibration Monitoring with ThingsBoard and Calculated Fields](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/real-time-vibration-monitoring-with-thingsboard-and-calculated-fields.md) used a real Balluff sensor with hand-built rules. This guide moves to ThingsBoard Cloud and lets AI do the dashboard and alarm work.
**By the end of this guide, you will have:**
* Your local **Node-RED simulation** connected to ThingsBoard Cloud over **MQTT**.
* A compact motor dashboard built with the **Configure with AI** feature in ThingsBoard, including electrical readings and vibration trends.
* **Alarm conditions** for motor faults, high vibration and high temperature.
Allow **about 90 minutes** for registration, Node-RED motor simulation setup and checks, or about 60 minutes if your ThingsBoard account and Node-RED are ready. Optional manual styling comes last.
### Five steps, from your first prompt to alarms
> [card] [Step 1: Create your account](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/from-prompt-to-live-dashboard-with-thingsboard-ai.md#step-1-create-your-cloud-account)
>
> Sign in to ThingsBoard Cloud EU.
> [card] [Step 2: Prompt a simple gauge](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/from-prompt-to-live-dashboard-with-thingsboard-ai.md#step-2-create-a-simple-rpm-dashboard)
>
> Create one motor device and an RPM dashboard.
> [card] [Step 3: Connect live simulation](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/from-prompt-to-live-dashboard-with-thingsboard-ai.md#step-3-connect-the-example-node-red-simulation)
>
> Import our Node-RED flow and link it over MQTT.
> [card] [Step 4: Expand with AI](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/from-prompt-to-live-dashboard-with-thingsboard-ai.md#step-4-build-the-bigger-dashboard-with-ai)
>
> Add readings, trends and a Details view.
> [card] [Step 5: Add and check alarms](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/from-prompt-to-live-dashboard-with-thingsboard-ai.md#step-5-add-alarm-conditions-with-ai)
>
> Set fault, vibration and temperature conditions.
### Before you start
Use these Code & Compile resources if you need the basics:
* **ThingsBoard:** The [introduction](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard) explains the platform; [Cloud Setup](https://wiki.codeandcompile.com/product-reviews/smart-platforms/virtual-plcs/autonomy-edge-openplc-redefined/openplc-with-python-fb.md#thingsboard-cloud-setup) covers registration and credentials.
* **Node-RED:** Browse the [learning resources](https://wiki.codeandcompile.com/iiot/iiot-tools/node-red). Install it using the official [Windows guide](https://nodered.org/docs/getting-started/windows) or [other installation options](https://nodered.org/docs/getting-started/).
* **Edge demo:** This guide reuses its [MQTT example](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/thingsboard-edge-setup.md#step-3-add-a-new-device-and-send-a-test-value) and [motor simulation](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/thingsboard-edge-setup.md#step-4-update-telemetry-data-in-the-node-red) as an importable flow. Here, **ThingsBoard Cloud EU** and AI replace the local ThingsBoard setup. No PLC project or Python/HTTP example is needed.
> [!TIP]
>
> **Want to get started with ThingsBoard Cloud?**
>
> Create an account or sign in [here](https://eu.thingsboard.cloud/home).
### Hardware & Software Used
**Hardware**
* Development PC / laptop with an internet connection. No physical motor is needed.
**Software**
* ThingsBoard Cloud EU with **Tenant Administrator** access. The [EU Free plan includes 2.5 million monthly AI credits; Prototype includes 4 million](https://thingsboard.io/docs/paas/eu/reference/subscriptions/). Free can complete this guide with sufficient remaining credits and device, telemetry, storage and alarm allowances. Check **API usage** before Step 2; repeated AI changes consume more credits.
* [Node-RED](https://nodered.org/docs/getting-started/) running on your PC.
* The example Node-RED project attached in Step 3.
Keep your Cloud account and Node-RED editor open in separate browser tabs. You will move between them to copy device credentials, publish data and check the dashboard.
***
### Step 1 – Create your Cloud account
Open [ThingsBoard Cloud EU](https://eu.thingsboard.cloud/home). Sign in or select **Sign up**, complete registration, and verify your email.
ThingsBoard Cloud EU sign-in page.
Use **Tenant Administrator** access. Let AI create **Industrial Motor 01** in Step 2; do not manually add another device.
### Step 2 – Create a simple RPM dashboard
**1. Enter the simple prompt**
Open **AI solution creator → New solution** and enter:
```
Create a dashboard named Motor RPM for one device
named Industrial Motor 01. Show only the latest
speedRpm in a gauge from 0 to 1600 RPM.
The data will come from my local Node-RED simulator
over MQTT.
```
The simple prompt in AI Solution Creator.
**2. Review and create the solution**
Select **Skip interview** if offered. Check the proposed device name, **speedRpm** key, and **0–1600 RPM** gauge. The telemetry key is the name Node-RED sends; it must match exactly, including capital letters.
**Review the full proposal.** Approve only one motor device and its RPM dashboard. Ask AI to remove unrequested users, roles, assets, devices, calculated fields, alarm rules or emulators before installing; alarms come in Step 5.
Continue through **Dashboard Design**, then click **Create Solution**.
Open **Motor RPM**. Connect Node-RED next to supply its data.
Already have a motor dashboard? Export a backup, then use **Configure with AI** on it instead of installing another solution.
### Step 3 – Connect the example Node-RED simulation
The attached flow packages the Edge demo's motor simulation with a secure MQTT connection. Install Node-RED first using the links under **Before you start**.
**1. Import the project**
Start Node-RED and open [localhost:1880](http://localhost:1880). Select **Menu → Import**, choose the attached JSON project, and click **Import**. Reuse the existing flow if it is already imported; running two copies would publish duplicate samples.
> [card] [industrial-motor-cloud-flow.json](https://raw.githubusercontent.com/Code-and-Compile/wiki-docs/main/wiki/.gitbook/assets/industrial-motor-cloud-flow.json)
Inject → motor simulation → JSON → ThingsBoard MQTT, with Debug samples.
**Import only the JSON project.** It contains the complete `Industrial motor simulator` Function. The plain-text source under **Resources** is optional; do not add another simulator.
The Inject node starts each sample. The Function calculates the motor readings, JSON serialization prepares the message, and the MQTT node sends it to ThingsBoard. Debug lets you inspect the same readings locally.
**2. Link the motor device**
In ThingsBoard, open **Devices & assets → Devices → Industrial Motor 01**. Select **Manage credentials → Access token → Copy access token**, or use its **Copy access token** shortcut.
The motor device's credential controls.
New to device access tokens? The [Edge Setup guide](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/thingsboard-edge-setup.md#get-thingsboard-mqtt-connection-details) shows step by step where to find a device's MQTT connection details.
In Node-RED, double-click **Publish to ThingsBoard Cloud EU** and edit its Server configuration. The download already has these connection settings; enter only your token under **Security → Username**:
| Setting | Value |
| - | - |
| Server | `mqtt.eu.thingsboard.cloud` |
| Port | `8883` |
| TLS | Enabled, with server certificate verification |
| Security → Username | **Your motor device access token** |
| Security → Password | Leave blank |
| Topic | `v1/devices/me/telemetry` |
| QoS / Retain | `1` / `false` |
MQTT uses port 8883 with TLS and certificate verification.
Click **Update → Done → Deploy**. The Inject node sends **every 5 seconds**. Check that MQTT shows **connected**.
If it stays disconnected, recheck the hostname, token and internet connection. Use the token belonging to **Industrial Motor 01**, not another device: that token determines which device receives the data.
> [!WARNING]
>
> Keep your token private. Never disable certificate verification or include the token in shared project files.
**3. Check the data in ThingsBoard**
1. Open **Devices & assets** in ThingsBoard.
2. Click **Devices**.
3. Open **Industrial Motor 01**.
4. Click **Latest telemetry**.
5. Find **speedRpm**, the simulated motor speed.
6. Watch its value and **Last update time** for at least 15 seconds. Timestamps should advance every 5 seconds.
7. Open **Dashboards**.
8. Open **Motor RPM** to see the gauge follow the speed.
Latest speedRpm and its update time.
Briefly pause the local publisher: timestamps should stop, then resume when you restart it. **0 RPM can simply mean that the simulated motor is stopped.**
The Motor RPM gauge follows the simulated speed.
### Step 4 – Build the bigger dashboard with AI
> [!NOTE]
>
> AI layouts can vary. Use the same telemetry keys and supported widgets; the arrangement need not match the images exactly.
Open **Motor RPM** and click **Configure with AI**. Keep the existing device and refine the installed dashboard; do not click Create Solution again.
Use built-in status cards, a ring or arc RPM gauge, charts and navigation. Keep the main screen focused on motor health; the Details view holds the secondary measurements.
Configure with AI opens beside the dashboard.
Paste this prompt:
```
Update this dashboard for the existing Industrial
Motor 01. Rename it Motor Overview and keep the same
device alias and live MQTT telemetry.
Make a compact industrial panel using built-in widgets
and their default card appearance:
Top: four compact horizontal label-and-value cards
for voltageV (V), currentA (A), powerW (W) and
energyKWh (kWh). Avoid square cards with cramped text.
Middle: standard status cards for Motor Status from
motorOn and Motor Fault from fault on the left.
In the centre, use a basic ring or arc gauge for the
latest speedRpm, with a scale from 0 to 1600 RPM.
On the right, add a wide orange vibrationRms chart.
Use a real-time telemetry window of the last 1 minute
with no aggregation, so a short demo shows raw values.
Show minimum, maximum, average and latest vibration.
Bottom: a compact device Alarms Table showing time,
type, severity and status, including cleared history.
Move temperature, humidity, availability, cycleCount,
cycleTimeSec, goodParts, rejectRate, faultCode and
alarmLevel, plus the speedRpm trend, into a Details
state. Use compact horizontal value cards there too.
Add small Details and Back navigation buttons.
Keep it readable and uncluttered. Reuse built-in
widgets. Do not create devices, emulators, motor
controls, notifications or alarm rules in this step.
Show the proposed changes for approval.
```
Review each proposal, **Approve** the intended changes, and save. Check readability; request horizontal label-and-value cards if square cards make values too small.
Check the rendered dashboard, not just the text proposal. Its widgets must still point to the existing motor device, with readings updating from Node-RED.
Read cycle time only while **motorOn=true**: the simulator sends null for **cycleTimeSec** while stopped, and a widget may retain its last non-null value.
To view your larger dashboard:
1. Open **Dashboards**.
2. Open **Motor Overview**.
3. Watch the electrical values, RPM gauge and vibration chart change as the simulation runs.
4. Click **Details** to see the secondary measurements.
5. Click **Back** to return to the overview.
*Motor Overview showing simulated readings and cleared alarms.*
### Step 5 – Add alarm conditions with AI
An **Alarms Table** displays alarms; the rules below create them.
**1. Open the alarm assistant**
Open **Alarms → Alarm rules → Configure with AI**. Confirm that the assistant targets **Industrial Motor 01** before approving any changes.
The three motor alarm rules.
**2. Give the alarm prompt**
```
Create or update three alarm rules for the existing
device Industrial Motor 01. Use latest telemetry,
immediate conditions and an always-active schedule.
Motor Fault: CRITICAL when fault=true.
Clear when fault=false.
High Vibration: WARNING when vibrationRms >7 and <=9;
CRITICAL when vibrationRms >9. Clear when <=7 mm/s.
High Temperature: WARNING when temperature >30 °C.
Clear when temperature <=30 °C.
Treat missing data as unknown, not zero or false.
Reuse matching rules; do not create duplicate devices
or alarms. Show me the proposed changes for approval.
Do not add email, SMS or other notification actions.
```
Check the target device, severities, and clear conditions before approving:
| Alarm | Trigger | Clear |
| - | - | - |
| Motor Fault | `fault=true` → CRITICAL | `fault=false` |
| High Vibration | `>7` and `<=9` → WARNING; `>9` → CRITICAL | `<=7` mm/s |
| High Temperature | `>30` °C → WARNING | `<=30` °C |
Vibration uses **one alarm type**; Critical takes priority above 9 mm/s. Check device/profile scope and reuse matching rules, avoiding duplicates. These are simulation thresholds, not real-motor operating limits.
> [!NOTE]
>
> **Want to compare with hand-built alarm rules?** [Step 5 of the Vibration Monitoring guide](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/real-time-vibration-monitoring-with-thingsboard-and-calculated-fields.md#step-5-configure-alarms) configures ISO 10816 alarm rules manually on a device profile, using real sensor data and calculated fields.
**3. Check the result**
Return to **Motor Overview**. Its Alarms Table must use the same device and show active and cleared alarms to reveal automatic clearing.
The normal simulation may not cross every threshold during your check. Use the two controlled payloads below to demonstrate both alarm creation and clearing, then restore the repeating simulation.
Pause the repeating Inject and startup injection, then Deploy. Add a non-repeating Inject with a **JSON** payload, connected directly to **Serialize telemetry as JSON**. Send:
```json theme={null}
{"speedRpm":0,"motorOn":false,"temperature":31,"vibrationRms":10,"fault":true,"faultCode":101,"alarmLevel":2}
```
Expect Motor Fault and High Vibration to be **CRITICAL**, and High Temperature to be **WARNING**. Send the following normal values to clear them:
```json theme={null}
{"speedRpm":1100,"motorOn":true,"temperature":24,"vibrationRms":2,"fault":false,"faultCode":0,"alarmLevel":0}
```
Cleared alarms remain in history but disappear from an active-only table. Restore the five-second Inject and startup injection, then Deploy.
### Where AI still needs a human
* **Unrequested resources:** Review proposals and remove extras before approving.
* **Needle gauge:** AI cannot select the analogue Speed gauge. Use the optional manual instructions below, or see the [ISO-banded Speed gauge](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/real-time-vibration-monitoring-with-thingsboard-and-calculated-fields.md#vibration-severity-gauge-iso-10816-bands) built by hand in the Vibration Monitoring guide.
* **Font size and scaling:** These controls are not exposed in this AI workflow; use Edit mode when available.
* **Alarm history:** AI cannot set a separate Alarms Table time window here. Select a longer global dashboard window for older alarms.
* **Rule scope:** AI may attach rules to a device profile, affecting every device using it. Confirm the intended scope.
### Your result – a bigger dashboard using AI-supported widgets
You now have electrical readings, motor status, speed, vibration, Details navigation and alarms that activate and clear. This completes the AI workflow.
Motor Overview with electrical readings, status cards, RPM, vibration and alarm history.
> [accordion] Optional manual editing
>
> Use **Edit mode** for optional appearance changes, separate from the AI prompts and opening GIF. See [Edge Setup Step 5: Create Dashboard](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/thingsboard-edge-setup.md#step-5-create-dashboard) for widget basics.
>
> To add a needle gauge, open **Edit mode → Add widget → Analogue gauges → Speed gauge**. Use the existing motor alias and `speedRpm`; set **RPM**, **min 0**, **max 1600**, and **0 decimal digits**, then enable the digital value. For the pictured style, use **Motor speed** as the Units title, **#048AD3** for Arrow and scale default color, and white for Plate color. Replace the old RPM widget and Save. See the [Speed gauge guide](https://thingsboard.io/docs/reference/widgets/analogue-gauges/speed-gauge/).
>
> 
>
> The optional needle gauge in the manual widget preview.
***
## Resources
#### Node-RED Motor Simulation Flow
The complete flow: five-second Inject, motor simulator Function, JSON serialization, secure MQTT output and Debug. Add only your device access token after import.
> [card] [industrial-motor-cloud-flow.json](https://raw.githubusercontent.com/Code-and-Compile/wiki-docs/main/wiki/.gitbook/assets/industrial-motor-cloud-flow.json)
#### Simulator Source Code (optional)
The same Function code as plain text, for reading or building a flow manually. It is already included in the flow above; do not add it again.
> [card] [industrial-motor-simulator.txt](https://raw.githubusercontent.com/Code-and-Compile/wiki-docs/main/wiki/.gitbook/assets/industrial-motor-simulator.txt)
#### ThingsBoard Dashboard and Alarm Rules
The Node-RED flow, the AI-generated Motor Overview dashboard export, all three alarm definitions and a README with import notes. No tokens or telemetry history are included.
> [card] [motor-ai-example-project.zip](https://raw.githubusercontent.com/Code-and-Compile/wiki-docs/main/wiki/.gitbook/assets/motor-ai-example-project.zip)
> [!NOTE]
>
> To learn how to import a dashboard and update its entity alias, refer to [ThingsBoard (Edge Setup)](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/thingsboard-edge-setup.md). Alarm rules are not part of the dashboard export; recreate them in your account with Step 5.
#### Further reading
* **Next step with real hardware:** [Real-Time Vibration Monitoring with ThingsBoard and Calculated Fields](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/real-time-vibration-monitoring-with-thingsboard-and-calculated-fields.md) uses a physical Balluff sensor, a virtual PLC and ThingsBoard Calculated Fields.
* **Official ThingsBoard guides:** [AI Solution Creator](https://thingsboard.io/docs/paas/eu/user-guide/ai-solution-creator/), [dashboard AI](https://thingsboard.io/docs/paas/eu/user-guide/dashboards/#configure-dashboard-with-ai) and [alarm-rule AI](https://thingsboard.io/docs/paas/eu/user-guide/alarm-rules/#configure-alarm-rules-with-ai).
* **Simulation limits:** values and faults are synthetic, and in-memory counters reset when Node-RED restarts. `availability` indicates running time, not OEE.
## 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](mailto:rajvir@codeandcompile.com) or drop me a message on [LinkedIn](https://www.linkedin.com/in/singhrajvir/)
## Related topics
- [Real-Time Vibration Monitoring with ThingsBoard and Calculated Fields](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/real-time-vibration-monitoring-with-thingsboard-and-calculated-fields.md)
- [ThingsBoard](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/index.md)
- [ThingsBoard (Edge Setup)](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/thingsboard-edge-setup.md)
- [Secure OT/IT Data Integration Using HiveMQ Edge and Site DMZ](https://wiki.codeandcompile.com/product-reviews/smart-platforms/thingsboard/secure-ot-it-data-integration-using-hivemq-edge-and-site-dmz.md)
- [Smart Platforms](https://wiki.codeandcompile.com/product-reviews/smart-platforms/index.md)
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.