Key Features

• Overview
• Core Platform Features
  • Local Data Processing
  • Local Storage
  • Offline Operation
  • Real-Time Dashboards
• Edge-Specific Features
  • Traffic Filtering
  • Local Alarms
  • Bidirectional Synchronisation
  • Cloud Integration
• Device Connectivity
  • Supported Protocols
  • Device Management
• Entity Management
  • Entity Types
  • Entity Relations
• Security Features
  • Authentication
  • Encryption
  • Access Control
• Integration Capabilities
  • REST API
  • Remote Integrations
• Performance Features
  • Rule Engine Performance
  • Database Performance
  • Transport Performance
• Monitoring Features
  • System Monitoring
  • Application Monitoring
  • Alerting
• OTA Updates
  • Software Package Management
• Batch Operations
  • Multi-Edge Management
• Next Steps

Overview

IndustryOS Edge provides comprehensive edge computing capabilities whilst maintaining seamless synchronisation with the IndustryOS Cloud Platform. This page covers the key features available on edge instances.

Core Platform Features

Local Data Processing

Rule Engine:

• Full rule chain capability on edge
• 50+ node types for data processing
• JavaScript and TBEL script support
• Asynchronous processing with actor model
• Configurable throughput (10,000+ msg/sec)

Example Use Case:

1
2
3
4
5
6
7
8
// Filter anomalies before cloud push
var temp = msg.temperature;
if (temp < 10 || temp > 30) {
    // Send anomalies to cloud
    return {msg: msg, metadata: metadata, msgType: "Push to Cloud"};
}
// Keep normal readings local only
return {msg: msg, metadata: metadata, msgType: "Local Only"};

Local Storage

PostgreSQL Database:

• Complete time-series storage
• Partitioned tables (monthly partitions)
• Configurable retention (default: 90 days)
• Automatic partition management

Data Types:

• Telemetry (time-series data)
• Attributes (configuration)
• Entities (devices, assets)
• Alarms (active and historical)
• Events (connectivity, errors)

Storage Capacity:

Offline Operation

Full Capabilities Offline:

• Accept device telemetry (MQTT/HTTP/CoAP)
• Process rule chains
• Create and clear alarms
• Display dashboards
• Execute RPC commands
• User authentication
• Dashboard updates

Message Queuing:

1
2
3
4
5
6
Offline Period:
  Device → Edge → Local DB
                → Queue (for cloud)

Online Period:
  Queue → Cloud (automatic drain)

Queue Management:

• Persistent queue (survives restarts)
• Configurable max size (default: 100k messages)
• Priority handling (alarms > entities > telemetry)
• Batch transmission (1000 records/batch)

Real-Time Dashboards

Dashboard Engine:

• 100+ widget types
• Custom HTML/CSS/JavaScript widgets
• Real-time websocket updates
• Mobile-responsive design
• Offline rendering

Widget Categories:

• Charts: Time series, bar, pie, state
• Maps: Google Maps, OpenStreetMap, image maps
• Controls: Buttons, sliders, switches
• Tables: Entity tables, alarms, events
• Gauges: Radial, linear, compass
• Cards: Value cards, timeseries cards

Data Sources:

• Latest telemetry
• Historical data (time ranges)
• Attributes (server/client/shared)
• Alarms
• Entity relationships

Edge-Specific Features

Traffic Filtering

Reduce bandwidth by filtering data before cloud push:

Threshold Filtering:

1
2
3
4
5
// Only push when temperature exceeds threshold
if (msg.temperature > metadata.ss_tempThreshold) {
    return pushToCloud(msg);
}
return saveLocal(msg);

Aggregation:

1
2
3
4
5
6
7
8
9
Raw Data (edge):
  - 1 msg/second/device
  - 86,400 messages/day/device
  - Full resolution local storage

Aggregated Data (cloud):
  - 1 avg/hour/device
  - 24 messages/day/device
  - 99.97% bandwidth reduction

Delta Filtering:

1
2
3
4
5
6
7
8
9
// Only push significant changes
var lastValue = metadata.lastSentValue || 0;
var delta = Math.abs(msg.temperature - lastValue);

if (delta > 0.5) {
    metadata.lastSentValue = msg.temperature;
    return pushToCloud(msg);
}
return saveLocal(msg);

Local Alarms

Instant Alarm Creation:

• No cloud round-trip required
• Sub-second response times
• Offline alarm support

Alarm Types:

• Threshold: Single value comparison (temp > 30)
• Duration: Condition persists (temp > 30 for 5 min)
• Complex: Multi-condition logic (temp > 30 AND humidity > 80)
• Clear: Auto-clear when condition resolves

Alarm Severities:

• CRITICAL: Immediate action required
• MAJOR: Significant issue
• MINOR: Warning condition
• WARNING: Informational
• INDETERMINATE: Unknown state

Alarm Lifecycle:

1
2
3
4
5
6
7
1. Create alarm (edge rule chain)
2. Save to edge database
3. Display in edge UI
4. Push to cloud (when connected)
5. Acknowledge (edge or cloud)
6. Clear (condition resolves)
7. Archive (move to history)

Example:

1
2
3
4
5
6
7
8
// Create alarm node configuration
{
  "alarmType": "High Temperature",
  "severity": "CRITICAL",
  "propagate": true,
  "relationTypes": ["Contains"],
  "alarmDetailsBuildJs": "var details = {temp: msg.temperature, threshold: 30}; return details;"
}

Bidirectional Synchronisation

Edge → Cloud (Uplink):

• Device telemetry (filtered)
• Alarms
• New entities (devices, assets)
• Attribute updates
• Events

Cloud → Edge (Downlink):

• Dashboard assignments
• Rule chain templates
• Device provisioning
• Configuration updates
• Firmware packages (OTA)

Sync Protocol:

• Transport: gRPC over TLS
• Port: 7070 (cloud)
• Authentication: Edge key + secret
• Reconnection: Automatic with exponential backoff
• Compression: gzip (optional)

Cloud Integration

gRPC Connection:

1
2
3
4
5
6
7
8
Edge Instance
     |
     | gRPC (TLS)
     | Port 7070
     |
     ▼
Cloud Platform
  (Edge Management Service)

Connection States:

• CONNECTED: Active bidirectional sync
• DISCONNECTED: Offline, queuing messages
• CONNECTING: Attempting reconnection
• ERROR: Authentication or network failure

Health Monitoring:

1
2
3
4
5
6
7
8
{
  "cloudConnection": "CONNECTED",
  "lastSyncTime": "2024-03-15T10:30:00Z",
  "queueSize": 42,
  "syncErrors": 0,
  "bytesSent": 1048576,
  "bytesReceived": 524288
}

Device Connectivity

Supported Protocols

MQTT:

• Ports: 1883 (plain), 8883 (TLS)
• QoS: 0, 1, 2 support
• Persistent Sessions: Supported
• Last Will: Supported
• Authentication: Access token, username/password, X.509

HTTP:

• Port: 8080 (configurable)
• Methods: POST for telemetry/attributes/RPC
• TLS: Supported (HTTPS)
• Authentication: Access token in URL or header

CoAP:

• Ports: 5683 (plain), 5684 (DTLS)
• Methods: POST, GET
• Observe: Supported (attribute subscriptions)
• Authentication: Access token

Device Management

Device Lifecycle:

1. Create device on edge UI
2. Copy access token
3. Configure device with token
4. Device connects to edge
5. Edge marks device active
6. Edge provisions device to cloud

Device Profiles:

• Default configurations
• Transport settings
• Alarm rules
• Dashboard templates

Bulk Operations:

• Import devices (CSV, JSON)
• Export device list
• Batch attribute updates
• Mass alarm acknowledgement

Entity Management

Entity Types

Devices:

• Physical equipment
• Sensors, actuators, controllers
• Access token authentication
• Telemetry and attributes

Assets:

• Logical groupings
• Buildings, production lines
• Hierarchical organisation
• No direct telemetry

Customers:

• Single customer per edge
• Owns all entities
• User management

Edge Instance:

• Represents edge in cloud
• Manages entity ownership
• Tracks sync status

Entity Relations

Relation Types:

• Contains: Asset contains devices
• Manages: Edge manages devices
• Uses: Device uses gateway

Example Hierarchy:

1
2
3
4
5
6
7
8
9
10
11
12
13
Factory Edge
   |
   ├── Factory Building (Asset)
   │     |
   │     ├── Production Line 1 (Asset)
   │     │     ├── Robot Arm (Device)
   │     │     └── Conveyor (Device)
   │     │
   │     └── Production Line 2 (Asset)
   │           └── CNC Machine (Device)
   │
   └── Warehouse (Asset)
         └── Temperature Sensor (Device)

Querying Relations:

1
GET /api/relations?fromId=<ASSET_ID>&fromType=ASSET

Response:

1
2
3
4
5
6
7
[
  {
    "from": {"id": "<ASSET_ID>", "entityType": "ASSET"},
    "to": {"id": "<DEVICE_ID>", "entityType": "DEVICE"},
    "type": "Contains"
  }
]

Security Features

Authentication

Device Authentication:

• Access tokens (UUID-based)
• X.509 certificates (MQTT TLS)
• Username/password (MQTT)

User Authentication:

• Local username/password
• OAuth 2.0 (cloud-synced)
• JWT token sessions
• Two-factor authentication (optional)

Edge-Cloud Authentication:

• Edge routing key (UUID)
• Edge routing secret (credential)
• Mutual TLS (optional)

Encryption

Device Connections:

• MQTT over TLS (port 8883)
• HTTPS (port 8080 with TLS)
• CoAP over DTLS (port 5684)

Cloud Connection:

• gRPC over TLS (mandatory)
• Certificate validation
• Encrypted credentials

Data at Rest:

• PostgreSQL encryption (optional)
• Encrypted configuration files
• Secure credential storage

Access Control

Role-Based Access Control:

• Tenant Administrator (full access)
• Customer User (limited access)
• Generic roles (configurable)

Permissions:

• Read/Write entities
• Modify rule chains
• Access dashboards
• Manage users
• View audit logs

Integration Capabilities

REST API

Complete REST API on edge:

Device API:

1
2
3
4
POST /api/v1/<TOKEN>/telemetry
POST /api/v1/<TOKEN>/attributes
POST /api/v1/<TOKEN>/rpc
GET /api/v1/<TOKEN>/attributes

Platform API:

1
2
3
GET /api/device/<DEVICE_ID>
POST /api/plugins/telemetry/DEVICE/<DEVICE_ID>/timeseries/ANY?scope=ANY&keys=<KEYS>
GET /api/alarm/<ENTITY_TYPE>/<ENTITY_ID>?searchStatus=ACTIVE

Remote Integrations

HTTP Integration:

• Push data to external REST endpoints
• Webhook support
• Custom headers and authentication

MQTT Integration:

• Subscribe to external MQTT brokers
• Publish to cloud MQTT services
• Topic mapping and transformation

OPC-UA Integration:

• Connect to OPC-UA servers
• Node browsing and subscription
• Data type conversion

Custom Integrations:

• JavaScript-based converters
• Protocol adapters
• Data transformation

Performance Features

Rule Engine Performance

Actor-Based Processing:

• Parallel message handling
• Configurable thread pools
• Non-blocking I/O

Throughput:

Database Performance

Optimisations:

• Partitioned tables (monthly)
• Indexes on entity_id, ts
• Connection pooling
• Batch inserts

Query Performance:

• Latest values: < 10ms
• Historical range (1 hour): < 100ms
• Historical range (1 day): < 1000ms

Transport Performance

MQTT:

• 10,000+ concurrent connections (4-core)
• QoS 0: Minimal overhead
• QoS 1: Guaranteed delivery

HTTP:

• Connection pooling
• Keep-alive support
• Compression (gzip)

Monitoring Features

System Monitoring

Metrics Available:

• CPU usage (%)
• Memory usage (MB)
• Disk space (GB free)
• Database connections (active/idle)
• Queue size (messages pending)
• Cloud connection status

Health Check Endpoint:

1
GET /api/edge/health

Response:

1
2
3
4
5
6
7
8
9
10
11
{
  "status": "UP",
  "cloudConnection": "CONNECTED",
  "database": "UP",
  "diskSpace": {
    "status": "UP",
    "free": 53687091200,
    "threshold": 10485760
  },
  "queueSize": 42
}

Application Monitoring

Telemetry Stats:

• Messages received (total, /sec)
• Messages processed (total, /sec)
• Messages queued (total)
• Processing latency (avg, p95, p99)

Rule Engine Stats:

• Nodes executed
• Script execution time
• Error count

Alerting

System Alerts:

• Disk space < 10%
• Queue size > 50,000
• Cloud disconnected > 1 hour
• Database errors

Custom Alerts:

• Create via rule chains
• Email notifications
• Webhook calls
• SMS (via integrations)

OTA Updates

Software Package Management

Edge Software Updates:

• Download packages from cloud
• Version management
• Rollback capability

Device Firmware Updates:

• Firmware package distribution
• OTA update scheduling
• Update status tracking

Update Process:

1. Upload package to cloud
2. Assign to edge instance(s)
3. Edge downloads package
4. Edge schedules update
5. Update applied (edge or devices)
6. Status reported back to cloud

Batch Operations

Multi-Edge Management

From Cloud:

• Update rule chains on multiple edges
• Deploy dashboards to edge groups
• Push configuration changes
• Distribute firmware packages

Edge Groups:

• Organise edges by location, version, etc.
• Apply batch operations to groups
• Monitor group health

Next Steps

• Telemetry Synchronisation
• Entities and Relations
• Edge Alarms
• Edge Attributes
• OTA Updates
• Configuration Guide