Connectivity & Integration
Modern and legacy equipment, one resilient service
Connect modern and legacy plant equipment through one resilient service that keeps data flowing through network outages.
Data flow
From field signal to dashboard
Signals arrive over OPC-UA and OPC classic DA, land on the embedded MQTT v5 broker, and split into a live path for the browser and a processing path for KPI and event logs.
Field-to-dashboard data flow
- OPC-UA devices → Field gateway service
- OPC classic DA devices → Field gateway service
- Field gateway service → MQTT v5 broker (live path)
- Field gateway service → Store-and-forward buffer (while the broker is unreachable)
- Store-and-forward buffer → MQTT v5 broker (replay on reconnect)
- MQTT v5 broker → LIVE trends in the browser (live path)
- MQTT v5 broker → Expression evaluation
- Expression evaluation → KPI & event logs
- KPI & event logs → Historian
- Historian → Dashboards & timelines
Live-pipeline diagnostics
NewDiagnose stalled live feeds faster: live-pipeline diagnostics log stuck ticks, empty datasets and history-seed failures once per cause.
Connectivity
Every path onto the bus
Modern OPC-UA servers, legacy OPC classic DA servers and native MQTT publishers all land on one embedded broker — and keep landing there when the network does not cooperate.
OPC-UA
Keep-alive, automatic session recovery, subscriptions and monitored items. Modern servers stay connected without anyone watching a console.
OPC classic DA
Legacy servers bridged through COM interop, so equipment that predates OPC-UA lands on the same bus as everything else.
Embedded MQTT v5 broker
Hosted inside the service, with optional connection authentication and publish interception for anything that speaks MQTT natively.
Store-and-forward
Buffers to disk during outages and replays oldest-first on reconnect. Broker outages become delays, not gaps — bounded by the configured disk buffer.
System monitoring
CPU, memory and disk watched against configurable thresholds, with SMS alerts when one is crossed — before the buffer fills or the host stalls.
Hub Management
NewAdd, edit and delete MQTT hub instances from the web app, with URI validation before anything is saved.
Field gateway service
One service, nine roles
One installable service binary. Choose the role each installed service plays — one instance beside the equipment or several across the plant — and the same binary covers OPC-UA, legacy OPC classic, MQTT brokering, logging and monitoring.
OPC-UA hub
Connects OPC-UA servers with keep-alive and automatic session recovery
OPC classic DA hub
Bridges legacy OPC classic DA servers through COM interop
Data logger
Logs field data from IoT sources into the historian
Event manager
Evaluates event logic and dispatches actions
MQTT hub
Hosts the embedded MQTT v5 broker with optional connection authentication
Hive hub
Aggregates multiple hubs into one stream
MQTT logger
Captures broker traffic and service logs
System monitor
Watches CPU, memory and disk against thresholds with SMS alerts
Calculation engine
Evaluates expressions over live data and publishes results
Open by design
Integration & APIs
Open historian data and KPI processing to any external system through secure, documented REST APIs with live progress feedback.
- 15KPI & event REST endpoints
- 2governed tag & time-series endpoints
- 2live progress hubs
- 4client-language examples
- 4time-series resolutions
Per-user API keys with endpoint allow-lists
Every integration key belongs to a user and names the endpoints it may call. A reporting job that needs tag history gets exactly that and nothing more — least privilege, enforced at the endpoint.
Background extractions with live progress
KPI and event extractions run as background jobs. Callers are never blocked; progress is pushed live, so a pull over months of history can be watched instead of polled.
Interactive API docs
Every endpoint is documented interactively. An integrator can try a call in the browser, see the shape of the response and copy it before writing a line of code.
Expression evaluation over live data
Evaluate custom expressions against live MQTT data and publish the computed results back onto the bus — the same expression language your engineers use for KPIs.
Integration API
For developers
The integration API exposes 2 governed endpoints that cover the most common need: which tags exist, and what they did. Authenticate with the ApiKey header and query from any language.
| Method | Endpoint | Returns |
|---|---|---|
| GET | /api/iot-items | Every tag with its description, topic, type and engineering unit |
| GET | /api/tag-timeseries | History for one tag at day, hour, minute or second resolution |
curl -X GET "http://localhost:5226/api/iot-items" \
-H "ApiKey: your-api-key"
curl -X GET "http://localhost:5226/api/tag-timeseries\
?topic=PLANT01\
&type=Real\
&id=TEMP001\
&start=01-15-2024T08:00:00\
&stop=01-15-2024T17:00:00\
&freq=3\
&intv=5" \
-H "ApiKey: your-api-key"const API_BASE = 'http://localhost:5226/api';
const API_KEY = 'your-api-key';
// Get IOT Items
async function getIOTItems() {
const response = await fetch(`${API_BASE}/iot-items`, {
headers: { 'ApiKey': API_KEY }
});
return await response.json();
}
// Get Time Series Data
async function getTimeSeries(topic, type, id, start, stop, freq, intv) {
const params = new URLSearchParams({
topic, type, id, start, stop, freq, intv
});
const response = await fetch(`${API_BASE}/tag-timeseries?${params}`, {
headers: { 'ApiKey': API_KEY }
});
return await response.json();
}
// Usage
const items = await getIOTItems();
const data = await getTimeSeries('PLANT01', 'Real', 'TEMP001',
'01-15-2024T08:00:00', '01-15-2024T17:00:00', 3, 5);using System.Net.Http.Headers;
var client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:5226/api/");
client.DefaultRequestHeaders.Add("ApiKey", "your-api-key");
// Get IOT Items
var items = await client.GetFromJsonAsync<List<IOTItem>>("iot-items");
// Get Time Series
var query = "tag-timeseries?topic=PLANT01&type=Real&id=TEMP001" +
"&start=01-15-2024T08:00:00&stop=01-15-2024T17:00:00&freq=3&intv=5";
var timeSeries = await client.GetFromJsonAsync<List<TimeSeriesPoint>>(query);import requests
API_BASE = 'http://localhost:5226/api'
headers = {'ApiKey': 'your-api-key'}
# Get IOT Items
items = requests.get(f'{API_BASE}/iot-items', headers=headers).json()
# Get Time Series
params = {
'topic': 'PLANT01',
'type': 'Real',
'id': 'TEMP001',
'start': '01-15-2024T08:00:00',
'stop': '01-15-2024T17:00:00',
'freq': 3,
'intv': 5
}
data = requests.get(f'{API_BASE}/tag-timeseries', headers=headers, params=params).json()Bulk configuration
No API? Import from Excel
New
Not every tag list lives behind an API. When the source is a spreadsheet — a commissioning handover, a PLC export, a tag list from a legacy system — upload the workbook and let the web app do the diff.
Every row is previewed before anything is written: Create, Update, Conflict, Unchanged or Error, colour-coded and filterable, with conflicts resolved row by row. The save then runs in small chunks, each verified against the store before the next begins, so a half-written import cannot happen silently.
- CreateNew tag, will be added
- UpdateExisting tag, fields differ
- ConflictScaling differs — resolve per row
- UnchangedIdentical, skipped
- ErrorRow cannot be parsed
| Tag | Description | State |
|---|---|---|
Kiln1.Shell.Temp | Shell temperature | Create |
Mill3.Bearing.Vibration | Bearing vibration | Update |
Crusher2.Motor.Load | Motor load | Conflict |
CV201.Belt.Speed | Belt speed | Unchanged |
Mill3.Motor.Current | missing | Error |
Bring your equipment onto one bus.
Tell us what talks OPC-UA, what is still classic DA and what publishes MQTT — we will show the data flowing end to end.