UA-Bridge – Feature Guide

Version: 1.2.0

Table of Contents

1. OPC-UA Client
2. Data Subscriptions & Monitoring
3. MQTT Output
4. PostgreSQL Output
5. Google Sheets Output
6. Built-in SQLite Database
7. Dashboard & Visualization
8. Connection Logging
9. Project File Management
10. Auto-Reconnection
11. Data Retention & Cleanup
12. Theming
13. Keyboard Shortcuts

1. OPC-UA Client

UA-Bridge includes a full-featured OPC-UA client supporting the OPC-UA binary protocol over TCP.

Connection Options

Endpoint Discovery

When connecting, UA-Bridge performs endpoint discovery to identify available security configurations on the server. It logs available security modes and policies to help diagnose connection issues.

Node Browsing

After connecting, you can interactively browse the server’s address space:

• Tree Navigation: Expand nodes in a hierarchical tree view to explore the server namespace
• Node Information: View NodeId, BrowseName, NodeClass, and TypeDefinition for each node
• Multi-Select: Select multiple variable nodes at once for subscription
• Path Tracking: The full browse path of each node is preserved for MQTT topic hierarchy

Node Reading

• Single Node Read: Read the current value, timestamps, and status code of any node
• Batch Read: Read display name, value, description, access level, and data type for multiple nodes in parallel (chunks of 50)

2. Data Subscriptions & Monitoring

Creating Subscriptions

Subscriptions allow you to monitor OPC-UA variables for real-time data changes.

• Batch Subscribe: Select multiple nodes from the browse tree and subscribe to all at once
• Configurable Publishing Interval: Set the publishing interval in milliseconds (default: 5,000 ms)
• Queue Size: Each monitored item has a queue size of 10 with discard-oldest policy
• Duplicate Detection: Prevents subscribing to the same node ID twice on a connection

Subscription Limits (Free Edition)

The Free Edition enforces a global limit of 100 subscribed variables across all connections. When the limit is reached, a warning message is displayed.

Live Data Feed

When a monitored item value changes, the following data is captured:

This data is simultaneously:

1. Written to the built-in SQLite database
2. Sent to the Renderer process for live UI updates
3. Published to all active MQTT connections
4. Inserted into all active PostgreSQL connections
5. Published to all active Google Sheets connections

Subscription Editing

Modify subscription parameters on the fly:

• Change the publishing interval
• Enable/disable publishing
• Add more monitored items
• Remove monitored items

3. MQTT Output

Publish OPC-UA data changes to one or more MQTT brokers in real time.

Features

• Multiple Brokers: Connect to multiple MQTT brokers simultaneously
• Protocol Support: mqtt://, mqtts:// (TLS), ws://, wss:// (WebSocket)
• TLS/SSL: Full TLS support with CA certificate, client certificate, and client key
• Self-Signed Certificates: Option to disable certificate verification
• Authentication: Optional username/password
• Retained Messages: Configurable per connection – retain the last published value on the broker
• Auto-Reconnection: Exponential backoff (2 s -> 60 s), up to 1,000 attempts
• Health Monitoring: 30-second health checks; triggers reconnection on 90 s inactivity

Topic Structure

Published topics follow a hierarchical structure:

{baseTopic}/{connectionName}/{OPC browsePath...}/{displayName}

Example:

opcuadt/opcsrv1/Objects/Server/ServerStatus

Each message body is a JSON object with the full data change payload.

{
  "connectionId": 1766761871040,
  "connectionName": "test",
  "nodeId": "ns=0;i=2256",
  "displayName": "ServerStatus",
  "value": {
    "startTime": "2026-02-18T18:37:38.742Z",
    "currentTime": "2026-02-21T19:10:59.095Z",
    "state": "Running",
    "buildInfo": {
      "productUri": "https://github.com/riclolsen/json-scada/",
      "manufacturerName": "JSON-SCADA Project",
      "productName": "{json:scada} - OPC-UA Server",
      "softwareVersion": "0.1.3",
      "buildNumber": "0.1.3",
      "buildDate": "2020-02-01T00:00:00.000Z"
    },
    "secondsTillShutdown": 0,
    "shutdownReason": {}
  },
  "serverTimestamp": "2026-02-21T19:10:59.094Z",
  "sourceTimestamp": "2026-02-21T19:10:59.094Z",
  "statusCode": {
    "value": 0
  }
}

Reconnection Behavior

When a connection is lost:

1. The old client is cleaned up
2. A new connection attempt is scheduled with exponential backoff
3. A 15-second timeout prevents hanging attempts
4. The UI receives live status updates (connected, disconnected, reconnecting, error)

4. PostgreSQL Output

Store OPC-UA data changes in PostgreSQL databases for long-term historical analysis.

Features

• Multiple Databases: Connect to multiple PostgreSQL instances simultaneously
• Auto-Create Database: If the target database doesn’t exist, it is automatically created
• Auto-Create Table: The data table is created on connect if it doesn’t exist
• SSL/TLS Support: Full SSL with CA certificate, client certificate, and client key
• Smart Value Storage: Values are stored in three parallel columns:
  • value_jsonb (JSONB) – Complete value for complex types
  • value_double (DOUBLE PRECISION) – Numeric values for efficient queries
  • value_string (TEXT) – String representation for all types
• Auto-Reconnection: Exponential backoff (5 s -> 60 s) on connection loss
• Data Retention Cleanup: Hourly cleanup of records older than the configured retention period, followed by VACUUM ANALYZE

Table Schema

The table name is configurable (default: opcua_data):

CREATE TABLE IF NOT EXISTS opcua_data (
  id SERIAL PRIMARY KEY,
  connection_id TEXT,
  node_id TEXT,
  display_name TEXT,
  value_jsonb JSONB,
  value_double DOUBLE PRECISION,
  value_string TEXT,
  server_timestamp TIMESTAMP,
  source_timestamp TIMESTAMP,
  status_code TEXT,
  created_at TIMESTAMP DEFAULT NOW()
);

Column Details

Example Data

The following example uses the SQL INSERT format as produced by the application:

INSERT INTO "public"."opcua_data"
  ("id", "connection_id", "node_id", "display_name",
   "value_jsonb", "value_double", "value_string",
   "server_timestamp", "source_timestamp", "status_code", "created_at")
VALUES
  ('1', '1040', 'ns=0;i=2254', 'ServerArray',
   '["urn:instance-20211207-0955:NodeOPCUA-Server"]', null,
   '["urn:instance-20211207-0955:NodeOPCUA-Server"]',
   '2026-02-21 18:53:03.724', '2026-02-19 09:11:59.729',
   'Good', '2026-02-21 17:53:03.929459');

Tabular view of typical rows collected from a running system:

Note: The three value_* columns allow flexible querying – use value_double for numeric aggregations (WHERE value_double IS NOT NULL), value_string for text values, and value_jsonb for complex structured objects (e.g., arrays like ServerArray above). When a value is non-numeric (arrays, strings), value_double is NULL.

5. Google Sheets Output

Write OPC-UA data changes directly to Google Sheets spreadsheets.

Features

• Service Account Authentication: Uses a Google Cloud service account JSON key file
• Two Write Modes:
  • Append: Adds a new row for every data change (time-series)
  • Update: Overwrites the existing row for each unique ConnectionName|NodeId combination (latest value dashboard)
• Batch Buffering: Data changes are buffered for 2 seconds and published in batches to reduce API calls
• Row Cache: In update mode, maintains an in-memory cache of row positions for efficient updates
• Automatic Cache Invalidation: Cache is cleared on errors and rebuilt on the next write attempt

Row Format

Each row written to Google Sheets contains these columns:

Example Data (in Google Sheets)

Append mode: Each of these rows is added sequentially – the sheet grows over time as a time-series log.
Update mode: Row 1 and row 2 would be overwritten with new values on subsequent data changes (matched by Connection Name | Node ID).

6. Built-in SQLite Database

All data changes from all OPC-UA subscriptions are automatically stored in a local SQLite database.

Features

• Automatic Storage: No configuration required – all data changes are logged
• Location: {userData}/opcua-data.sqlite (typically %APPDATA%\ua-bridge\opcua-data.sqlite)
• Historical Queries: Retrieves last 3 hours of numeric data (up to 10,000 records) for charting
• Clear Data: Option to empty the database and reclaim disk space via DELETE + VACUUM
• Data Retention: Configurable automatic cleanup (default: 30 days)
• File Access: “Show Database File” button opens Explorer at the database location

Table Schema

CREATE TABLE IF NOT EXISTS opc_data_changes (
  id              INTEGER PRIMARY KEY AUTOINCREMENT,
  connectionId    INTEGER,
  nodeId          TEXT,
  displayName     TEXT,
  value           REAL|TEXT,
  serverTimestamp  INTEGER,
  sourceTimestamp  INTEGER,
  statusCode      INTEGER
);

Column Details

Example Data

Note: The value column stores numeric values as REAL. Non-numeric values (strings, objects) are stored as their JSON representation. Boolean true/false values are stored as 1.0/0.0. The Visualize page only charts rows where value is a number.

Querying the Database

You can query the SQLite database directly using the sqlite3 command-line tool:

sqlite3 "%APPDATA%\ua-bridge\opcua-data.sqlite"

-- View recent readings with human-readable timestamps
SELECT connectionId, nodeId, displayName, value,
       DATETIME(serverTimestamp/1000, 'unixepoch', 'localtime') AS time
FROM opc_data_changes
ORDER BY id DESC
LIMIT 20;

-- Compute average temperature over the last hour
SELECT AVG(value) AS avg_temp
FROM opc_data_changes
WHERE displayName = 'Temperature'
  AND typeof(value) = 'real'
  AND serverTimestamp >= (CAST((julianday('now') - 2440587.5)*86400000 AS INTEGER) - 3600000);

-- Count records per connection
SELECT connectionId, COUNT(*) AS record_count
FROM opc_data_changes
GROUP BY connectionId;

7. Dashboard & Visualization

Dashboard

The Dashboard page provides an at-a-glance overview:

• Data Event Counter: Real-time count of received data change events
• Connection Status: Quick view of all active connections

Visualize / Explore Page

The Explore page (lazy-loaded for performance) provides:

• Historical Charts: Time-series charts of OPC-UA variables with numeric values
• Data Source: Reads from the built-in SQLite database (last 3 hours)
• Time Axis: Date/time formatted X-axis

8. Connection Logging

Each OPC-UA connection maintains its own log buffer (up to 10,000 entries).

Log Levels

Log Viewer

• Dedicated Window: Each connection can open a separate log viewer window
• Real-Time Streaming: New log entries are streamed to the log window

9. Project File Management

Save & Load Projects

UA-Bridge configurations can be saved to and loaded from JSON files.

• Save Project As (Ctrl+S): Exports the complete config.json state to a user-selected file
• Open Project (Ctrl+O): Imports a project JSON file, replaces config.json, and restarts the application
• File Format: Standard JSON with .json extension

10. Auto-Reconnection

All connection types feature robust auto-reconnection:

All reconnection logic respects manual disconnect flags – once a user explicitly disconnects, auto-reconnection is suppressed until they manually reconnect.

11. Data Retention & Cleanup

• Configurable Period: default: 30 days; 0 = disabled
• Scope: Both default SQLite DB and all active PostgreSQL connections
• Schedule: Initial cleanup 10 seconds after startup, then hourly
• Process:
  1. Delete records older than the retention period
  2. SQLite: VACUUM to reclaim disk space
  3. PostgreSQL: VACUUM ANALYZE to reclaim space and update statistics

12. Theming

• Light Mode: Default theme with light backgrounds and dark text
• Dark Mode: Full dark theme with appropriate contrast
• Toggle: Available in the Settings page via a Sun/Moon switch
• Persistence: Theme preference is saved to localStorage and applied on startup

13. Keyboard Shortcuts

UA-Bridge – Configuration Guide

Version: 1.2.0

Table of Contents

1. Application Settings
2. OPC-UA Connection Configuration
3. MQTT Output Configuration
4. PostgreSQL Output Configuration
5. Google Sheets Output Configuration
6. Configuration File Reference
7. Data Paths & Storage Locations

1. Application Settings

Application-wide settings are managed from the Settings page and stored in the appSettings section of config.json.

Available Settings

Changing Settings

1. Navigate to the Settings page via the sidebar
2. Modify the desired values
3. Changes are automatically saved to config.json when modified

Note: The dataRetention value affects both the built-in SQLite database and all active PostgreSQL connections.

2. OPC-UA Connection Configuration

2.1. Adding a New Connection

1. Go to the OPC-UA (Connections) page
2. Click “Add Connection”
3. Fill in the connection details (see table below)
4. Click “Add Connection” to save

2.2. Connection Parameters

2.3. Security Configuration

When Security Mode is set to Sign or Sign & Encrypt, additional fields appear:

File Selection: Use the ... button to open a file browser dialog for selecting certificate and key files.

2.4. Endpoint URL Format

The endpoint URL must follow the OPC-UA TCP URI scheme:

opc.tcp://<hostname>:<port>[/<path>]

Valid examples:

opc.tcp://localhost:4840
opc.tcp://192.168.1.100:4840
opc.tcp://plc-server.local:4840/UAServer

2.5. Security Mode & Policy Combinations

Recommendation: For production environments, use Sign & Encrypt with Basic256Sha256.

3. MQTT Output Configuration

3.1. Adding an MQTT Output

1. Navigate to the Output Destinations page
2. In the MQTT section, click “Add MQTT Connection”
3. Fill in the connection details
4. Click “Save Connection”

3.2. Connection Parameters

3.3. TLS/SSL Configuration

For mqtts or wss protocols:

3.4. Topic Hierarchy

The actual published topic for each data point is constructed as:

{baseTopic}/{connectionName}/{browsePath}/{displayName}

Where:

• baseTopic is the configured topic
• connectionName is the name of the OPC-UA connection
• browsePath is the browse path from the OPC-UA address space
• displayName is the display name of the variable node

4. PostgreSQL Output Configuration

4.1. Adding a PostgreSQL Output

1. Navigate to the Output Destinations page
2. In the PostgreSQL section, click “Add PostgreSQL Connection”
3. Fill in the database details
4. Click “Save Connection”

4.2. Connection Parameters

4.3. SSL/TLS Configuration

4.4. Automatic Database & Table Setup

When connecting, UA-Bridge performs the following steps:

1. Check Database Existence: Connects to the postgres system database and queries pg_catalog.pg_database
2. Create Database (if needed): Runs CREATE DATABASE <name> if the target database doesn’t exist
3. Connect to Target: Disconnects from postgres and connects to the target database
4. Create Table (if needed): Runs CREATE TABLE IF NOT EXISTS with the configured or default table name

Note: The service user must have CREATEDB privilege or the target database must already exist.

5. Google Sheets Output Configuration

5.1. Prerequisites

Before configuring a Google Sheets output, you need:

1. Google Cloud Project with the Google Sheets API enabled
2. Service Account with a JSON key file
3. Spreadsheet shared with the service account email (with Editor access)

5.2. Adding a Google Sheets Output

1. Navigate to the Output Destinations page
2. In the Google Sheets section, click “Add Google Sheets Connection”
3. Fill in the spreadsheet details
4. Click “Save Connection”

5.3. Connection Parameters

5.4. Finding the Spreadsheet ID

The Spreadsheet ID is found in the URL of your Google Sheet:

https://docs.google.com/spreadsheets/d/{SPREADSHEET_ID}/edit

5.5. Write Modes Explained

Append Mode

• Adds a new row to the sheet for every data change
• Best for: Time-series data, logging, audit trails
• Warning: The sheet will grow continuously

Update Mode

• Maintains one row per unique ConnectionName|NodeId combination
• On first write, the row is appended
• On subsequent writes, the existing row is found and updated in place
• Uses an in-memory cache for fast row lookups (cache is loaded from the sheet on first access)
• Best for: Real-time dashboards, current value displays

5.6. Setting Up Google Cloud

1. Go to Google Cloud Console
2. Create or select a project
3. Enable the Google Sheets API
4. Go to IAM & Admin -> Service Accounts
5. Create a service account
6. Click the service account -> Keys -> Add Key -> Create new key -> JSON
7. Download the JSON key file
8. Open your Google Sheet -> Share -> Add the service account email as Editor

6. Configuration File Reference

6.1. File Location

6.2. Complete Configuration Schema

{
  "opcuaConnections": [
    {
      "id": 1,
      "name": "Production Line PLC",
      "endpoint": "opc.tcp://192.168.1.100:4840",
      "securityMode": "None",
      "securityPolicy": "None",
      "authenticationMethod": "Anonymous",
      "username": "",
      "password": "",
      "autoConnect": true,
      "certificateFile": "",
      "privateKeyFile": "",
      "privateKeyPassphrase": "",
      "automaticallyAcceptUnknownCertificate": false,
      "sessionTimeout": 60000
    }
  ],
  "mqttConnections": [
    {
      "id": "uuid-1",
      "name": "Central MQTT Broker",
      "host": "broker.local",
      "port": 1883,
      "protocol": "mqtt",
      "username": "",
      "password": "",
      "topic": "factory/opcua",
      "retain": false,
      "caCert": "",
      "clientCert": "",
      "clientKey": "",
      "rejectUnauthorized": true
    }
  ],
  "postgresConnections": [
    {
      "id": "uuid-2",
      "name": "Historian Database",
      "host": "db.local",
      "port": 5432,
      "database": "process_data",
      "username": "opcua_writer",
      "password": "secret",
      "tableName": "opcua_data",
      "ssl": false,
      "sslCaCert": "",
      "sslClientCert": "",
      "sslClientKey": "",
      "sslRejectUnauthorized": true
    }
  ],
  "googlesheetsConnections": [
    {
      "id": "uuid-3",
      "name": "Monitoring Dashboard",
      "spreadsheetId": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
      "range": "Sheet1!A:A",
      "writeMode": "update",
      "keyFilePath": "C:\\keys\\service-account.json"
    }
  ],
  "subscriptions": [],
  "appSettings": {
    "autoConnect": false,
    "logLevel": "info",
    "maxConnections": 10,
    "dataRetention": 30,
    "enableNotifications": true
  }
}

6.3. Saving and Loading Projects

Format: The project file is a standard JSON file with the same schema as config.json.

7. Data Paths & Storage Locations

7.1. Standard Paths

7.2. Windows Paths

• Normal Install: %APPDATA%\ua-bridge\
• UWP Install: C:\Users\<user>\AppData\Local\Packages\<packageFamily>\LocalCache\Roaming\ua-bridge\

UA-Bridge automatically detects whether it’s running as a UWP app and uses the appropriate data path.

UA-Bridge – Usage Examples

Version: 1.2.0

Table of Contents

1. Quick Start: First OPC-UA Connection
2. Subscribing to Variables
3. Setting Up MQTT Forwarding
4. Connecting to a PostgreSQL Historian
5. Publishing to Google Sheets
6. Using Secure OPC-UA Connections
7. Using MQTT with TLS
8. Saving and Restoring Projects
9. Setting Up Data Retention
10. Viewing Historical Data
11. Complete Industrial Setup Example

1. Quick Start: First OPC-UA Connection

This example walks through connecting to a local OPC-UA simulation server.

Step 1: Launch UA-Bridge

Start the application. You’ll land on the OPC-UA (Connections) page.

Step 2: Add a Connection

1. Click “Add Connection”

2. Enter the connection details:

   Field	Value
   Connection Name	Local Simulator
   Endpoint URL	opc.tcp://localhost:4840
   Security Mode	None
   Security Policy	None
   Authentication	Anonymous

3. Click “Add Connection”

Step 3: Connect

Click the Connect button (plug icon) next to your new connection. The status indicator will turn green when connected. If it doesn’t turn green, check the logs for errors.

Step 4: Browse the Server

1. Click the Browse button to open the address space browser
2. Expand the tree: Root -> Objects -> etc.
3. Select one object from the tree (left panel) or a variable node (middle panel)
4. Click “Add to Subscription” or “Add Child Variables to Subscription” to start monitoring

You should now see live data values updating in the subscriptions panel.

2. Subscribing to Variables

Single Variable Subscription

1. After connecting to an OPC-UA server, open the Browse dialog
2. Navigate through the tree to find the variable of interest
3. Select the variable node (checkbox)
4. Click “Add to Subscription”

Batch Subscription

Select multiple variables by clicking a node in the browse tree, then click “Add Child Variables to Subscription”. All child nodes will be subscribed at once.

Subscription Configuration

The following defaults are used for new subscriptions:

Publishing Interval:   5,000 ms
Queue Size:            10
Discard Policy:        Discard Oldest
Timestamps:            Both (server + source)

Modifying a Subscription

Use the Edit Subscription option to change:

• Publishing Interval – How often the server sends data changes (milliseconds)
• Publishing Enabled – Temporarily pause/resume data delivery

Data Flow

Once subscribed, every value change is automatically:

OPC-UA Server
    |
    v
UA-Bridge (Main Process)
    |
    +--+ SQLite DB (always)
    +--+ UI / Renderer (always)
    +--+ MQTT Brokers (if configured)
    +--+ PostgreSQL DBs (if configured)
    +--+ Google Sheets (if configured)

3. Setting Up MQTT Forwarding

Example: Forward to a Mosquitto Broker

Step 1: Configure the MQTT Output

1. Go to the Output Destinations page

2. Click “Add MQTT Connection”

3. Enter:

   Field	Value
   Connection Name	Factory MQTT Broker
   Host	mqtt-broker.factory.local
   Port	1883
   Protocol	mqtt
   Topic	factory/opcua/data
   Retain	true

4. Click “Save Connection”

Step 2: Connect

Click Connect on the MQTT connection. The status will update to “Connected”.

Step 3: Verify Data

Subscribe to topics on the MQTT broker using any MQTT client:

mosquitto_sub -h mqtt-broker.factory.local -t "factory/opcua/data/#" -v

You should see messages like:

factory/opcua/data/LocalSimulator/Objects/Simulation/Temperature
{
  "connectionId":1,
  "connectionName":"Local Simulator",
  "nodeId":"ns=2;s=Temperature",
  "displayName":"Temperature",
  "value":23.5,
  "serverTimestamp":"2026-02-21T12:00:00.000Z",
  "sourceTimestamp":"2026-02-21T12:00:00.000Z",
  "statusCode":"Good"
}

4. Connecting to a PostgreSQL Historian

Example: Store Process Data in PostgreSQL

Step 1: Prepare the Database Server

Ensure PostgreSQL is running and accessible. The database user needs either:

• CREATEDB privilege (UA-Bridge will auto-create the database), or
• An existing database already created

Step 2: Configure the PostgreSQL Output

1. Go to Output Destinations

2. Click “Add PostgreSQL Connection”

3. Enter:

   Field	Value
   Name	Process Historian
   Host	db-server.local
   Port	5432
   Database	process_data
   Username	opcua_writer
   Password	secure_password
   Table Name	opcua_data

4. Click “Save Connection”

Step 3: Connect and Verify

After connecting, check the database:

SELECT * FROM opcua_data ORDER BY created_at DESC LIMIT 10;

Expected result:

Obs.: Not all columns are shown in the example table.

5. Publishing to Google Sheets

Example: Create a Live Monitoring Dashboard

Step 1: Set Up Google Cloud

1. Create a Google Cloud project
2. Enable the Google Sheets API
3. Create a Service Account and download the JSON key
4. Create a Google Sheet and share it with the service account email (Editor access)

Step 2: Configure the Google Sheets Output

1. Go to Output Destinations

2. Click “Add Google Sheets Connection”

3. Enter:

   Field	Value
   Connection Name	Plant Dashboard
   Spreadsheet ID	1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms
   Sheet / Range	LiveData!A:A
   Write Mode	update
   Key File Path	C:\Keys\plant-monitor-sa.json

4. Click “Save Connection”

Step 3: Connect

Click Connect. Data changes will begin appearing in your spreadsheet:

Tip: In Update mode, each ConnectionName|NodeId combination occupies exactly one row. New values overwrite the previous entry, creating a real-time “current values” view.

6. Using Secure OPC-UA Connections

Example: Connect with Certificate-Based Security

Prerequisites

• Server certificate or CA certificate
• Client X.509 certificate (.pem format)
• Client private key (.pem format, optionally encrypted)

Step 1: Configure the Connection

1. Click “Add Connection”

2. Enter:

   Field	Value
   Connection Name	Secure PLC
   Endpoint URL	opc.tcp://plc.factory.local:4840
   Security Mode	Sign & Encrypt
   Security Policy	Basic256Sha256
   Authentication	Username/Password
   Username	operator
   Password	secure_pass
   Certificate File	C:\Certs\client-cert.pem
   Private Key File	C:\Certs\client-key.pem
   Private Key Passphrase	my_key_password
   Accept Unknown Certs	[ ] (unchecked for production)

3. Click “Add Connection”

Security Note: Only check “Accept Unknown Certificates” in development or when connecting to servers with self-signed certificates on trusted networks.

7. Using MQTT with TLS

Example: Connect to an MQTTS Broker

Step 1: Configure TLS MQTT

1. Go to Output Destinations -> “Add MQTT Connection”

2. Enter:

   Field	Value
   Connection Name	Secure Cloud Broker
   Host	cloud-mqtt.example.com
   Port	8883
   Protocol	mqtts
   Username	device01
   Password	device_secret
   Topic	plant/opcua
   CA Certificate	C:\Certs\mqtt-ca.pem
   Client Certificate	C:\Certs\mqtt-client.pem
   Client Key	C:\Certs\mqtt-client-key.pem
   Reject Unauthorized	[x] enabled

3. Click “Save Connection”

For self-signed certificates: Uncheck Reject Unauthorized to skip CA validation. This is insecure and should only be used in development.

8. Saving and Restoring Projects

Saving a Project

1. Configure all your connections, outputs, and subscriptions
2. Press Ctrl+S (or use the menu)
3. Choose a location and filename (e.g., factory-floor-config.json)
4. Click Save

Restoring a Project

1. Press Ctrl+O (or use the menu)
2. Select a previously saved .json project file
3. UA-Bridge will replace the current configuration and restart

Project File Example

{
  "opcuaConnections": [
    {
      "id": 1,
      "name": "PLC Line A",
      "endpoint": "opc.tcp://192.168.1.10:4840",
      "securityMode": "None",
      "securityPolicy": "None",
      "authenticationMethod": "Anonymous",
      "autoConnect": true,
      "sessionTimeout": 60000
    },
    {
      "id": 2,
      "name": "PLC Line B",
      "endpoint": "opc.tcp://192.168.1.11:4840",
      "securityMode": "None",
      "securityPolicy": "None",
      "authenticationMethod": "Anonymous",
      "autoConnect": true,
      "sessionTimeout": 60000
    }
  ],
  "mqttConnections": [
    {
      "id": "mqtt-1",
      "name": "Factory MQTT",
      "host": "mqtt.factory.local",
      "port": 1883,
      "protocol": "mqtt",
      "topic": "factory/data",
      "retain": true
    }
  ],
  "postgresConnections": [
    {
      "id": "pg-1",
      "name": "Historian",
      "host": "historian.factory.local",
      "port": 5432,
      "database": "process_data",
      "username": "opcua",
      "password": "secret",
      "tableName": "sensor_data"
    }
  ],
  "appSettings": {
    "dataRetention": 90
  }
}

9. Setting Up Data Retention

Adjusting Retention Period

1. Go to the Settings page
2. Set the Data Retention (Days) value:
   • 30 (default) – Keep last 30 days of data
   • 90 – Keep last 3 months
   • 365 – Keep last year
   • 0 – Disable automatic cleanup (data grows indefinitely)

What Gets Cleaned

Cleanup Schedule

• First Run: 10 seconds after application start
• Recurring: Every 60 minutes (3,600,000 ms)

10. Viewing Historical Data

Built-in Charts

1. Navigate to the Visualize page
2. The page loads the last 3 hours of numeric data from the SQLite database
3. Data is displayed as time-series charts (Chart.js)

Direct Database Access

Click “Show Database File” from the Dashboard or use OPC data options to open Windows Explorer at the database location. You can then query the SQLite file directly:

sqlite3 "%APPDATA%\ua-bridge\opcua-data.sqlite"

For MS Store version (UWP):

sqlite3 "%LOCALAPPDATA%\Packages\{pkg}\LocalCache\Roaming\ua-bridge\config.json"

Use the SQLite Output “Show File” button to open Windows Explorer at the exact database file location.

-- View recent temperature readings
SELECT displayName, value,
       datetime(serverTimestamp/1000, 'unixepoch', 'localtime') as time
FROM opc_data_changes
WHERE displayName LIKE '%Temperature%'
ORDER BY id DESC
LIMIT 20;

-- Count records per connection
SELECT connectionId, COUNT(*) as record_count
FROM opc_data_changes
GROUP BY connectionId;

Clearing Historical Data

To free disk space, use the “Empty Data” button, which performs:

DELETE FROM opc_data_changes;
VACUUM;

11. Complete Industrial Setup Example

Scenario

A manufacturing plant with:

• 2 PLCs (Siemens S7-1500 with OPC-UA)
• 1 Mosquitto MQTT broker for SCADA
• 1 PostgreSQL database for historian
• 1 Google Sheet for management reports

Configuration

+----------------------------+
|        UA-Bridge           |
|                            |
|  OPC-UA Connections:       |
|  +-- PLC Line A            |---> opc.tcp://192.168.1.10:4840
|  +-- PLC Line B            |---> opc.tcp://192.168.1.11:4840
|                            |
|  Output Destinations:      |
|  +-- MQTT: SCADA           |---> mqtt://scada-broker:1883
|  |   Topic: plant/opcua    |
|  +-- PostgreSQL: Historian |---> postgres://db-server:5432/process_data
|  |   Table: sensor_data    |
|  +-- Google Sheets: KPIs   |---> Spreadsheet: "Plant KPIs"
|      Mode: update          |
|                            |
|  Settings:                 |
|  +-- Retention: 90 days    |
+----------------------------+

Step-by-Step Setup

1. Add OPC-UA Connections
   • Add connection for PLC Line A (opc.tcp://192.168.1.10:4840)
   • Add connection for PLC Line B (opc.tcp://192.168.1.11:4840)
   • Enable Auto-Connect for both
2. Connect & Subscribe
   • Connect to each PLC
   • Browse the address space and subscribe to key variables (temperatures, pressures, speeds)
3. Configure MQTT Output
   • Add MQTT connection to the SCADA broker
   • Set topic to plant/opcua with retain enabled
   • Connect
4. Configure PostgreSQL Output
   • Add PostgreSQL connection to the historian server
   • Set database to process_data, table to sensor_data
   • Connect
5. Configure Google Sheets Output
   • Create a Google Sheet titled “Plant KPIs”
   • Share with your service account
   • Add Google Sheets connection with update mode
   • Connect
6. Save the Project
   • Press Ctrl+S and save as plant-config.json
   • This file can be used to restore the full setup on any machine
7. Set Data Retention
   • Go to Settings
   • Set retention to 90 days

All data from both PLCs will now automatically flow to the MQTT broker, PostgreSQL database, and Google Sheet simultaneously, with automatic reconnection and 90-day retention management.

Troubleshooting

Common Issues

Checking Connection Logs

Each connection maintains up to 10,000 log entries. Open the log viewer:

1. Click the Log button on any connection
2. A new window opens with the full log history
3. Logs include timestamps, severity levels, and detailed messages