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

  1. OPC-UA devices → Field gateway service
  2. OPC classic DA devices → Field gateway service
  3. Field gateway service → MQTT v5 broker (live path)
  4. Field gateway service → Store-and-forward buffer (while the broker is unreachable)
  5. Store-and-forward buffer → MQTT v5 broker (replay on reconnect)
  6. MQTT v5 broker → LIVE trends in the browser (live path)
  7. MQTT v5 broker → Expression evaluation
  8. Expression evaluation → KPI & event logs
  9. KPI & event logs → Historian
  10. Historian → Dashboards & timelines
Field signals arrive over OPC-UA and OPC classic DA and are published onto the embedded MQTT v5 broker, where the flow splits: a live path feeds LIVE trends directly in the browser, and a processing path evaluates expressions into KPI and event logs stored in the historian for dashboards and timelines. If connectivity drops, the store-and-forward buffer replays samples on reconnect, so outages become delays bounded by the configured disk buffer.

Live-pipeline diagnostics

New

Diagnose 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

    New

    Add, 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.

  1. OPC-UA hub

    Connects OPC-UA servers with keep-alive and automatic session recovery

  2. OPC classic DA hub

    Bridges legacy OPC classic DA servers through COM interop

  3. Data logger

    Logs field data from IoT sources into the historian

  4. Event manager

    Evaluates event logic and dispatches actions

  5. MQTT hub

    Hosts the embedded MQTT v5 broker with optional connection authentication

  6. Hive hub

    Aggregates multiple hubs into one stream

  7. MQTT logger

    Captures broker traffic and service logs

  8. System monitor

    Watches CPU, memory and disk against thresholds with SMS alerts

  9. 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.

Integration API endpoints
MethodEndpointReturns
GET/api/iot-itemsEvery tag with its description, topic, type and engineering unit
GET/api/tag-timeseriesHistory for one tag at day, hour, minute or second resolution
Integration API examples
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()
Illustrative host and key

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.

Illustrative preview — replaced by a product screenshot when available

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.