Uniflow v1.0 Technical Spec All Core Modules Full Node Catalog

Uniflow User Manual

---

1. Introduction and Overview

1.1 Purpose

Uniflow is an advanced visual workflow automation, protocol ingestion, and rule-evaluation platform. Built specifically for industrial IoT, physical security integration, and telemetry processing, Uniflow bridges diverse communication protocols (Modbus, OPC UA, MQTT, SNMP, BACnet, HTTP, Avigilon, Milestone, Hexagon Lidar, CAN Bus, and SIA) with a powerful, deterministic visual rule engine. The application provides seamless real-time data ingestion, transformation, decision execution, local in-memory storage, and live diagnostic monitoring.

1.2 Target Audience

Operations Engineers & System Integrators: Users who design and configure automated data pipelines, map industrial sensors, and build complex logic graphs without writing raw code.
System Administrators: Professionals responsible for deployment, protocol security, diagnostic logging, and machine licensing across enterprise infrastructure.
Technicians & Maintenance Personnel: Support staff utilizing live telemetry views, real-time execution logs, and adapter helper tools to troubleshoot field devices and communication faults.

1.3 System Requirements

Operating System: Windows 10/11 (64-bit) or Windows Server 2019/2022.
Processor: Multi-core processor (Intel Core i5 / AMD Ryzen 5 or equivalent Xeon/EPYC architecture).
Memory: Minimum 4 GB RAM (8 GB+ recommended for large active tag topologies and high-frequency protocol ingestion).
Storage: 500 MB available disk space for application binaries and local persistent database files.
Runtime Environment: .NET Desktop Runtime (x64) supporting WPF Fluent UI rendering.
Network Interface: Dedicated NIC(s) reachable by field devices (TCP/UDP, serial COM ports for hardware adapters).

---

2. Getting Started

2.1 Installation and Setup

Uniflow is deployed as an integrated desktop control environment and background service suite.

Unpacking / Execution: Run the Uniflow desktop executable. The system initializes local IPC (Inter-Process Communication) to communicate with the underlying Uniflow background processing service.
Initial Verification: Upon launch, check the top-right corner of the interface across any page to verify active subsystem connection badges (e.g., *System Storage Connected*, *Local Catalog Sync Active*).

2.2 Quick Start Workflow

To verify operational readiness immediately after setup, follow this end-to-end onboarding and automation sequence:

Generate License Request: Navigate to the Settings page via the sidebar navigation and select the System License Management tab. Click Copy Code to capture your generated License Request Code and submit it to your support representative for registration.

Input System License: Upon receiving your issued license key string, paste it into the System License Key input field and click Save Settings in the toolbar.

Verify License Status: Observe the dynamic Status Badge Card update to LICENSED SYSTEM (teal/green badge). Check the Allowed Capacity Limits Table to verify your permitted source adapters and allowed instance counts.

Add Source: Navigate to the Sources page via the sidebar, click Add Source, select a source adapter (e.g., *Modbus TCP*), and configure its connection parameters.

Add Points to Source: Within the source configuration panel, add specific Data Points (e.g., holding registers) to sample, then click Save and start the source.

Add a New Rule: Navigate to the Rules page and click Add Rule to open the blank canvas.

Fill Identification Fields: In the rule settings panel, fill in the mandatory identification fields: Name, Group, Priority, and verify Enabled is checked.

Add Graph Nodes: From the Sources In/Out toolbox on the left, drag an Input Source node and a Write Value node onto your canvas.

Bind Source to Input Source: Select the Input Source node, click Configure Input... in its property panel, and bind it to the Data Point created in Step 5.

Bind Source to Write Value: Select the Write Value node, click Configure Target..., and bind its destination. Wire the output port of the Input Source across to the Value input port of the Write Value node.

Save the Rule: Click Save in the top toolbar. Verify that the compilation badge turns green and displays "Compiled".

Preview Execution: Click the Preview button to launch the live runtime window and monitor live data evaluating through your graph in real time.

The Uniflow application interface is structured around a modern Fluent UI Navigation Sidebar on the left, providing rapid access to the seven core functional workspaces:

Dashboard: A high-level overview of the system's operational state, displaying the visual topology of running data sources and rules, along with summary statistics and recent activity.

Rules: A design surface for building, compiling, and deploying visual automation graphs that process data and trigger actions.

Sources: A collection of configurable data adapters that connect to and ingest data from diverse systems, hardware devices, and network protocols.

Storage: A structured repository for managing persistent data points and monitoring live system telemetry. It enables flexible storage configuration, memory point management, and real-time data inspection for both individual variables and complex objects.

JSON Objects: A collection of user-defined JSON structures that act as flexible templates for shaping, organizing, and validating complex data payloads. These structures are used to parse raw data, maintain state for complex object types, and ensure consistent data formatting across the application.

Logs: A comprehensive, time-ordered record of all system activities, errors, and data processing events. It supports filtering, real-time inspection, and analysis to aid in monitoring and troubleshooting.

Settings: System-level configuration and administrative controls for managing logging verbosity, recursion protection, and machine licensing.

---

3.1 Dashboard

The Dashboard serves as the central operational monitor. It houses the Advanced Topology View, an interactive, hardware-accelerated D3.js visual representation of the active system architecture.

3.1.1 Two-Tier Topology Navigation

The visual topology engine operates across two distinct hierarchical display levels:

Level 1: System Overview: Upon initial load, the canvas renders the macro-level architecture, displaying active Source Adapters and high-level logical Rule Groups. This provides an immediate, uncluttered view of enterprise ingestion pipelines.

Level 2: Rule Group Deep-Dive: Double-clicking any Rule Group node zooms inside that specific subsystem, dynamically transitioning the canvas to display all individual Rule Graphs executing within that group. A dedicated ← Back to Overview button in the upper-left corner returns the viewport to the macro view.

3.1.2 Interactive Canvas & Controls

The dashboard canvas provides extensive spatial and animation customization options:

Arranging Sources (Persistent Layouts): Engineers can freely click and drag nodes across the D3 physics simulation canvas to arrange sources and groups according to physical plant layouts or architectural preferences. Node coordinates are automatically saved and persisted across application restarts.

Activity Toggle: An interactive toggle switch (Activity) enables or disables live visual telemetry animation pulses (glowing data bubbles) traveling along connection links whenever data frames pass between nodes.

Animation Speed Slider: A dedicated range slider (Speed) dynamically adjusts the transit velocity of telemetry pulses (adjustable from 500ms up to 5000ms), allowing operators to balance visual feedback against system busyness.

Fit View Button: Clicking the Fit button (⛶ Fit) instantly rescales and centers the D3 zoom transformation to frame all active nodes perfectly within the visible screen window.

Minimap Navigation: A picture-in-picture minimap in the lower corner tracks global node positions and renders an interactive bounding box representing the current viewport, allowing rapid panning across expansive topologies.

3.1.3 Node Properties & Scatterplot Diagnostics

Selecting any node on the canvas reveals the collapsible Node Details Panel at the bottom of the screen. This panel provides deep execution analytics:

Execution Metadata: Displays operational health badges, connection state, and live activity metrics.

Historical Scatterplot: Renders a time-series scatterplot tracking recent telemetry values, execution latencies, or evaluation states over time.

Graph Filtering: Technicians can isolate specific diagnostic streams using the panel's granular filtering controls:

Inputs vs. Outputs: Toggle buttons (Inputs / Outputs) instantly show or hide inbound vs. outbound telemetry series.

Live / Pause Stream: Clicking the live stream indicator button freezes incoming scatterplot updates, allowing engineers to inspect historical spikes without data scrolling away.

Series Isolation: Clicking individual metric keys inside the interactive chart legend isolates specific data point properties.

3.1.4 Operational Summary Indicator

A persistent status bar at the top of the dashboard displays aggregate health metrics, including total service uptime, real-time host CPU/RAM utilization, active source adapter counts, and running vs. disabled rule totals.

3.2 Rules

The Rules view is a comprehensive management interface for visual logic sets. It provides advanced sorting, filtering, and execution trace inspection.

┌────────────────────────────────────────────────────────────────────────┐

│ [ + Add Rule ] [ Refresh ] | Filter Name... | Group... | Source... │

├────────────────────────────────────────────────────────────────────────┤

│ Status │ Preview │ Edit │ Delete │ Rule Name │ Group │ Source │ Prio │

│ ● │ [P] │ [E] │ [D] │ AlarmCheck │ Sec │ Modbus │ 10 │

└────────────────────────────────────────────────────────────────────────┘

`3.2.1 Toolbar Actions`

Add Rule (+): Opens the dedicated Rule Editor workspace to design a new workflow from scratch.

Refresh: Synchronizes the active list of rules with the background processing engine.

Filtering: Live search textbox for filtering rules by name, paired with dropdown filters to isolate rules belonging to specific Groups or bound to specific Input Sources.

`3.2.2 Data Grid Columns`

Status (Indicator Ellipse): A color-coded status circle reflecting the rule's active state. Action: Double-clicking this indicator immediately toggles the rule between *Enabled* (Active) and *Disabled* (Paused).

Preview Button: Launches a live execution trace overlay. This allows engineers to view real-time data transitions and node evaluations occurring within that rule without opening the full editor.

Edit Button: Opens the selected rule inside the visual Rule Editor.

Delete Button: Permanently removes the rule set.

Rule Name: The defined unique identifier of the rule.

Group: Logical grouping category used for organizational tagging.

Source: The primary input adapter or event trigger bound to this rule.
Priority: Execution priority level determining evaluation order during simultaneous event storms.

`3.3 Sources`

The Sources view manages all data ingest adapters communicating with external hardware, field devices, and network endpoints.

│ [ + Add Source ] [ Refresh ] | Search by Name or URL... | Total │

│ Status │ Edit │ Delete │ Start/Stop │ Source Name/URL │ Type │ Runtime │

│ [Icon] │ [E] │ [D] │ [►] │ Plant PLC / IP │ Modb │ Running │

`3.3.1 Toolbar Actions`

Add Source (+): Invokes a creation dialog prompting the selection of a specific source adapter type.

Refresh: Reloads adapter status and configurations.

Search: Filters configured sources by matching names, IP addresses, or URLs.

Count Indicator: Displays total configured vs. active source metrics.

`3.3.2 Data Grid Columns`

Status Avatar: A protocol-specific icon encased in a dynamic, glowing rounded outline representing operational health (Green glow = Active/Healthy, Red glow = Fault/Error, Grey = Stopped).

Edit Button: Modifies the protocol configuration settings (IPs, polling rates, registers, topics).

Delete Button: Removes the adapter configuration.

Start / Stop Controls: Dedicated runtime control buttons (► Start / ■ Stop) allowing individual adapters to be brought online or offline independently. Includes an indeterminate progress ring during connection handshakes.

Source Name / URL: The user-defined friendly name and underlying network endpoint URI.

Type: The source adapter classification (e.g., *ModbusTcp*, *OpcUa*, *SnmpWalker*).

Runtime Status: Live operational state (e.g., *Connected*, *Listening*, *Disconnected*) paired with a sub-label displaying exact error messages if a connection fault occurs.

Helper Button: Available on applicable VMS adapters (Avigilon and Milestone) to launch a specialized exploration utility that queries and browses entity collections (such as Alarms, Cameras, Servers, and Sites) fetched directly via API.

---

`3.4 Storage`

The Storage view exposes Uniflow's internal memory space, local persistence engine, and live telemetry cache. It is divided into two primary pivot tabs.

`3.4.1 Filtering Card`

A unified search card allowing rapid filtering across both tabs by matching Name / Point ID or filtering by specific Value Types (e.g., *Boolean*, *Integer*, *Double*, *String*).

`3.4.2 Tab 1: Storage Points`

Manages the structural definitions of internal memory registers.

Actions: Edit ([E]) or Delete ([D]) storage definitions.

Name: The friendly name and unique point access key.

Value Type: The expected data structure.

Default Value: The initial starting state or baseline value assigned upon system initialization.

Access: Security access level (*Read/Write*, *ReadOnly*).

Max Size: Clamped capacity for string or byte array buffers.

Persistent Flag: A visual badge (*Yes* in Green / *No* in Red). When set to *Yes*, point values are automatically persisted across system reboots and power losses.

`3.4.3 Adding an Internal Storage "Data Point"`

To allocate a new memory variable for rule graphs or external protocol access, navigate to Tab 1: Storage Points and click the Add Storage Point (+) button in the upper toolbar. Fill out the following configuration dialog:

Name / Point ID (String): A unique identifier key used to address this memory variable within Rule Graphs or REST API queries (e.g., Facility_Target_Setpoint).

Value Type (Dropdown): Expected structural format (Boolean, Integer, Double, String).

Default Value (Dynamic): The initial starting state assigned to the memory variable upon creation or system boot (e.g., False, 0, 21.5, "Idle").

Access Level (Dropdown): Restricts access permissions (ReadWrite allows dynamic updating by rules/clients; ReadOnly locks the point as a constant or external read-only tag).

Max Size (Integer): Applicable for string data types, setting the maximum allowed character buffer allocation.

Persistent (Checkbox): When checked, the point's latest runtime value is continuously written to local disk storage, ensuring state recovery following server reboots or power outages.

`3.4.4 Tab 2: Live Data`

Provides real-time inspection of active values passing through or resting within internal storage.

Point ID & Name: Identifies the specific memory address.

Value Type: Data classification.

Value: Renders the current live value in a highly readable, monospaced Consolas font.

Timestamp: Exact UTC timestamp of the last recorded value mutation.

Actions (Write Value): A dedicated edit button allowing technicians to manually override and write a specific value directly into the storage point for simulation or forced override.

---

`3.5 JSON Objects`

The JSON Objects view manages custom metadata schemas used to parse, flatten, and extract deeply nested JSON payloads originating from HTTP endpoints, MQTT topics, or Webhook receivers.

│ [ + Add Schema ] [ Refresh ] | Search Name... | Filter Category... │

│ Actions │ Friendly Name │ Category │ Notes / Description │

│ [E] [D] │ AvigilonAlarmPayload │ Security │ Extracts rule matches │

`3.5.1 Toolbar & Filtering`

Add Schema (+): Opens the schema designer to map JSON property keys to strongly typed collection fields.

Search & Category Filters: Quickly isolates object schemas by matching text or categorical groupings.

`3.5.2 Data Grid Columns`

Actions: Edit or Delete object definitions.

Friendly Name: The identifier referenced inside Rule Graph nodes (e.g., json_to_collection).

Category: Organizational grouping.

Description / Notes: Contextual documentation regarding the expected payload structure.

Date Added: Creation timestamp.

`3.5.3 Adding a JSON Object Schema`

To define a new custom payload template, click Add Schema (+) in the upper toolbar and configure the following parameters:

Friendly Name (String): The unique schema identifier referenced inside Rule Graph nodes (e.g., Milestone_Event_Record).

Category (String): An organizational grouping tag used for filtering and sorting (e.g., Security, Sensors, HVAC).

Description / Notes (String): Contextual documentation explaining the payload source or intended use case.

Schema Properties Table: The core mapping structure where engineers define individual payload variables. Click Add Property (+) to configure each field:

Property Key / Path (String): The exact JSON key name or path to extract from incoming text (e.g., alarmState, event.id, device.temperature).

Data Type (Dropdown): Expected structural conversion format (String, Integer, Double, Boolean).

---

`3.6 Logs`

The Logs view provides a high-fidelity, real-time diagnostic stream of system events, protocol driver communications, and rule execution traces.

│ System Logs [● Live Stream] [x] Auto Scroll [Export] [Clear] │

│ Filter Time... | Level... | Region... | Filter Message text... │

│ Time │ Level │ Region │ Message (Consolas Wrap) │

│ 15:20:10.123 │ INFO │ ModbusSvc │ Connected to PLC 192.168.1.50 │

`3.6.1 Toolbar Actions`

Auto Scroll Checkbox: Toggles automatic tailing of incoming log entries.
Export ([Icon]): Dumps active in-memory log history to an external disk file for auditing.
Clear ([Icon]): Flushes the active view buffer.

`3.6.2 Granular Filter Bar`

Four dedicated input fields allow precise log isolation:

Time Filter: Matches specific hour/minute/second patterns.
Level Filter: Dropdown filtering by severity (*Info*, *Warning*, *Error*, *Debug*).
Region Filter: Filters by subsystem or protocol driver module (e.g., *OpcUaSvc*, *RuleEngine*).
Message Filter: Full-text search across log contents.

`3.6.3 Log Data Grid`

Displays exact timestamps, color-coded severity levels, operational regions, and multi-line wrapping message blocks formatted in monospaced typography. Action: Double-clicking any log row opens a detailed modal window displaying complete stack traces and execution metadata.

---

`3.7 Settings`

The Settings view configures core runtime parameters and manages system licensing across two main tabs.

`3.7.1 Toolbar Actions`

Save Settings ([Icon]): Commits changes to system configurations and triggers dynamic reloading.

`3.7.2 Tab 1: Logging Configuration`

Diagnostic Logging Verbosity: Dropdown selector adjusting the detail level written to logs (*Error Only*, *Normal*, *Detailed*, *Debug Trace*).

Max Rule Trigger Depth: A numerical input clamped between 1 and 100. Defines the maximum allowed depth for recursive rule execution (i.e., Rule A triggers Rule B, which triggers Rule C). This safety clamp prevents infinite feedback loops from locking up system CPU resources.

`3.7.3 Tab 2: System License Management`

License Request Code: A read-only text box generating a unique hardware identifier for the hosting machine. Includes a Copy Code button to send to support for license issuance.

System License Key: Input area to paste active license cryptographic strings.

Status Badge Card: Dynamic shield display reflecting active validation state:

LICENSED SYSTEM (Teal/Green border & badge).

UNLICENSED SYSTEM (Red border & badge).

LICENSE EXPIRED (Red border & badge).

Allowed Capacity Limits Table: Displays an exact table of permitted source connections based on the active license (e.g., *ModbusTcp: 10 allowed*, *OpcUa: 5 allowed*).

---

`4. Rule Editor & Graph Nodes`

`4.1 Philosophy of Uniflow Rules`

Visual rules act as the intelligent "nervous system" of Uniflow. Rather than relying on continuous, CPU-heavy polling loops, rules are strictly event-driven. When a source adapter ingests a telemetry frame or an internal storage point changes value, the rule engine instantly awakens, evaluates the connected logic graph from left to right, executes decision branches, and dispatches outbound control commands.

`4.1.1 Core Execution Mechanics & Concurrency`

Understanding how the rule engine processes logic is essential for designing robust automation:

Event Awakening & Concurrency: Rules execute asynchronously across multi-threaded thread-pool workers. When multiple independent source adapters or storage points emit telemetry simultaneously, their bound rules are dispatched and evaluated in parallel, ensuring high-throughput ingestion without single-threaded bottlenecks.

Deterministic Order of Execution: Within an awakened rule graph, node evaluation strictly follows a topological ordering (from upstream data ingest to downstream sinks). A functional logic node (e.g., Addition or Greater Than) will not evaluate until all upstream wire connections delivering its input parameters are fully resolved.

Branching & Sinks: Conditional flow control blocks (such as Branch (If / Else)) evaluate boolean expressions to dynamically route execution down isolated graph pathways. The evaluation cycle completes when all active branches terminate at outbound action sinks (e.g., Write Value or Execute Command).

Target Contention & Priority: When multiple concurrent rules attempt to write to the identical internal storage point or external protocol register, write operations are processed thread-safely. During simultaneous event storms, the execution scheduler prioritizes evaluations based on each rule's configured Priority Level (higher priority rules evaluate first). However, engineers should design rules defensively to avoid uncoordinated competing writes that cause unpredictable value overwriting.

Feedback Loops & Recursion Breaker: If a rule graph binds to a specific storage point as its input source and subsequently executes a Write Value action targeting that exact same storage point, committing the write instantly re-triggers the rule, initiating a circular feedback loop. To protect host CPU resources from infinite recursion lockups, Uniflow enforces a rigorous safety breaker (Max Rule Trigger Depth, configurable in Settings). If a self-triggering loop or chained circular sequence exceeds the configured depth threshold (clamped from 1 to 100), the engine immediately aborts execution and logs a recursion safety fault.

┌──────────────────────────────────────────────────────────────────────────────┐

│ RULE METADATA │

│ [x] Enabled │

│ Priority: [ 10 ] │

│ Name: [ OverheatShutoff ] │

│ Group: [ SafetySvc ] │

│ Source: [ Modbus Svc (192.168.1.50) ▼] │

│ Graph Nodes: [ 3 active nodes ] │

└──────────────────────────────────────────────────────────────────────────────┘

│

▼ (Opens Graph Canvas)

┌─────────────────┬────────────────────────────────────────────────────────────┐

│ Toolbox │ Canvas │

│ ├─ Sources │ ┌───────────────┐ ┌──────────┐ │

│ ├─ Constants │ │ Source Signal ├─────►│ If > 85 ├──────┐ │

│ ├─ Logic │ └───────────────┘ └──────────┘ │ │

│ └─ ...... │ ▼ │

│ │ ┌───────────────────────────────┐ │

│ │ │ Write Value │ │

│ │ │ Target: [Data Point] │ │

│ │ └───────────────────────────────┘ │

└─────────────────┴────────────────────────────────────────────────────────────┘

`4.2 Creating and Debugging Rules`

Clicking Add Rule instantly redirects the engineer to a fresh visual canvas editor. No preliminary dialog is presented. Instead, a new rule is automatically initialized with sensible defaults:

Rule Name: Defaults to New Rule.
Group: Defaults to General.
Priority Level: Defaults to 50.
Enabled State: Enabled (true) by default.

`4.2.1 Configuring Rule Identity and Metadata`

At any point during rule design, the engineer can configure these identity fields directly in the top header panel of the Rule Editor:

Rule Name (TextBox): A clear, unique identifier describing the rule's exact purpose (e.g., BoilerOverheatProtection, BadgeAccessGranted).
Group (ComboBox): An organizational categorization tag allowing engineers to sort and filter large enterprise catalogs by department or subsystem (e.g., HVAC, Security, Telemetry). The field is editable, allowing you to select an existing group or type a new one.
Priority Level (ComboBox, options from 10 to 100): Determines execution precedence during simultaneous event storms. Rules assigned higher priority numbers are evaluated first by the execution scheduler.
Enabled State (CheckBox): Toggles whether the rule should begin active evaluation immediately upon saving, or remain paused in a disabled draft state.

`4.2.2 Required Nodes in a Functional Rule`

For a visual graph to compile and execute successfully, it cannot just be a set of intermediate calculations. Every rule must follow a clear execution pipeline comprising at least one Trigger/Ingestion node and at least one Action/Sink node:

Trigger / Ingestion Node:
The entry point of a rule. It initiates graph execution upon receiving telemetry changes or external signals.
Input Source: Ingests continuous telemetry points (e.g., Modbus registers, OPC UA variables) or internal memory storage registers.
Event Input: Ingests push-based system events (e.g., VMS motion alerts, SIA receiver signals).
*Note*: Without an ingestion node, the rule's logic has no starting trigger and will never evaluate.

Action / Sink Node:
The termination point of a rule. It converts in-memory evaluated results into physical or external impact.
Write Value: Writes the final calculated data back to a device address or triggers system actions (e.g., toggling a Modbus coil, triggering a Milestone VMS alarm, writing a temperature setpoint to BACnet, or updating an Internal Storage point).
*Note*: Without an action/sink node, a rule will evaluate its logic successfully in memory but will produce no external side effects or actions.

`4.2.3 Connecting Graph Nodes: Mapping the Flow from Source to Sink`

Once the required ingestion and action nodes are placed on the canvas along with any necessary intermediate functional blocks (math, comparisons, timers), the logic flow is established by connecting ports:

Understanding Ports:

Input Ports (Left side of node): Receive incoming data values or trigger signals from upstream nodes.
Output Ports (Right side of node): Emits calculated values, boolean matches, or execution triggers.

Drawing Connections:

Hover over an output port on an upstream node (the cursor changes to a connection tool).
Click and drag a connection wire from the output port.
Drop the wire onto a compatible input port on a downstream node (e.g., connecting a boolean output to a logical gate input).
Repeat this process to map the complete sequence of operations, carrying data smoothly from the trigger source, through the mathematical and logical processing blocks, and finally into the input ports of the Write Value data sink node.

Data Flow Validation:

Connections must map compatible data types (e.g., passing a float to a float math input).
The visual editor automatically highlights valid ports and blocks invalid or recursive connections to ensure static compilation stability before metadata is saved.

`4.2.4 Real-Time Rule Execution Debugging`

To facilitate seamless validation, troubleshooting, and tuning of complex automation workflows, Uniflow features a state-of-the-art Live Rule Runtime Preview engine. Instead of debugging in isolation or reading raw text logs, operators can observe their logic executing in real time directly on the visual canvas.

##### 1. Initiating a Live Debugging Session

To attach the debugger to a rule:

Navigate to the Rules section in the main navigation.
Select the desired rule from the list grid.
Click the Preview Rule (Live Execution Trace) button on the grid toolbar.
This launches the dedicated Rule Runtime Preview window, which automatically subscribes to the background UniflowService runtime engine via named pipes to stream live telemetry and event execution traces.

##### 2. Dynamic Flow Pulsing (Canvas Tracing)

The preview canvas updates dynamically, using colored glowing "pulses" to visualize data flow and execution frequency:

Computational State Pulses: Nodes and wire connections emit immediate glowing pulses corresponding to their result state:
Teal Glow (Succeeded): Indicates that the node evaluated successfully without errors.
Red Glow (Failed): Indicates that the node encountered a runtime exception or failed evaluation.
Amber Glow (Skipped): Indicates that the node was bypassed due to logical branching.
Deep Blue Glow (Running): Indicates an ongoing asynchronous task or loop execution.
Execution Path & Value Propagation: Active value transitions trigger distinct Bright Blue or Purple pulses along the connections to indicate exactly how data travels through ports.
Fading & Temporal Decay: Older execution pulses automatically fade away over a brief, calculated interval. This creates a temporal trail, allowing operators to visually see the frequency, speed, and exact path of the latest trigger events.

##### 3. Integrated Diagnostics & Live Logs Terminal

Complementing the visual canvas is a detailed log terminal displaying a synchronized millisecond-precise live feed of rule activities:

Millisecond-precise Timestamps: Logs are stamped in a high-precision format (HH:mm:ss.fff) to capture fast-moving, high-frequency triggers.
Color-Coded Severity Levels:
INFO (Blue): General attachment, session state, and diagnostic connections.
RULE (Teal): Global rule execution starts, finishes, and broad outcomes.
ERROR (Red): Detailed exception stack traces, network timeouts, or variable retrieval issues.
WARN (Amber): Out-of-bounds metrics, quality drops, or retry occurrences.
DEBUG (Gray): Granular trace outputs representing intermediate computations inside individual node blocks.
Auto-Scroll & Navigation Locks: Enable the Auto-Scroll toggle to lock the log terminal to the latest incoming stream, or disable it to pause and inspect a specific historical trace.
Fit to View: Click the Fit command to instantly scale and center the canvas, keeping large and complex rule topologies fully visible at a glance.

---

`4.3 Anatomy & Meaning of Graph Nodes`

Once metadata is committed, the user enters the visual canvas. Logic is constructed by connecting functional building blocks known as Nodes.

┌──────────────────────────┐

│ [ Node Name ] │

──► (Input Port) (Output Port) ──►

│ Executes Core Function │

└──────────────────────────┘

`4.3.1 What is a Graph Node?`

A Graph Node represents a self-contained, atomic execution unit designed to perform a specific, focused task. Conceptually, every node operates on a simple three-stage principle: it ingests incoming data parameters across its input ports, executes its designated internal logic transformation (such as calculating a mathematical equation, filtering a signal, or evaluating a logical comparison), and immediately pushes the resulting calculated values or control flow commands outward through its output ports.

Input Ports (Left side): Receive data values or execution control flows from upstream nodes.
Core Logic Engine (Center): Evaluates incoming variables, performs mathematical transformations, or tests boolean conditions.
Output Ports (Right side): Transmit the resulting data values or branched execution flows onward to downstream nodes.

---

`4.4 Exhaustive Graph Node Catalog`

Below is the complete, exhaustive catalog of all visual graph nodes available in Uniflow, organized by category, including exact port definitions and operational behavior.

`4.4.1 Sources In/Out (Ingest)`

Nodes that initiate workflow execution or read live telemetry and memory variables into the graph.

Input Source
*Description*: Ingests continuous telemetry points or internal storage variables sampled by active source adapters or memory registers.

*Inputs*: None.

*Outputs*: Dynamic Point Fields (Varies by configuration). Renders specific output ports for each selected point or memory tag, outputting their live values in their configured data type.

Event Input
*Description*: Subscribes to complex, structured event streams (such as Avigilon camera alarms, Milestone motion events, or Lidar intrusion alerts) emitted by a configured source adapter. When the target event fires, this node awakens the rule graph.
*Inputs*: None.
*Outputs*: Dynamic Event Fields (Varies by configuration). While a newly created node defaults to a single Trigger boolean output, configuring the node via the Configure Event... dialog dynamically generates specific output ports for each selected event property (e.g., timestamp, sequence, rawJson, alarmState), allowing direct data mapping into downstream logic.

Data Source
*Description*: Reads the current runtime value of specific Data Points (such as Modbus holding registers, OPC UA nodes, SNMP OIDs, or BACnet objects) configured within an active source adapter.
*Inputs*: None.
*Outputs*: Dynamic Point Fields (Varies by configuration). Renders specific output ports for each selected data point, outputting their live values in their configured data type.

---

`4.4.2 Actions & Sinks`

Nodes that execute state changes, write data outward, or trigger external actions.

Write Value
*Description*: Acts as an outbound action sink. When triggered, it captures an incoming data variable and writes it outward to a targeted internal storage point or external protocol register.
*Inputs*: Trigger (Boolean) - Initiates write execution; Value (Any) - The data payload to write.
*Outputs*: None.
Execution Settings:
Trigger Mode: Determines how incoming boolean trigger pulses translate into write executions:
Repetitive: Executes continuously on every evaluation cycle as long as the trigger is True.
OnceOnTrue: Executes exactly once on the rising edge (False → True).
OnceOnFalse: Executes exactly once on the falling edge (True → False).
OnAnyChange: Executes whenever the trigger changes state.
Cooldown (ms): Minimum interval between operations to prevent hardware flooding.
Debounce (ms): Requires the trigger signal to remain stable for a specified duration before committing.
Write Policy: Dictates transmission logic:
Always: Transmits payload unconditionally on every trigger.
OnChange: Only transmits if the value differs from the last successful write.
OnChangeWithTolerance: Only transmits if the numeric difference exceeds a defined Tolerance threshold.
ForceInterval: Transmits on change, but forces a write if no change occurs within a specific heartbeat window.

Execute Command
*Description*: Executes an external command or system action (such as camera PTZ presets, alarm triggers, or system scripts) via a configured source adapter.
*Inputs*: Trigger (Boolean) - Initiates command execution.
*Outputs*: None.
Execution Settings:
Trigger Mode: Behavior mirrors Write Value (Repetitive, OnceOnTrue, OnceOnFalse, OnAnyChange).
Cooldown (ms): Suppresses rapid command executions to protect external systems.
Debounce (ms): Requires trigger stability before executing the command.

`4.4.3 Constants`

Nodes providing static, unchangeable primitive values into the graph.

Constant Number
*Description*: User-defined static 32-bit integer or floating-point number.
*Inputs*: None | *Outputs*: Output (Integer/Double)

Constant Boolean
*Description*: User-defined static Boolean value.
*Inputs*: None | *Outputs*: Output (Boolean)

Constant String
*Description*: User-defined static text string.
*Inputs*: None | *Outputs*: Output (String)

Constant Array
*Description*: User-defined static array of types: string, int, double, or bool.
*Inputs*: None | *Outputs*: Output (Array)

Current Time
*Description*: Current system UTC time.
*Inputs*: None | *Outputs*: String (Formatted DateTime string), DateTime (DateTime object)

Guid
*Description*: Generates a unique 128-bit GUID string identifier.
*Inputs*: None | *Outputs*: Output (String)

---

`4.4.4 Logic & Comparisons`

Nodes executing logical operations and boolean comparison checks.

Greater Than
*Inputs*: Input A (Number), Input B (Number) | *Outputs*: Output (Boolean) - True if A > B.

Greater Than or Equal
*Inputs*: Input A (Number), Input B (Number) | *Outputs*: Output (Boolean) - True if A >= B.

Less Than
*Inputs*: Input A (Number), Input B (Number) | *Outputs*: Output (Boolean) - True if A < B.

Less Than or Equal
*Inputs*: Input A (Number), Input B (Number) | *Outputs*: Output (Boolean) - True if A <= B.

Equal
*Inputs*: Input A (Dynamic), Input B (Dynamic) | *Outputs*: Output (Boolean) - True if values match exactly.

Not Equal
*Inputs*: Input A (Dynamic), Input B (Dynamic) | *Outputs*: Output (Boolean) - True if values differ.

Logical AND
*Inputs*: Input A (Boolean), Input B (Boolean) | *Outputs*: Output (Boolean) - True if both A and B are true.

Logical OR
*Inputs*: Input A (Boolean), Input B (Boolean) | *Outputs*: Output (Boolean) - True if either A or B is true.

Logical NOT
*Inputs*: Input (Boolean) | *Outputs*: Output (Boolean) - Inverts the boolean input.

Logical XOR
*Inputs*: Input A (Boolean), Input B (Boolean) | *Outputs*: Output (Boolean) - True if inputs differ.

Is NULL
*Description*: Checks if the input value is null or undefined.
*Inputs*: Input (Dynamic) | *Outputs*: IsNull (Boolean) - True if input value is null.

Default Value (Coalesce)
*Description*: Returns the primary input if non-null; otherwise falls back to the default fallback value.
*Inputs*: Input (Dynamic), Default (Dynamic) | *Outputs*: Value (Dynamic).

---

`4.4.5 Flow Control`

Nodes controlling branching, routing, and conditional execution paths.

Branch (If / Else)
*Description*: Routes execution flow based on a boolean condition evaluation.
*Inputs*: Condition (Boolean) - The expression check.
*Outputs*: True (Flow) - Executed if condition is true; False (Flow) - Executed if condition is false.

Multi-Condition If
*Description*: Evaluates multiple comparison rows in sequence and combines them into a single boolean result using configurable logic.
*Inputs*: Dynamic Operand Inputs (L1, R1, L2, R2, etc.) generated for each configured row.
*Outputs*: Result (Boolean) - The aggregated boolean result of all evaluated comparison rows.
*Settings*:
Mode: ALL (Logical AND - all conditions must be true) or ANY (Logical OR - at least one condition must be true).
Rows: A configurable table defining the comparisons (Left Operand, Operator, Right Operand). Each operand can be a static constant or a dynamic input port.

Switch
*Description*: Compares a single input value against multiple user-defined cases. It acts as a multi-way boolean branch.
*Inputs*: Value (Dynamic) - The value to be tested.
*Outputs*: Dynamic Case Outputs (Case 1, Case 2, etc.). Each output port emits True if the input value matches that specific case, and False otherwise.
*Settings*:
Input Type: Defines the data type of the input value (e.g., String, Integer).
Cases: A configurable table where each entry defines a comparison value. Adding a row dynamically creates a matching output port on the node.

Select
*Description*: Selects and routes one of multiple input data streams to the output based on a zero-based index.
*Inputs*: Index (Double/Integer) - Zero-based selector index; In 0 (Dynamic) - Mandatory default input option. Additional option ports (In 1, In 2, etc.) can be dynamically added or removed.
*Outputs*: Result (Dynamic) - The selected input data payload.
*Settings*:
Input Ports: Configurable list allowing users to add or remove input option streams. The default In 0 port is mandatory and cannot be deleted.

Gate
*Description*: Conditionally passes or blocks data payload based on a boolean control signal.
*Inputs*: Open (Boolean) - Gate control signal (True = open/pass, False = closed/block); Value (Dynamic) - Input data payload.
*Outputs*: Result (Dynamic) - Emits Value payload when open, or null when closed.

`4.4.6 Strings`

Advanced string manipulation, formatting, and pattern matching nodes.

Format
*Description*: Composes a string by inserting input values into a template with placeholders (e.g., {0}, {1}).
*Inputs*: Arg 0, Arg 1... (Dynamic based on configuration).
*Outputs*: Result (String).

Regex Extract
*Description*: Extracts substrings from text using a Regular Expression pattern match.
*Inputs*: Text (String).
*Outputs*: Result (String).

Substring
*Description*: Extracts a sequence of characters from the input text starting at a specific index.
*Inputs*: Text (String), Start (Integer), Len (Integer).
*Outputs*: Result (String).

Replace
*Description*: Replaces all occurrences of a specific substring with another text.
*Inputs*: Text (String), Old (String), New (String).
*Outputs*: Result (String).

Contains
*Description*: Checks if the input text contains a specific substring.
*Inputs*: Text (String), Value (String).
*Outputs*: Result (Boolean).

Equal
*Description*: Compares two strings for exact character-for-character equality.
*Inputs*: Text (String), Other (String).
*Outputs*: Result (Boolean).

IndexOf
*Description*: Returns the zero-based position of the first occurrence of a substring in the input text (-1 if not found).
*Inputs*: Text (String), Value (String).
*Outputs*: Result (Integer).

Trim
*Description*: Removes leading and trailing whitespace from the input text.
*Inputs*: Text (String).
*Outputs*: Result (String).

Upper / Lower
*Description*: Converts the input text to all uppercase or all lowercase characters.
*Inputs*: Text (String).
*Outputs*: Result (String).

Length
*Description*: Returns the total number of characters in the input text.
*Inputs*: Text (String).
*Outputs*: Result (Integer).

Is Empty
*Description*: Checks if the input text is null or an empty string.
*Inputs*: Text (String).
*Outputs*: Result (Boolean).

---

`4.4.7 Arithmetic Math`

Nodes performing core numeric arithmetic across floating-point and integer types.

Addition
*Description*: Calculates the sum of two numeric inputs.
*Inputs*: L (Number), R (Number) | *Outputs*: Result (Number).

Subtraction
*Description*: Calculates the difference between the left and right numeric inputs (L - R).
*Inputs*: L (Number), R (Number) | *Outputs*: Result (Number).

Multiplication
*Description*: Calculates the product of two numeric inputs.
*Inputs*: L (Number), R (Number) | *Outputs*: Result (Number).

Division
*Description*: Calculates the quotient of the left input divided by the right input (L / R).
*Inputs*: L (Number), R (Number) | *Outputs*: Result (Number).

Square Root
*Description*: Calculates the square root of the input value.
*Inputs*: Number (Number) | *Outputs*: Root calculation (Number).

Power
*Description*: Calculates a base raised to a specified power.
*Inputs*: Base (Number), Exponent (Number) | *Outputs*: Calculated power (Number).

Logarithm
*Description*: Calculates the logarithm of a specified number in a specified base.
*Inputs*: Value (Number), Base (Number) | *Outputs*: Log value (Number).

Sine
*Description*: Calculates the sine of a specified angle in radians.
*Inputs*: Angle (Number) | *Outputs*: Trig ratio (Number).

Cosine
*Description*: Calculates the cosine of a specified angle in radians.
*Inputs*: Angle (Number) | *Outputs*: Trig ratio (Number).

Tangent
*Description*: Calculates the tangent of a specified angle in radians.
*Inputs*: Angle (Number) | *Outputs*: Trig ratio (Number).

Random
*Description*: Generates a pseudo-random floating-point number within a specified range.
*Inputs*: None (Configured via properties).
*Outputs*: Result (Double).
*Settings*: From (Min), To (Max).

Abs
*Description*: Calculates the absolute value of a number.
*Inputs*: Value (Number) | *Outputs*: Result (Number).

Min
*Description*: Returns the smaller of two input values.
*Inputs*: A (Number), B (Number) | *Outputs*: Result (Number).

Max
*Description*: Returns the larger of two input values.
*Inputs*: A (Number), B (Number) | *Outputs*: Result (Number).

Round
*Description*: Rounds a numeric value to a specified number of decimal places.
*Inputs*: Value (Number), Precision (Integer) | *Outputs*: Result (Number).

Floor
*Description*: Rounds a number down to the next lowest integer.
*Inputs*: Number (Number) | *Outputs*: Integer rounded down (Number).

Ceiling
*Description*: Rounds a number up to the next highest integer.
*Inputs*: Number (Number) | *Outputs*: Integer rounded up (Number).

Clamp
*Description*: Constrains a value to lie between a specified minimum and maximum range.
*Inputs*: Value (Number), Min (Number), Max (Number) | *Outputs*: Result (Number).

---

`4.4.8 Timers & Pulses`

Industrial automation timing blocks for signal conditioning and delayed execution.

Pulse (TP)
*Description*: Generates a fixed-duration high output pulse triggered by a rising edge of the input.
*Inputs*: Input (Boolean), Duration (ms) | *Outputs*: Output (Boolean), Elapsed (ms).

Timer On-Delay (TON)
*Description*: Delays the True output until the input has remained True for the specified duration.
*Inputs*: Input (Boolean), Duration (ms) | *Outputs*: Output (Boolean), Elapsed (ms).

Timer Off-Delay (TOF)
*Description*: Keeps the output True for a specified duration after the input has transitioned to False.
*Inputs*: Input (Boolean), Duration (ms) | *Outputs*: Output (Boolean), Elapsed (ms).

Value Delay
*Description*: Delays the transmission of any input value by a specified time interval.
*Inputs*: Input (Any), Duration (ms) | *Outputs*: Output (Any).

Rising Edge (R_TRIG)
*Description*: Detects a False-to-True transition and emits a single-cycle high pulse.
*Inputs*: CLK (Boolean) | *Outputs*: Q (Boolean).

Falling Edge (F_TRIG)
*Description*: Detects a True-to-False transition and emits a single-cycle high pulse.
*Inputs*: CLK (Boolean) | *Outputs*: Q (Boolean).

Any Change
*Description*: Emits a single-cycle high pulse whenever the input value changes state.
*Inputs*: Input (Any) | *Outputs*: Q (Boolean).

---

`4.4.9 Signal & State`

Industrial automation logic blocks for maintaining states, latched signals, and pulse counts.

Linear Scaling
*Description*: Maps a numeric value from an input range (Min/Max) to an output engineering range (Min/Max).
*Inputs*: Input (Number) | *Outputs*: Output (Number) - Scaled value.

Smoothing Filter
*Description*: Applies a moving average or exponential smoothing equation over historical samples.
*Inputs*: Input (Number) | *Outputs*: Output (Number) - Smoothed value.

Hysteresis Filter
*Description*: Prevents rapid signal oscillation (chatter) using high and low threshold bands.
*Inputs*: Input (Number) | *Outputs*: Output (Boolean) - State evaluation.

SR Flip-Flop
*Description*: Standard Set/Reset latch. Q goes high on Set and stays high until Reset fires.
*Inputs*: Set (Boolean), Reset (Boolean) | *Outputs*: Q (Boolean).

RS Flip-Flop
*Description*: Reset-priority latch. Similar to SR, but Reset takes precedence if both inputs are active.
*Inputs*: Set (Boolean), Reset (Boolean) | *Outputs*: Q (Boolean).

Count Up (CTU)
*Description*: Increments the internal counter on each rising edge of the CU input. Output Q becomes True when the current value CV is greater than or equal to the preset value PV.
*Inputs*: CU (Boolean) - Count up pulse; Reset (Boolean) - Resets CV to 0; PV (Number) - Preset value.
*Outputs*: Q (Boolean) - Threshold reached; CV (Number) - Current count value.

Count Down (CTD)
*Description*: Decrements the internal counter on each rising edge of the CD input. Output Q becomes True when the current value CV reaches 0.
*Inputs*: CD (Boolean) - Count down pulse; Load (Boolean) - Loads PV into CV; PV (Number) - Preset value.
*Outputs*: Q (Boolean) - Zero reached; CV (Number) - Current count value.

Count Up/Down (CTUD)
*Description*: Provides simultaneous up and down counting logic with separate threshold indicators.
*Inputs*: CU (Boolean) - Count up; CD (Boolean) - Count down; Reset (Boolean) - Zeroes CV; Load (Boolean) - Sets CV to PV; PV (Number) - Preset value.
*Outputs*: QU (Boolean) - Up threshold reached; QD (Boolean) - Down threshold reached; CV (Number) - Current count value.

---

`4.4.10 Arrays`

Managing, filtering, and performing operations on ordered lists of data.

String Split
*Description*: Splits a single string into an array of strings based on a specified separator.
*Inputs*: Text (String), Delimiter (String) | *Outputs*: Array (String Array).

Array Scope
*Description*: Iterates over a primitive array. Generates a scope context for each item, exposing the item value and its array index, allowing downstream actions to be executed for each item individually.
*Inputs*: Array (Array) | *Outputs*: Item (Any), Index (Number).

Filter Array
*Description*: Creates a new array containing only the elements that satisfy a configured comparison.
*Inputs*: Array (Array), Op (String Operator), Value (Any) | *Outputs*: Array (Array).

Any Match
*Description*: Returns True if at least one element in the array meets the specified criteria.
*Inputs*: Array (Array), Op (String), Value (Any) | *Outputs*: Q (Boolean).

All Match
*Description*: Returns True if every single element in the array meets the specified criteria.
*Inputs*: Array (Array), Op (String), Value (Any) | *Outputs*: Q (Boolean).

Array Contains
*Description*: Checks if a specific target value exists anywhere within the array.
*Inputs*: Array (Array), Value (Any) | *Outputs*: Result (Boolean).

Array Index
*Description*: Returns the zero-based position of the first occurrence of a value. Returns -1 if not found.
*Inputs*: Array (Array), Value (Any) | *Outputs*: Result (Integer).

Array Length
*Description*: Returns the total count of elements currently in the array.
*Inputs*: Array (Array) | *Outputs*: LEN (Integer).

Is Empty
*Description*: Returns True if the array has zero elements.
*Inputs*: Array (Array) | *Outputs*: Result (Boolean).

Get Item
*Description*: Retrieves the element at a specific index. Index is zero-based.
*Inputs*: Array (Array), Index (Integer) | *Outputs*: Item (Any).

Average
*Description*: Calculates the mathematical average (mean) of all numeric values in the array.
*Inputs*: Array (Numeric Array) | *Outputs*: Result (Double).

Sum
*Description*: Calculates the total sum of all numeric values in the array.
*Inputs*: Array (Numeric Array) | *Outputs*: Result (Double).

Minimum / Maximum
*Description*: Returns the smallest (Minimum) or largest (Maximum) numeric value found in the array.
*Inputs*: Array (Numeric Array) | *Outputs*: Result (Double).

---

`4.4.11 Collections & Object Extraction`

Nodes designed for parsing structured, multi-property object records.

Collection Scope
*Description*: Iterates through items in a collection, exposing each element sequentially as a loop context.
*Inputs*: Collection (Any).
*Outputs*: Item (Any).
*Settings*:
Scope Key Field: The property path inside each collection item that serves as its unique identifier (e.g., id or uid).
Scope Display Field: The property path used to display a user-friendly name or label representing each active item scope in the user interface (e.g., name or title).

Collection Filter
*Description*: Filters an object collection by comparing a property or field value to the provided input value.
*Inputs*: Collection (Any), Value (Any).
*Outputs*: Result (Any).

Collection Sort
*Description*: Sorts a collection of objects by one or more fields in ascending (ASC) or descending (DESC) order based on dynamic sorting criteria groups.
*Inputs*: Collection (Any).
*Outputs*: Result (Any) - Sorted collection.
*Settings*:
Sorting Criteria: Dynamic list of sorting groups. Each group contains a dropdown to select the target field and a dropdown to select order (ASC/DESC). Multi-level sort priority is governed by group order.

Collection First
*Description*: Extracts the first object record from a collection. Exposes a helper flag indicating whether a non-null item was successfully retrieved.
*Inputs*: Collection (Any).
*Outputs*: Result (Any), Not Null (Boolean).

Object Get
*Description*: Plucks the value of a specific property or field from an object.
*Inputs*: Object (Any).
*Outputs*: Result (Any).

Collection Any
*Description*: Checks if any item inside a collection satisfies the specified field comparison condition.
*Inputs*: Collection (Any), Value (Any).
*Outputs*: Result (Boolean).

Collection All
*Description*: Checks if every item inside a collection satisfies the specified field comparison condition.
*Inputs*: Collection (Any), Value (Any).
*Outputs*: Result (Boolean).

Collection Count
*Description*: Counts the total number of items currently in the collection.
*Inputs*: Collection (Any).
*Outputs*: Count (Integer).

Collection Select
*Description*: Projects/selects a specific field from all items in the collection, returning a new collection of values.
*Inputs*: Collection (Any).
*Outputs*: Result (Any).

---

`4.4.12 JSON Utilities`

Nodes for parsing, validating, building, and extracting values from JSON payloads to interface with external web APIs and structured event streams.

Deserialize
*Description*: Parses a raw JSON string into a strongly-typed object schema.
*Inputs*: JSON (String).
*Outputs*: Success (Boolean). Exposes properties of the parsed object as dynamic output ports on the node.
*Settings*:
Schema: The object schema definition to use for parsing.
Category: The schema category folder.

Serialize
*Description*: Converts the properties of an object schema back into a serialized JSON string.
*Inputs*: Trigger (Boolean), Message (String).
*Outputs*: Success (Boolean), Object (String) - Serialized JSON string.
*Settings*:
Schema: The object schema definition to serialize.
Category: The schema category folder.

To Collection
*Description*: Parses a JSON array string into an enumerable collection of strongly-typed items governed by a defined schema.
*Inputs*: JSON (String).
*Outputs*: Collection (Any).
*Settings*:
Schema: The item schema definition to use.

Extract
*Description*: Plucks specific values from a JSON string using JSONPath query rows.
*Inputs*: Message (String) - The JSON payload.
*Outputs*: Success (Boolean). Plus dynamic output ports corresponding to each configured JSONPath query.
*Settings*:
Fields: A table defining comparison or extraction rows, where each row dynamically creates a labeled output port mapping to a specific JSONPath (e.g., $.store.book[0].title).

Is Valid
*Description*: Checks if a string is syntactically valid JSON.
*Inputs*: JSON (String).
*Outputs*: Q (Boolean) - True if the JSON is valid.

---

`4.4.13 DateTime`

Nodes for parsing, manipulating, and comparing timestamps and date/time objects.

Date Time (Now)
*Description*: Emits the current system date and time as a formatted string, DateTime object, or Unix timestamp in seconds or milliseconds.
*Outputs*: String (String) - Formatted date/time text; DateTime (DateTime) - Timestamp object; Unix Time (s) (Double) - Unix timestamp in seconds; Unix Time(ms) (Double) - Unix timestamp in milliseconds.
*Settings*:
Mode: Output format mode (Pattern, Local, Utc).
Format: Custom date format string (e.g., dd/MM/yyyy HH:mm:ss).

Parse Date
*Description*: Parses a raw date/time string into a structured DateTime object.
*Inputs*: Input (String) - Date/time text representation.
*Outputs*: DateTime (DateTime) - Parsed timestamp object; Success (Boolean) - True if parsing succeeded.

Date Diff
*Description*: Calculates the elapsed duration between two DateTime points (A - B).
*Inputs*: A (DateTime) (DateTime), B (DateTime) (DateTime).
*Outputs*: Days (Double), Hours (Double), Minutes (Double), Seconds (Double), Milliseconds (Double).

Date Add
*Description*: Adds a specific numeric duration of a chosen interval (Days, Hours, etc.) to a DateTime value.
*Inputs*: DateTime (DateTime), Value (Integer) - Duration amount to add.
*Outputs*: Result (DateTime) - Adjusted timestamp.
*Settings*:
Interval: The time unit to add (e.g., Days, Hours, Minutes, Seconds).

Date Equal
*Description*: Compares two DateTime values for equality.
*Inputs*: A (DateTime) (DateTime), B (DateTime) (DateTime).
*Outputs*: Equal (Boolean) - True if both date/time values are equal.

---

`4.4.14 Bitwise`

Low-level masking and bit manipulation for PLC holding registers.

Explode
*Description*: Deconstructs a numeric value (e.g., a 16-bit register) into its individual boolean bit components.
*Inputs*: Value (Number) - The numeric value to explode.
*Outputs*: Bit 0, Bit 1... Bit 15 (Boolean) - The state of each individual bit.
*Settings*:
Bits: The number of bits to output (default is 16).

Pack
*Description*: Combines multiple separate boolean bit inputs into a single combined numeric value.
*Inputs*: Bit 0, Bit 1... Bit 15 (Boolean) - The state of each bit.
*Outputs*: Result (Number) - The packed numeric value.
*Settings*:
Bits: The number of bits to pack (default is 16).

Test
*Description*: Checks the boolean state of a specific bit index inside a numeric value.
*Inputs*: Value (Number) - The target number; Index (Integer) - The bit index to test.
*Outputs*: Bit State (Boolean) - True if the tested bit is high (1).

AND
*Description*: Performs a bitwise AND operation across two numeric inputs.
*Inputs*: Left (Number), Right (Number).
*Outputs*: Result (Number).

OR
*Description*: Performs a bitwise OR operation across two numeric inputs.
*Inputs*: Left (Number), Right (Number).
*Outputs*: Result (Number).

XOR
*Description*: Performs a bitwise exclusive-OR (XOR) operation across two numeric inputs.
*Inputs*: Left (Number), Right (Number).
*Outputs*: Result (Number).

NOT
*Description*: Performs a bitwise logical inversion (NOT) of a numeric input.
*Inputs*: Input (Number).
*Outputs*: Result (Number).

Shift Left
*Description*: Shifts the bits of a numeric value to the left by a specified number of positions.
*Inputs*: Left (Number) - The value to shift; Right (Number) - The number of positions to shift.
*Outputs*: Result (Number).

Shift Right
*Description*: Shifts the bits of a numeric value to the right by a specified number of positions.
*Inputs*: Left (Number) - The value to shift; Right (Number) - The number of positions to shift.
*Outputs*: Result (Number).

---

`4.4.15 Cryptography`

Security-focused nodes for data encryption and integrity verification.

AES
*Description*: Performs symmetric key encryption or decryption using the Advanced Encryption Standard (AES).
*Inputs*: Text (String) - Plaintext or ciphertext base64 string; Key (String) - Secret cipher key.
*Outputs*: Result (String) - Processed output payload.
*Settings*:
Mode: Action to perform (encrypt or decrypt).

RSA
*Description*: Performs asymmetric key encryption or decryption using the Rivest-Shamir-Adleman (RSA) algorithm.
*Inputs*: Text (String) - Plaintext or ciphertext base64 string; Key (String) - Public key (for encrypting) or Private key (for decrypting) in PEM format.
*Outputs*: Result (String) - Processed output payload.
*Settings*:
Mode: Action to perform (encrypt or decrypt).

SHA-2
*Description*: Computes the secure SHA-2 cryptographic hash value of a given string payload.
*Inputs*: Text (String) - Target text.
*Outputs*: Result (String) - Calculated hash value.
*Settings*:
Variant: The SHA-2 bit length variation to use (256, 384, or 512).

MD5
*Description*: Computes the MD5 checksum hash value of a given string payload (commonly used for checksum validations).
*Inputs*: Text (String) - Target text.
*Outputs*: Result (String) - Calculated MD5 hash value.

---

`4.4.16 Advanced Mathematical Functions`

Extended trigonometry, powers, and rounding.

Absolute Value | Input: Number | Output: Positive magnitude.

Square Root | Input: Number | Output: Root calculation.

Power / Exponent | Inputs: Base, Exponent | Output: Calculated power.

Logarithm | Inputs: Value, Base | Output: Log value.

Sine / Cosine / Tangent | Input: Angle (Radians) | Output: Trig ratio.

Floor / Ceiling | Input: Number | Output: Integer rounded down/up.

---

`4.4.17 Data Quality & Null Handling`

Defensive data checking and fallback assignments.

Is Null
*Inputs*: Input (Dynamic) | *Outputs*: IsNull (Boolean) - True if input value is null.

Coalesce
*Inputs*: Input A (Dynamic), Input B (Dynamic) | *Outputs*: Value (Dynamic) - Returns A if not null; otherwise returns B.

Random Number Generator
*Inputs*: Min (Number), Max (Number) | *Outputs*: Value (Number) - Random number within range.

---

`4.4.18 Tools`

File I/O and utility action nodes.

Read File
*Description*: Reads file content (as text or byte array) from a local disk or network file path.
*Inputs*: Path (String) - Local or network file path to read.
*Outputs*: Content (ByteArray/String) - The file payload read from disk; Success (Boolean) - True if the file read succeeded.
*Settings*:
Format: Data format emitted by the Content port (ByteArray or Text).

Data Converter
*Description*: Converts input values from a selected scalar datatype (Int, Double, Bool, String) to a target output scalar datatype, dynamically updating port colors in the rule editor canvas.
*Inputs*: In (Dynamic - matching selected Input Type).
*Outputs*: Out (Dynamic - matching selected Output Type).
*Settings*:
Input Type: Dropdown selecting input datatype (Int, Double, Bool, String).
Output Type: Dropdown selecting output datatype (Int, Double, Bool, String).
Default Value: Fallback value text used if conversion fails at runtime. Must be compatible with the selected Output Type, or the rule compiler emits a validation error.

---

`5. Source Adapters & Configuration Parameters`

Uniflow supports 21 distinct source adapter classifications (SourceType). Each adapter requires specific configuration parameters to successfully initialize network bindings, establish communication handshakes, and ingest field data.

┌────────────────────────────────────────────────────────┐

│ SOURCE ADAPTER CONFIG │

│ │

│ Type: [ Modbus TCP Client ▼ ] │

│ Host: [ 192.168.1.50 ] Port: [ 502 ] │

│ UnitId: [ 1 ] │

│ │

│ [Advanced Socket Tuning] │

│ Connect Timeout (ms): [ 3000 ] │

│ Reconnect Backoff (ms):[ 5000 ] │

└────────────────────────────────────────────────────────┘

`5.1 Built-In System Sources`

In addition to external network source adapters, Uniflow features two foundational built-in sources available to trigger rule execution:

System Timer
A built-in interval clock that generates periodic execution impulses at a configured frequency (governed by the system setting HeartbeatIntervalMs, defaulting to 100ms / 10 Hz). It is deployed to drive scheduled workflows, watchdog heartbeats, or periodic polling tasks.

Internal Storage
A built-in source linked directly to Uniflow's internal memory registry. Whenever a targeted storage variable changes state, it instantly awakens bound rule graphs, allowing engineers to chain multi-stage calculation pipelines seamlessly.

---

`5.2 Sources "Data Points"`

For source adapters that sample multi-variable data tables (such as Modbus registers, OPC UA nodes, SNMP OIDs, BACnet objects, or HTTP REST targets), data mapping is handled via Data Points.

│ CONFIGURING ADAPTER POINTS [ + Add Point] │

│ ID/Name │ Address / NodeId / OID │ Data Type │ Access / Unit │

│ BoilerTemp │ 40001 │ Float32 │ ReadWrite / °C │

What is a Data Point? A Data Point defines a specific, addressable memory register or data variable within an external field device or service.

How are they used? Depending on the underlying protocol architecture, Uniflow either continuously polls these data points at the adapter's configured interval (e.g., Modbus holding registers, SNMP OIDs) or establishes active, asynchronous data subscriptions that push value changes in real time (e.g., OPC UA monitored items). Incoming byte streams and published frames are automatically unpacked, converted into strongly typed runtime values (Integers, Doubles, Booleans, Strings), and cached in memory for immediate evaluation by visual rule graphs.

How are they added? When editing a source adapter, navigate to the Points Table at the bottom of the configuration panel. Click Add Point (+) and configure the following properties:
Point ID / Name (String): A friendly identifier used to reference this variable inside Rule Graphs (e.g., Room101_Temp).
Address / Register (String): The exact protocol address (e.g., Modbus holding register 40001, OPC UA ns=2;s=Temp, SNMP .1.3.6.1.2.1.1.3.0).
Data Type (Dropdown): Expected structural conversion format (e.g., Int16, UInt32, Float32, Boolean).
Access (Dropdown): Configures operational read/write permissions (ReadOnly, ReadWrite).

---

`5.3 Internal & System Classifications`

`5.3.1 System Timer`

NOTE

Scope & Common Use Case
Deployed as an internal execution clock. Commonly used in automated facilities to trigger scheduled maintenance scripts, poll web endpoints at precise intervals, or heartbeat system storage points.

PollIntervalMs (Integer | [Required] | Default: 1000): The precise time interval in milliseconds between execution pulse ticks.

Rule Graph Node Interface:
InputSource: Trigger (Boolean) - Periodic clock pulse trigger.
DataSource: Not supported.
EventInput: Not supported.
WriteValue: Not supported.

`5.3.2 Internal Storage`

NOTE

Scope & Common Use Case
Used to chain complex workflows. Commonly deployed when Rule A calculates an industrial KPI and writes it to memory, instantly triggering Rule B to evaluate threshold alarms against that new KPI value.

PointId (String | [Required] | Default: ""): The exact storage tag identifier or memory address key to monitor.

Rule Graph Node Interface:
InputSource: Value (Any) - Fires execution on any memory variable changes, emitting the new state.
DataSource: Value (Any) - Returns the current cached memory state on demand.
EventInput: Not supported.
WriteValue: Value (Any) - Updates the internal memory register with the incoming target value.

---

`5.4 Industrial Automation Protocols`

`5.4.1 Modbus TCP Client`

NOTE

Scope & Common Use Case
The foundational workhorse of industrial automation. Commonly deployed in water treatment facilities, manufacturing assembly lines, and power substations to continuously poll holding registers from programmable logic controllers (PLCs), variable frequency drives (VFDs), and remote IO modules.

Host (String | [Required] | Default: ""): IP address or resolvable hostname of the Modbus slave device.

Port (Integer | [Required] | Default: 502): TCP listening port of the target slave.

UnitId (Integer | [Required] | Default: 1): Modbus station identifier (1 to 247) addressing the specific device on a gateway.

ConnectTimeoutMs (Integer | [Advanced] | Default: 3000): Maximum time allowed in milliseconds to complete the initial TCP connection handshake.

PollIntervalMs (Integer | [Required] | Default: 1000): Sampling frequency defining how often register frames are requested.

ReconnectIntervalMs (Integer | [Advanced] | Default: 5000): Delay period before attempting socket re-establishment following a dropped connection.

HealthCheckIntervalMs (Integer | [Advanced] | Default: 5000): Background verification frequency testing socket viability.

Points (Data Points Table | [Required]): Configured memory register mappings specifying memory table (*DiscreteInputs*, *Coils*, *InputRegisters*, *HoldingRegisters*), starting 16-bit register offset, data type conversion, and bitwise slice masks.

Rule Graph Node Interface:
InputSource: PointName (Boolean/Integer/Double) - Live value stream of register points (triggers graph evaluation on change).
DataSource: PointName (Boolean/Integer/Double) - Current polled register value.
EventInput: Not supported.
WriteValue: Value (Boolean/Integer/Double) - Writes new payload directly to target write-enabled registers/coils.

`5.4.2 Modbus Server`

NOTE

Scope & Common Use Case
Acts as a virtual PLC. Commonly deployed in supervisory control and data acquisition (SCADA) networks where external master controllers need to write operational setpoints directly into Uniflow's internal storage registers.

Port (Integer | [Required] | Default: 502): TCP port bound to local network interfaces (0.0.0.0).

UnitId (Integer | [Required] | Default: 1): Local station identifier assigned to the Uniflow slave instance.

Points (Data Points Table | [Required]): Configured memory register mappings specifying memory table (*DiscreteInputs*, *Coils*, *InputRegisters*, *HoldingRegisters*), starting 16-bit register offset, data type conversion, and bitwise slice masks.

Rule Graph Node Interface:
InputSource: PointName (Boolean/Integer/Double) - Live value stream of local server registers (fires on external write actions).
DataSource: PointName (Boolean/Integer/Double) - Current cached register state.
EventInput: Not supported.
WriteValue: Value (Boolean/Integer/Double) - Local manual update of target register cache.

`5.4.3 OPC UA Client`

NOTE

Scope & Common Use Case
Modern, secure industrial connectivity. Commonly deployed in enterprise Industry 4.0 architectures to communicate with Siemens S7-1500, Allen-Bradley ControlLogix, and Beckhoff PLCs using encrypted binary streams and structured node hierarchies.

EndpointUrl (String | [Required] | Default: ""): Complete endpoint URI (e.g., opc.tcp://192.168.1.100:4840).

SecurityMode (String | [Required] | Default: "None"): Cryptographic mode (*None*, *Sign*, *SignAndEncrypt*).

SecurityPolicy (String | [Required] | Default: "None"): Security suite algorithm (*None*, *Basic256Sha256*, *Aes128_Sha256_RsaOaep*).

AuthMode (String | [Required] | Default: "Anonymous"): Authentication verification mode (*Anonymous*, *UsernamePassword*, *Certificate*).

Username / Password (String | [Optional] | Default: ""): User security credentials if UsernamePassword is active.

ConnectTimeoutMs (Integer | [Advanced] | Default: 5000): Maximum handshake duration.

PollIntervalMs (Integer | [Required] | Default: 1000): Data sampling subscription interval.

ReconnectIntervalMs (Integer | [Advanced] | Default: 5000): Socket recovery delay interval.

HealthCheckIntervalMs (Integer | [Advanced] | Default: 5000): Keep-alive sampling interval.

RootNodeId (String | [Advanced] | Default: "i=84"): Starting root node identifier for hierarchical browsing (*ObjectsFolder*).

AutoBrowse (Boolean | [Advanced] | Default: true): Toggles automatic structural traversal of the server's node tree.

AutoAcceptServerCertificate (Boolean | [Advanced] | Default: true): Automatically trusts and accepts unverified or self-signed server certificates.

SelectedNodes / SelectedNodeIds (Text List | [Required]): Explicit collection of target NodeId strings to sample.

Rule Graph Node Interface:
InputSource: PointName (Any) - Live value stream of subscribed Monitored Items.
DataSource: PointName (Any) - Reads current node state on demand.
EventInput: Not supported.
WriteValue: Value (Any) - Writes payload directly to target write-enabled OPC UA nodes.

NamespaceIndexesFilter (Number List | [Optional]): Comma-separated namespace index IDs used to filter large node catalogs during discovery.

TIP

OPC UA Node Browser Utility
To simplify node discovery, clicking the Browse Nodes button beside the selection table launches the OPC UA Node Selection Dialog. This interactive utility connects directly to the server using your current draft settings, issues a catalog discovery command (

BrowseSourceCatalog

), filters out internal connection metadata, and presents all discovered value nodes as a searchable list of selectable checkboxes. Engineers can filter by name or ID, check target rows, and click "Add Selected" to automatically import them and their metadata into the adapter's monitoring table without manual typing.

`5.4.4 OPC UA Server`

NOTE

Scope & Common Use Case
Enterprise data publishing. Commonly deployed to expose Uniflow's aggregated telemetry cache to enterprise ERP systems, cloud historians, or external third-party SCADA dashboards.

BindingIp (String | [Required] | Default: "0.0.0.0"): Local network interface binding address.

Port (Integer | [Required] | Default: 4840): TCP listening port.

AuthAnonymous (Boolean | [Required] | Default: true): Permits unauthenticated client connections.

AuthUsername (Boolean | [Required] | Default: false): Requires incoming clients to provide valid credentials.

AuthCertificate (Boolean | [Required] | Default: false): Requires incoming clients to present valid X509 client certificates.

AuthorizedUsers (String | [Optional] | Default: ""): Comma-separated list of permitted username strings.

AutoGenerateCert (Boolean | [Advanced] | Default: true): Generates a local self-signed X509 certificate automatically if none exists.

CertificatePath (String | [Optional] | Default: ""): File path pointing to a custom X509 certificate store.

Points (Data Points Table | [Required]): Published OPC UA nodes mapped directly to Uniflow storage registers.

Rule Graph Node Interface:
InputSource: PointName (Any) - Fires when external OPC UA clients write values to published nodes.
DataSource: PointName (Any) - Returns the current published server variable cache.
EventInput: Not supported.
WriteValue: Value (Any) - Locally updates the node value exposed to connecting clients.

`5.4.5 CAN Bus`

NOTE

Scope & Common Use Case
Automotive and heavy machinery monitoring. Commonly deployed in fleet management hubs, diesel generator enclosures, and mobile robotics to ingest engine diagnostic frames, battery management system (BMS) telemetry, and OBD2 parameters.

AdapterType (Enum | [Required] | Default: PcanUsb): Hardware adapter classification (*PcanUsb*, *Elm327*, *Slcan*, *SocketCan*, *TcpBridge*, *Virtual*).

DeviceHandle (String | [Required] | Default: "PCAN_USBBUS1"): Hardware channel handle string or COM port identifier (e.g., "COM5").

BitrateKbps (Integer | [Required] | Default: 500): Communication bus transmission speed in kilobits per second.

BitrateAutoDetect (Boolean | [Optional] | Default: false): Automatically attempts baud rate negotiation.

PollIntervalMs (Integer | [Required] | Default: 250): Polling frequency requesting active diagnostic PIDs.

ResponseTimeoutMs (Integer | [Advanced] | Default: 500): Maximum time allowed waiting for a frame response.
ReconnectIntervalMs (Integer | [Advanced] | Default: 3000): Recovery delay following adapter disconnect.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Decodes signals dynamically using custom or built-in DBC message templates:
Trigger (Boolean) - Pulse fired on frame reception.
id (Integer) - The physical CAN frame identifier.
SignalName (Double) - Calculated signal values extracted via DBC definitions.
rawFrame (String) - Hexadecimal-encoded byte payload string.
WriteValue: Value (String/JSON) - Encodes and writes physical CAN frames to the bus. Accepts a JSON payload string containing field-value pairs that target a writable message defined in the catalog (e.g., raw CAN frames or writable OBD2 parameters).

TIP

Custom DBC Signal Ingestion
While Uniflow loads a built-in default message catalog out-of-the-box, system integrators can drop a custom Vector DBC (

.dbc) file directly into the runtime's local Data/

 folder (or specify its path within the raw JSON adapter configuration). Uniflow automatically reads the custom DBC file, parsing all frame definitions, engineering units, scaling factors, and signal bitmasks. These parsed CAN signals are dynamically broadcasted and exposed as selectable custom event fields within the Event Input node in the visual rule graph, allowing seamless drag-and-drop automation against proprietary automotive and heavy machinery telemetry.

---

`5.5 IoT, Networking, and IT Management Protocols`

`5.5.1 MQTT Client`

NOTE

Scope & Common Use Case
Lightweight IoT messaging. Commonly deployed in smart city grids, environmental monitoring networks, and remote agricultural sites to subscribe to low-bandwidth telemetry streams published by field sensors over cellular networks.

BrokerHost (String | [Required] | Default: "localhost"): Hostname or IP address of the target MQTT Broker.

Port (Integer | [Required] | Default: 1883): TCP connection port (1883 for plain / 8883 for TLS).

UseTls (Boolean | [Required] | Default: false): Toggles SSL/TLS encrypted communication.

AuthMode (Enum | [Required] | Default: Anonymous): Security authorization mode (*Anonymous*, *UsernamePassword*, *X509Certificate*).

Username / Password (String | [Optional] | Default: ""): Broker authentication credentials.

ClientCertPath / ClientCertPassword (String | [Optional] | Default: ""): Local path and passphrase for client X509 certificates.

ClientId (String | [Optional] | Default: ""): Unique string identifying the Uniflow client instance.

CleanSession (Boolean | [Advanced] | Default: true): Instructs broker to purge or preserve queued subscriptions across disconnects.

KeepAliveSeconds (Integer | [Advanced] | Default: 60): Ping interval maintaining active connection state.

ConnectTimeoutMs (Integer | [Advanced] | Default: 5000): Handshake connection timeout.

ReconnectIntervalMs (Integer | [Advanced] | Default: 5000): Reconnection backoff interval.

Topics (Topics Table | [Required]): Subscribed topic string filters paired with exact Quality of Service levels (QoS 0, 1, 2).

Rule Graph Node Interface:
InputSource: PointName (String/Double/Boolean) - Emits latest parsed topic payload values mapped as points.
DataSource: PointName (String/Double/Boolean) - Returns the last cached state of subscribed topic values.
EventInput: Emits raw subscription alerts on incoming broker messages:
Trigger (Boolean) - Message received pulse.
Topic (String) - Target channel topic string.
Payload (String) - Unparsed raw payload string.
QoS (Integer) - Message transmission Quality of Service level.
WriteValue: Value (String) - Publishes payload data back to the configured target topic.

`5.5.2 SNMP Walker`

NOTE

Scope & Common Use Case
IT and data center infrastructure monitoring. Commonly deployed in network operations centers (NOCs) to actively poll core routers, managed network switches, rack UPS units, and server cooling arrays for bandwidth utilization and hardware temperature metrics.

HostOrUrl (String | [Required] | Default: "127.0.0.1"): Target SNMP agent IP address.

Port (Integer | [Required] | Default: 161): UDP connection port.

Version (Enum | [Required] | Default: v2c): Supported SNMP protocol version (*v1*, *v2c*, *v3*).

ReadCommunity (String | [Required] | Default: "public"): SNMP community string for incoming read operations.

WriteCommunity (String | [Required] | Default: "private"): SNMP community string for write actions.

Username / ContextName (String | [Optional] | Default: ""): SNMPv3 user authentication security context.

AuthProtocol (Enum | [Optional] | Default: None): SNMPv3 authentication cryptographic hashing (*None*, *MD5*, *SHA1*, *SHA256*, *SHA384*, *SHA512*).

AuthPassword (String | [Optional] | Default: ""): SNMPv3 authentication passphrase.

PrivProtocol (Enum | [Optional] | Default: None): SNMPv3 privacy payload encryption (*None*, *DES*, *AES128*, *AES192*, *AES256*).

PrivPassword (String | [Optional] | Default: ""): SNMPv3 privacy decryption key.

PollIntervalMs (Integer | [Required] | Default: 1000): Active polling execution frequency.

RetryIntervalMs (Integer | [Advanced] | Default: 1000): Delay before re-requesting a dropped UDP poll frame.

TimeoutMs (Integer | [Advanced] | Default: 3000): Network response timeout.

SelectedPoints (Data Points Table | [Required]): Target Object Identifiers (OIDs) to poll (e.g., .1.3.6.1.2.1.1.3.0).

Rule Graph Node Interface:
InputSource: PointName (String/Integer/Double) - Live value stream of polled OID variables.
DataSource: PointName (String/Integer/Double) - Returns the latest polled OID state.
EventInput: Not supported.
WriteValue: Value (String/Integer/Double) - Issues outbound SNMP SET requests to write-enabled target OIDs.

TIP

SNMP OID Selection Utility & Custom MIB Translation
To simplify OID identification, clicking the Browse button launches the SNMP OID Selection Dialog. This interactive browser connects to the target agent using your configured community strings, walking available MIB tables. Discovered OID paths and descriptive names are rendered as a searchable list of selectable checkboxes. Engineers can instantly filter points, check target rows, and click "Add Selected" to automatically populate the adapter's persistent polling collection. Additionally, system integrators can define custom OID translations by populating the

Data/oids.csv file (format: OID,FriendlyName

) in the runtime directory. Uniflow automatically loads these mappings at startup to translate cryptic numerical OIDs into human-readable sensor names during discovery and polling.

`5.5.3 SNMP Agent`

NOTE

Scope & Common Use Case
Integrates Uniflow into corporate IT dashboards. Commonly deployed so that enterprise network monitoring tools (SolarWinds, PRTG, Nagios) can poll Uniflow's internal status, or receive immediate SNMP Trap alerts when critical rules fire.

Port (Integer | [Required] | Default: 161): Bound UDP port (161 for polling responses, 162 for incoming Traps).

Version (Enum | [Required] | Default: v2c): SNMP operating protocol.

ReadCommunity / WriteCommunity (String | [Required] | Default: ""): Incoming community verification strings.

Username / AuthProtocol / PrivProtocol: SNMPv3 security engine configuration.

Points (Data Points Table | [Required]): Published OIDs bound directly to internal memory storage points.

TrapDestinations (Destinations Table | [Optional]): External destination IP addresses where Uniflow dispatches outbound SNMP Trap alerts.

Rule Graph Node Interface:
InputSource: PointName (String/Integer/Double) - Fires when external SNMP clients write payload data to local agent OIDs.
DataSource: PointName (String/Integer/Double) - Returns local agent cached OID variables.
EventInput: Not supported.
WriteValue: Value (String/Integer/Double) - Manually updates local agent OID cache (which can be polled externally or trigger automatic SNMP Traps).

SNMP v3 Security Guide (USM)

SNMP v3 introduces the User-based Security Model (USM), providing authentication and encryption to protect management traffic. Unlike v1 and v2c, which rely on plain-text community strings, v3 uses cryptographic protocols and user accounts.

Core Security Fields

Field	Description
Username	The security name of the user (e.g., v3admin`). Both the client and agent must match this.`
Context Name	(Optional) Identifies a specific collection of management information. Usually left blank.
Auth Protocol	The algorithm for identity verification and message integrity.
Auth Password	The secret key for the authentication protocol.
Priv Protocol	The algorithm for data encryption (Privacy).
Priv Password	The secret key for the encryption protocol.

Supported Protocols in Uniflow
Authentication: MD5, SHA1, SHA256, SHA384, SHA512
Privacy (Encryption): DES, AES128, AES192, AES256

`Security Levels`

SNMP v3 defines three levels of security based on the provided credentials:

noAuthNoPriv:
Uses only the Username.
No authentication, no encryption.
*Security: Low (v1/v2 style)*.
authNoPriv:
Requires Username + Auth Protocol + Auth Password.
Communication is authenticated but readable in clear text.
*Security: Medium*.
authPriv:
Requires Username + Auth (Proto/Pass) + Priv (Proto/Pass).
Communication is both authenticated and encrypted.
*Security: High (Recommended)*.

`Testing Setup in Uniflow`

To verify your v3 implementation, you can set up a local loopback test.

`Step A: Configure the SNMP Agent (Server)`

Add an SNMP Agent source.
Set Version** to V3.
Configure USM Credentials**:
Username: testuser
Auth Proto: SHA256 / Auth Pass: password123
Priv Proto: AES128 / Priv Pass: encryption123
**Start the source and check logs for started on udp/161 using V3.

`Step B: Configure the SNMP Walker (Client)`

Add an SNMP Walker source.
Set Host to 127.0.0.1 and Version** to V3.
Enter the EXACT same** credentials used in the Agent.
Click Browse OIDs...** to trigger a discovery walk.

`Troubleshooting`

Authentication Failure: Check if the Auth Password or Protocol (e.g., SHA256 vs SHA1) matches on both ends.
Decryption Error: If authentication succeeds but data cannot be read, verify the Privacy Password and Protocol (e.g., AES128).
EngineID: While Uniflow handles EngineID discovery automatically, some legacy hardware may require manual configuration if they don't support the standard discovery probe.
Timeout: If you get a timeout immediately on a v3 request, it might be due to an invalid username that the agent is silently ignoring.

`5.5.4 HTTP Client`

NOTE

Scope & Common Use Case
Cloud and web API integration. Commonly deployed to poll external weather services, financial ticker REST APIs, or enterprise webhooks to fetch JSON metadata and inject it into local automation graphs.

HostOrUrl (String | [Required] | Default: ""): Base target URL.

pollIntervalMs (Integer | [Required] | Default: 5000): Execution frequency defining how often REST routes are polled.

connectTimeoutMs (Integer | [Advanced] | Default: 5000): Maximum time allowed for socket handshakes.

reconnectIntervalMs (Integer | [Advanced] | Default: 5000): Retry interval following communication failures.

healthCheckIntervalMs (Integer | [Advanced] | Default: 5000): Background endpoint viability polling rate.

authMethod (Enum | [Required] | Default: None): Authorization strategy (*None*, *Basic*, *BearerToken*, *ApiKey*).

username / password (String | [Optional] | Default: ""): Credentials if Basic auth is selected.

authToken (String | [Optional] | Default: ""): Cryptographic bearer token string.

apiKeyHeader / apiKeyValue (String | [Optional] | Default: ""): Header key name and matching value for ApiKey auth.

customHeaders (String | [Optional] | Default: ""): JSON formatted key-value map defining custom HTTP headers.

points (Data Points Table | [Required]): Specific REST routes and HTTP verbs (*GET*, *POST*, *PUT*) to poll.

Rule Graph Node Interface:
InputSource: PointName (String) - Live string or parsed JSON response payloads from GET/POST polled endpoints.
DataSource: PointName (String) - Returns the latest polled response payload.
EventInput: Not supported.
WriteValue: Value (String) - Transmits outbound POST/PUT requests with custom payload strings to target REST endpoints.

`5.5.5 TCP Echo`

NOTE

Scope & Common Use Case
Diagnostic networking utility. Commonly deployed during system commissioning to verify firewall configurations, test socket bandwidth limits, and confirm raw TCP stream reachability.

HostOrUrl (String | [Required] | Default: "127.0.0.1"): Target IP address or hostname.

Port (Integer | [Required] | Default: 1234): Target TCP port.

ConnectTimeoutMs (Integer | [Advanced] | Default: 3000): Connection handshake timeout.

ReconnectIntervalMs (Integer | [Advanced] | Default: 5000): Socket recovery delay interval.

Rule Graph Node Interface:
InputSource: Status (Boolean) - Emits socket connection viability state.
DataSource: Not supported.
EventInput: Not supported.
WriteValue: Value (String) - Transmits raw characters/bytes over the active socket connection.

`5.5.6 Serial Port`

NOTE

Scope & Common Use Case
Direct physical COM connectivity. Commonly deployed in legacy manufacturing plants, access control turnstiles, and weighing scale stations to ingest raw ASCII strings or binary frames directly from serial RS-232 / RS-485 interfaces.

PortName (String | [Required] | Default: "COM1"): Hardware COM identifier (e.g., "COM3", "/dev/ttyUSB0").

BaudRate (Integer | [Required] | Default: 9600): Transmission speed (e.g., 9600, 115200).

DataBits (Integer | [Required] | Default: 8): Frame character length.

Parity (Enum | [Required] | Default: None): Error checking parity (*None*, *Odd*, *Even*, *Mark*, *Space*).

StopBits (Enum | [Required] | Default: One): Frame termination delimiter (*None*, *One*, *Two*, *OnePointFive*).

Handshake (Enum | [Advanced] | Default: None): Flow control protocol (*None*, *XOnXOff*, *RequestToSend*, *RequestToSendXOnXOff*).

RtsEnable (Boolean | [Advanced] | Default: false): Toggles Request to Send (RTS) hardware signal.

DtrEnable (Boolean | [Advanced] | Default: false): Toggles Data Terminal Ready (DTR) hardware signal.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Fires when COM port receives data (buffered until newline or termination character):
Trigger (Boolean) - Signal pulse.
Frame (String) - Complete received ASCII data.
Length (Integer) - Total character length.
WriteValue: Value (String) - Writes string directly to the physical serial tx register.

`5.5.7 Email Client`

NOTE

Scope & Common Use Case
Legacy system and notification integration. Commonly deployed to monitor dedicated support or alarm inboxes, ingesting incoming email alerts as structured data, or automatically dispatching SMTP notification reports when critical rule thresholds are breached.

Host (String | [Required] | Default: ""): Inbound server hostname (e.g., imap.gmail.com).
Port (Integer | [Required] | Default: 993): Inbound connection port.
Protocol (Enum | [Required] | Default: IMAP): Communication protocol (*IMAP*, *POP3*).
Encryption (Enum | [Required] | Default: Auto): Connection security mode (*None*, *Ssl*, *Tls*, *Auto*).
Username / Password (String | [Required] | Default: ""): Authentication credentials.
SmtpHost (String | [Optional] | Default: ""): Outbound SMTP server hostname.
SmtpPort (Integer | [Optional] | Default: 587): SMTP port.
SmtpEncryption (Enum | [Optional] | Default: Auto): SMTP security mode.
PollInterval (Integer | [Required] | Default: 60000): Frequency defining how often the inbox is checked for new messages.
DeleteAfterRead (Boolean | [Optional] | Default: false): Automatically purges emails from the server after successful ingestion.
SkipCertificateValidation (Boolean | [Advanced] | Default: false): Bypasses SSL/TLS certificate chain verification.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Fires when a new message is successfully fetched from target inbox:
Trigger (Boolean) - New mail arrival pulse.
From (String) - Sender email address.
Subject (String) - Mail header subject.
Body (String) - Extracted plaintext body string.
ReceivedTime (String) - Message receipt timestamp.
WriteValue: Sends outbound emails via SMTP server. Exposes inputs:
To (String) - Recipient email.
Subject (String) - Header title.
Body (String) - Outgoing body content.

`5.5.8 WebHook`

NOTE

Scope & Common Use Case
External event ingestion and SCADA integration. Commonly deployed as a high-performance REST endpoint that "listens" for incoming HTTP requests (GET, POST, PUT, DELETE) from external SCADA servers, IoT gateways, or third-party web services to trigger real-time automation logic.

Port (Integer | [Required] | Default: 8080): Local TCP port where the WebHook server listens for incoming connections.
ApiKey (String | [Optional] | Default: ""): Security key required in the X-API-Key HTTP header to authorize incoming requests.
EnableSsl (Boolean | [Optional] | Default: false): Toggles HTTPS secure communication.
CertPath (String | [Optional] | Default: ""): File path to the PFX certificate used for SSL/TLS.
CertPassword (String | [Optional] | Default: ""): Password for the PFX certificate.
AllowedIps (String | [Optional] | Default: ""): Semicolon-separated list of permitted source IP addresses (e.g., 192.168.1.10; 10.0.0.5). If empty, all IPs are allowed.
Points (Endpoints Table | [Required]): User-defined API routes. Each point specifies an HTTP Method (GET, POST, etc.) and a Relative Path (e.g., /api/v1/alarm). Incoming payloads are automatically converted to JSON strings and published as data points.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Fires when an external caller triggers a registered REST endpoint route:
Trigger (Boolean) - Pulse on HTTP request receipt.
Method (String) - Incoming HTTP verb (GET, POST, etc.).
Path (String) - Relative API target path.
Payload (String) - Raw request body payload.
ClientIP (String) - Caller's remote source IP.
WriteValue: Not supported.

---

`5.6 Building Management & Physical Security Protocols`

`5.6.1 BACnet Walker`

NOTE

Scope & Common Use Case
Building automation integration. Commonly deployed across commercial real estate, hospital campuses, and university facilities to discover and poll HVAC chillers, lighting control panels, and air handling units (AHUs) via BACnet/IP.

HostOrUrl (String | [Required] | Default: "0.0.0.0"): Local network interface or broadcast IP.

RemotePort (Integer | [Required] | Default: 47808): Remote target UDP destination port.

DeviceId (Integer | [Required] | Default: 1): Target BACnet device instance number.

PollIntervalMs (Integer | [Required] | Default: 1000): Sampling frequency.

EnableBbmd (Boolean | [Optional] | Default: false): Toggles BACnet Broadcast Management Device (BBMD) routing across subnets.

BbmdIpAddress (String | [Optional] | Default: ""): IP address of the BBMD router.

BbmdPort (Integer | [Optional] | Default: 47808): BBMD communication port.

BbmdTtl (Integer | [Advanced] | Default: 1800): Foreign device registration renewal interval in seconds.

SelectedPoints (Data Points Table | [Required]): Configured BACnet objects specifying Object Type (*AnalogInput*, *BinaryOutput*) and Instance IDs.

Rule Graph Node Interface:
InputSource: PointName (Any) - Live value stream of polled BACnet objects (Analog Input, Binary Output, etc.).
DataSource: PointName (Any) - Returns current polled BACnet object state.
EventInput: Not supported.
WriteValue: Value (Any) - Writes payload directly to target write-enabled BACnet objects.

TIP

BACnet Object Selection Utility
To eliminate manual instance number entry, clicking the Browse button launches the BACnet Node Selection Dialog. This explorer broadcasts discovery frames across the network (or through configured BBMD routers) to discover active BACnet objects. Available Analog Inputs, Binary Outputs, and Multi-State Values are presented as a searchable list of selectable checkboxes. Checking target objects and clicking "Add Selected" instantly parses their type and instance identifiers and imports them into the monitoring table.

`5.6.2 BACnet Agent`

NOTE

Scope & Common Use Case
Virtual building device simulation. Commonly deployed to allow central Building Management Systems (BMS) like Tridium Niagara or Desigo CC to read Uniflow's aggregated industrial metrics exactly as if Uniflow were a standard hardware controller.

HostOrUrl (String | [Required] | Default: "0.0.0.0"): Binding interface IP.

Port (Integer | [Required] | Default: 47808): Listening UDP port.

DeviceId (Integer | [Required] | Default: 12345): Virtual device instance number allocated to Uniflow.

DeviceName (String | [Required] | Default: "Uniflow_BACnet"): Friendly device name broadcasted during discovery.

Description (String | [Optional] | Default: ""): Contextual system documentation string.

EnableBbmd (Boolean | [Optional] | Default: false): Toggles BACnet Broadcast Management Device (BBMD) routing across subnets.

BbmdIpAddress (String | [Optional] | Default: ""): IP address of the BBMD router.

BbmdPort (Integer | [Optional] | Default: 47808): BBMD communication port.

BbmdTtl (Integer | [Advanced] | Default: 1800): Foreign device registration renewal interval in seconds.

SelectedPoints (Data Points Table | [Required]): Published BACnet objects bound directly to Uniflow storage points.

Rule Graph Node Interface:
InputSource: PointName (Any) - Fires on external BMS client writes to published virtual objects.
DataSource: PointName (Any) - Returns current state of published virtual BACnet variables.
EventInput: Not supported.
WriteValue: Value (Any) - Updates local variable state published to external BACnet clients.

`5.6.3 Avigilon Web Endpoint`

NOTE

Scope & Common Use Case
Enterprise physical security integration. Commonly deployed in airport security centers, casino surveillance rooms, and corporate headquarters to connect with Avigilon Control Center (ACC) servers, ingesting real-time camera motion alarms, facial recognition alerts, and door access events.

BaseUrl (String | [Required] | Default: ""): Base URL of the Avigilon Web Gateway API.

Username / Password (String | [Required] | Default: ""): Integration credentials.

ClientName (String | [Required] | Default: "Uniflow"): Integration client identifier string.

SiteName (String | [Optional] | Default: ""): Target ACC site name.

UserNonce / UserKey (String | [Advanced] | Default: ""): Cryptographic tokens maintaining persistent session state.

ConnectTimeoutMs (Integer | [Advanced] | Default: 5000): API handshake timeout.

ReconnectIntervalMs (Integer | [Advanced] | Default: 5000): API recovery interval.

EnableSitesPolling / EnableServersPolling / EnableCamerasPolling / EnableAlarmsPolling / EnableEventsPolling (Boolean | [Required]): Individual toggles enabling specific entity tracking.

SitesPollIntervalMs (Integer | [Required] | Default: 60000): Site status polling frequency.

ServersPollIntervalMs (Integer | [Required] | Default: 60000): Server health polling frequency.

CamerasPollIntervalMs (Integer | [Required] | Default: 5000): Camera state polling frequency.

AlarmsPollIntervalMs (Integer | [Required] | Default: 5000): Alarm queue polling frequency.

EventsPollIntervalMs (Integer | [Required] | Default: 10000): Event stream polling frequency.

UseSocketIo (Boolean | [Optional] | Default: false): Toggles real-time WebSocket/Socket.IO alarm streaming.

SocketIoAutoReconnect (Boolean | [Advanced] | Default: true): Automatically recovers dropped Socket.IO connections.

SocketIoReconnectDelayMs (Integer | [Advanced] | Default: 3000): Reconnect delay.

SocketIoTopicsCsv (String | [Advanced] | Default: "HELLO,HEARTBEAT,ALARM_OBJECTS,CAMERA_OBJECTS,SERVER_OBJECTS,SITE,END_OF_CATALOG,EVENT"): Subscribed Socket.IO event topics.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Dispatches real-time security events based on event subscription classification:
Digital Input Events: cameraIds (StringArray), entityIds (StringArray), accessControlType (String)
Motion / Camera State Events: cameraId (String), cameraIds (StringArray), entityIds (StringArray), rebootReason (Int)
License Plate Recognitions (LPR): cameraId (String), detectedPlate (String), confidence (Double)
Face Recognition Match: cameraId (String), faceId (String), description (String), matchSimilarity (Double)
Active Alarm Events: alarmId (String), alarmName (String), triggerType (String), triggerUserName (String)
Access Control Door Events: accessControlType (String), doorName (String), cardHolderName (String)
WriteValue: Value (String/JSON) - Triggers, acknowledges, claims, unclaims, or purges active alarms in the Avigilon Control Center. In the rule editor, targeting the special endpoint avigilon:alarm exposes structured input fields/ports:
AlarmId (String | [Required]): The target alarm identifier.
Notes (String | [Required]): Contextual alarm log or commentary.
Action (String | [Required]): The alarm state transition (allowed values: TRIGGER, ACKNOWLEDGE, CLAIM, UNCLAIM, PURGE).

TIP

VMS Catalog Helper Window
Clicking the Helper Button (

?) in the Avigilon configuration header launches the Source Helper Window. This utility issues background IPC commands (BrowseSourceCatalog and ReadSource

) to query fetched entity collections from the ACC server, such as Alarms, Cameras, Servers, and Sites. System integrators can browse items, search names, and copy raw JSON payloads to understand the exact structure of incoming VMS alarms and events.

`5.6.4 Milestone XProtect Web Endpoint`

NOTE

Scope & Common Use Case
Video Management System (VMS) integration. Commonly deployed across global retail chains and municipal surveillance hubs to connect with Milestone XProtect Event Servers, streaming live camera disconnect faults and intrusion analytics directly into Uniflow rule graphs.

BaseUrl (String | [Required] | Default: ""): URL of the Milestone server.

Username / Password (String | [Required] | Default: ""): Integration login credentials.

UseSsl (Boolean | [Required] | Default: true): Toggles HTTPS secure communication.

IgnoreSslErrors (Boolean | [Advanced] | Default: false): Bypasses invalid SSL certificate warnings.

ConnectTimeoutMs (Integer | [Advanced] | Default: 15000): Connection timeout.

ReconnectIntervalMs (Integer | [Advanced] | Default: 15000): Reconnect interval.

EnableCamerasPolling / EnableAlarmsPolling / EnableSystemConfigPolling (Boolean | [Required]): Toggles for entity polling.

CamerasPollIntervalMs (Integer | [Required] | Default: 30000): Cameras sampling rate.

AlarmsPollIntervalMs (Integer | [Required] | Default: 30000): Alarms sampling rate.

SystemConfigPollIntervalMs (Integer | [Required] | Default: 600000): System topology refresh interval (10 minutes).

GetStatePollIntervalSec (Integer | [Advanced] | Default: 60): State refresh frequency in seconds.

UseWebSockets (Boolean | [Optional] | Default: true): Toggles real-time WebSocket event streaming.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Dispatches real-time security events based on subscription type:
Motion Events: id (String), type (String), timestamp (String), sourceId (String), sourceName (String), cameraId (String), cameraName (String)
Analytic Events: id (String), type (String), timestamp (String), sourceId (String), sourceName (String), message (String), metadataJson (String)
Alarm Events: id (String), type (String), timestamp (String), sourceId (String), sourceName (String), alarmId (String), alarmName (String), priority (Int)
WriteValue: Value (String/JSON) - Triggers alarms or system/analytic events in Milestone XProtect. In the rule editor, targeting the following endpoints exposes structured input fields/ports:
milestone:action (Trigger Alarm):
Name (String | [Required]): The name of the alarm to trigger.
Message (String | [Required]): Diagnostic description or alert message.
Source (String | [Required]): Camera or device GUID where the alarm is registered.
Priority (String | [Optional]): Optional alarm priority GUID.
Category (String | [Optional]): Optional alarm category GUID.
State (String | [Optional]): Optional alarm state GUID.
Tag (String | [Optional]): Optional classification tag.
milestone:event:trigger (Trigger Event):
Type (String | [Required]): Unique identifier (GUID) of the target system or analytic event.
Source (String | [Optional]): Unique identifier of the source device (e.g., camera GUID).
Datatype (String | [Optional] | Allowed: none, analytics, free-form): Payload categorization.
Tag (String | [Optional]): User classification tag.

TIP

VMS Catalog Helper Window
Clicking the Helper Button (

?) in the Milestone configuration header launches the Source Helper Window. This utility issues background IPC commands (BrowseSourceCatalog and ReadSource

) to query fetched entity collections from the XProtect Event Server, such as Alarms, Cameras, and System Configuration. System integrators can browse items, search names, and copy raw JSON payloads to understand the exact structure of incoming VMS alarms and events.

`5.6.5 Hexagon Lidar`

NOTE

Scope & Common Use Case
3D spatial surveillance and perimeter security. Commonly deployed along airport perimeters, critical border fences, and power station boundaries to ingest real-time point cloud tracking frames and zone intrusion alerts from 3D Lidar sensors.

HostOrUrl (String | [Required] | Default: "127.0.0.1"): Target IP address or hostname of the Hexagon Lidar unit.
Port (Integer | [Required] | Default: 50051): Target gRPC port.
Username / Password (String | [Optional] | Default: ""): Authentication credentials.
ReconnectIntervalMs (Integer | [Advanced] | Default: 5000): Connection recovery delay interval.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Dispatches spatial 3D tracking and zone alarms:
DetectedObject Events: id (Int), scene_placement.position (DoubleArray), scene_placement.rotation.vector (DoubleArray), scene_placement.rotation.rotation (Double), extent (DoubleArray), velocity (DoubleArray), activity (Double), points_count (Int), type (String), time (DateTime), zone_id (Int), detected_class_index (Int), ai_detected_class (String), loitering_time (String)
ZoneAlarm Events: id (Int), zone_id (Int)
WriteValue: Not supported.

`5.6.6 SIA Receiver`

NOTE

Scope & Common Use Case
Physical alarm panel ingestion. Commonly deployed in central monitoring stations to listen for incoming SIA DC-09 alarm frames dispatched over IP by physical intrusion panels (Bosch, DSC, Honeywell) when motion sensors or door contacts are breached.

Port (Integer | [Required] | Default: 10002): Listening TCP/UDP port.
Protocol (Enum | [Required] | Default: TCP): Operating transport protocol (*TCP*, *UDP*).
EncryptionAlgorithm (Enum | [Required] | Default: None): Payload encryption mode (*None*, *AES128*, *AES192*, *AES256*).
EncryptionKey (String | [Optional] | Default: ""): Pre-shared AES cryptographic key string.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Receives incoming alarm panel event packets:
Trigger (Boolean) - Pulse on SIA frame arrival.
Account (String) - Transmitting account code.
EventCode (String) - Standard SIA event code (e.g., BA for burglary).
Zone (String) - Zone or sensor identifier.
Timestamp (String) - Packet timestamp.
RawPacket (String) - Raw unparsed SIA DC-09 payload.
WriteValue: Not supported.

`5.6.7 SIA Agent`

NOTE

Scope & Common Use Case
Central station dispatch. Commonly deployed by corporate security operations centers to forward verified, high-priority Uniflow alarms out to commercial police dispatch or external central monitoring stations via SIA DC-09 protocol.

Host (String | [Required] | Default: "127.0.0.1"): Target central station IP address.
Port (Integer | [Required] | Default: 10002): Destination receiver port.
Protocol (Enum | [Required] | Default: TCP): Outbound transport protocol (*TCP*, *UDP*).
ConnectionMode (Enum | [Required] | Default: Persistent): Socket maintenance strategy (*OnRequest*, *Persistent*).
EncryptionAlgorithm (Enum | [Required] | Default: None): Cryptographic cipher (*None*, *AES128*, *AES192*, *AES256*).
EncryptionKey (String | [Optional] | Default: ""): Pre-shared AES key.
QueueLimit (Integer | [Advanced] | Default: 50): Maximum queued outbound alarm messages before shedding load.
RetryIntervalMs (Integer | [Advanced] | Default: 5000): Delay before re-attempting failed transmission.
MessageTimeoutMs (Integer | [Advanced] | Default: 30000): Maximum wait time for receiving central station ACK frames.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Not supported.
WriteValue: Dispatches outbound alarm frames to central station. Exposes input ports:
Account (String) - Transmitter account number.
EventCode (String) - Standard SIA code to dispatch.
Zone (String) - Event location zone identifier.

`5.6.8 KisanCM`

NOTE

Scope & Common Use Case
Banking and financial hardware integration. Commonly deployed in bank vaults, casino cash counting rooms, and armored transit depots to interface directly with Kisan currency sorting machinery, capturing real-time bill counts and serial numbers.

HostOrUrl (String | [Required] | Default: "0.0.0.0"): Listening IP address binding interface.
Port (Integer | [Required] | Default: 5000): Bound communication port.

Rule Graph Node Interface:
InputSource: Not supported.
DataSource: Not supported.
EventInput: Fires when sorting/counting transaction registers:
Trigger (Boolean) - Pulse indicating operation completed.
Count (Int) - Total processed count of bills.
Denomination (Int) - Evaluated denomination value.
SerialNumbers (StringArray) - Collection of recognized serial number strings.
TotalAmount (Int) - Integrated transaction monetary value.
WriteValue: Not supported.

---

`6. Advanced Features & Troubleshooting`

`6.1 Diagnostic Inspection & Error Tracing`

When a visual rule fails or an adapter reports a fault:

Navigate to the Logs view.

Ensure the Level Filter is set to Error or Warning to isolate the problem.

Locate the error entry and double-click the row to view the complete multi-line stack trace.

For source adapters, switch to the Sources view and observe the Runtime Status error sub-label, which provides immediate driver-level feedback (e.g., *Socket Timeout*, *Authentication Refused*, *Register Out of Bounds*).

`6.2 Licensing Limits & Subsystem Verification`

If new source adapters fail to start:

Navigate to Settings → License.

Inspect the Status Badge Card to ensure the system is not reporting *UNLICENSED SYSTEM* or *LICENSE EXPIRED*.

Review the Allowed Capacity Limits Table to verify that your active source counts do not exceed the permitted connection thresholds for that specific SourceType`.

---

*End of Document*

Uniflow User Manual

Uniflow User Manual

1. Introduction and Overview

1.1 Purpose

1.2 Target Audience

1.3 System Requirements

2. Getting Started

2.1 Installation and Setup

2.2 Quick Start Workflow

2.3 Navigation and Interface Architecture

3. Core Features: Navigation Views In-Depth

3.1 Dashboard

3.1.1 Two-Tier Topology Navigation

3.1.2 Interactive Canvas & Controls

3.1.3 Node Properties & Scatterplot Diagnostics

3.1.4 Operational Summary Indicator

3.2 Rules

3.2.1 Toolbar Actions

3.2.2 Data Grid Columns

3.3 Sources

3.3.1 Toolbar Actions

3.3.2 Data Grid Columns

3.4 Storage

3.4.1 Filtering Card

3.4.2 Tab 1: Storage Points

3.4.3 Adding an Internal Storage "Data Point"

3.4.4 Tab 2: Live Data

3.5 JSON Objects

3.5.1 Toolbar & Filtering

3.5.2 Data Grid Columns

3.5.3 Adding a JSON Object Schema

3.6 Logs

3.6.1 Toolbar Actions

3.6.2 Granular Filter Bar

3.6.3 Log Data Grid

3.7 Settings

3.7.1 Toolbar Actions

3.7.2 Tab 1: Logging Configuration

3.7.3 Tab 2: System License Management

4. Rule Editor & Graph Nodes

4.1 Philosophy of Uniflow Rules

4.1.1 Core Execution Mechanics & Concurrency

4.2 Creating and Debugging Rules

4.2.1 Configuring Rule Identity and Metadata

4.2.2 Required Nodes in a Functional Rule

4.2.3 Connecting Graph Nodes: Mapping the Flow from Source to Sink

4.2.4 Real-Time Rule Execution Debugging

4.3 Anatomy & Meaning of Graph Nodes

4.3.1 What is a Graph Node?

4.4 Exhaustive Graph Node Catalog

4.4.1 Sources In/Out (Ingest)

4.4.2 Actions & Sinks

4.4.3 Constants

4.4.4 Logic & Comparisons

4.4.5 Flow Control

4.4.6 Strings

4.4.7 Arithmetic Math

4.4.8 Timers & Pulses

4.4.9 Signal & State

4.4.10 Arrays

4.4.11 Collections & Object Extraction

4.4.12 JSON Utilities

4.4.13 DateTime

4.4.14 Bitwise

4.4.15 Cryptography

4.4.16 Advanced Mathematical Functions

4.4.17 Data Quality & Null Handling

4.4.18 Tools

5. Source Adapters & Configuration Parameters

5.1 Built-In System Sources

5.2 Sources "Data Points"

5.3 Internal & System Classifications

5.3.1 System Timer

5.3.2 Internal Storage

5.4 Industrial Automation Protocols

5.4.1 Modbus TCP Client

5.4.2 Modbus Server

5.4.3 OPC UA Client

5.4.4 OPC UA Server

5.4.5 CAN Bus

`3.2.1 Toolbar Actions`

`3.2.2 Data Grid Columns`

`3.3 Sources`

`3.3.1 Toolbar Actions`

`3.3.2 Data Grid Columns`

`3.4 Storage`

`3.4.1 Filtering Card`

`3.4.2 Tab 1: Storage Points`

`3.4.3 Adding an Internal Storage "Data Point"`

`3.4.4 Tab 2: Live Data`

`3.5 JSON Objects`

`3.5.1 Toolbar & Filtering`

`3.5.2 Data Grid Columns`

`3.5.3 Adding a JSON Object Schema`

`3.6 Logs`

`3.6.1 Toolbar Actions`

`3.6.2 Granular Filter Bar`

`3.6.3 Log Data Grid`

`3.7 Settings`

`3.7.1 Toolbar Actions`

`3.7.2 Tab 1: Logging Configuration`

`3.7.3 Tab 2: System License Management`

`4. Rule Editor & Graph Nodes`

`4.1 Philosophy of Uniflow Rules`

`4.1.1 Core Execution Mechanics & Concurrency`

`4.2 Creating and Debugging Rules`

`4.2.1 Configuring Rule Identity and Metadata`

`4.2.2 Required Nodes in a Functional Rule`

`4.2.3 Connecting Graph Nodes: Mapping the Flow from Source to Sink`

`4.2.4 Real-Time Rule Execution Debugging`

`4.3 Anatomy & Meaning of Graph Nodes`

`4.3.1 What is a Graph Node?`

`4.4 Exhaustive Graph Node Catalog`

`4.4.1 Sources In/Out (Ingest)`

`4.4.2 Actions & Sinks`

`4.4.3 Constants`

`4.4.4 Logic & Comparisons`

`4.4.5 Flow Control`

`4.4.6 Strings`

`4.4.7 Arithmetic Math`

`4.4.8 Timers & Pulses`

`4.4.9 Signal & State`

`4.4.10 Arrays`

`4.4.11 Collections & Object Extraction`

`4.4.12 JSON Utilities`

`4.4.13 DateTime`

`4.4.14 Bitwise`

`4.4.15 Cryptography`

`4.4.16 Advanced Mathematical Functions`

`4.4.17 Data Quality & Null Handling`

`4.4.18 Tools`

`5. Source Adapters & Configuration Parameters`

`5.1 Built-In System Sources`

`5.2 Sources "Data Points"`

`5.3 Internal & System Classifications`

`5.3.1 System Timer`

`5.3.2 Internal Storage`

`5.4 Industrial Automation Protocols`

`5.4.1 Modbus TCP Client`

`5.4.2 Modbus Server`

`5.4.3 OPC UA Client`

`5.4.4 OPC UA Server`

`5.4.5 CAN Bus`

`5.5 IoT, Networking, and IT Management Protocols`

`5.5.1 MQTT Client`

`5.5.2 SNMP Walker`

`5.5.3 SNMP Agent`

`Security Levels`

`Testing Setup in Uniflow`

`Step A: Configure the SNMP Agent (Server)`

`Step B: Configure the SNMP Walker (Client)`

`Troubleshooting`

`5.5.4 HTTP Client`

`5.5.5 TCP Echo`

`5.5.6 Serial Port`

`5.5.7 Email Client`

`5.5.8 WebHook`

`5.6 Building Management & Physical Security Protocols`

`5.6.1 BACnet Walker`

`5.6.2 BACnet Agent`