Uniflow Technical Overview

1. Executive Summary

Uniflow is an advanced visual workflow automation, protocol ingestion, and rule-evaluation platform built specifically for Industrial IoT, physical security integration, and telemetry processing. It acts as the intelligent "nervous system" connecting disparate hardware and software ecosystems. Uniflow bridges diverse communication protocols (like Modbus, OPC UA, MQTT, SNMP, and hardware-specific APIs like Avigilon and Milestone) with a powerful, deterministic visual rule engine.

This document outlines the architectural aspects, performance considerations, and primary areas of application for the Uniflow platform.

2. System Architecture

Uniflow employs a modern, highly decoupled architecture designed for stability and real-time responsiveness. It separates the visual control plane from the background execution engine.

2.1 Decoupled Client-Service Model

Uniflow is deployed as an integrated suite comprising two primary components:

• Uniflow Client (Desktop App): A Windows Presentation Foundation (WPF) Fluent UI application serving as the presentation layer. It provides visual interfaces for designing topologies, monitoring dashboards (via D3.js), and configuring rule graphs.
• Uniflow Service (Background Worker): A highly resilient .NET background service (UniflowService) that handles physical device polling, continuous data stream ingestion, and rule evaluation. It acts as the headless backend engine.

Visual Control Plane (GUI) <--- Named Pipe IPC ---> Background Service (UniflowService)
                                 Push Pipe (Async Telemetry & Traces)

Inter-Process Communication (IPC): The UI and Background Service communicate via a NamedPipeIpcServer and a PushPipeServer.

• The IPC Server handles synchronous commands (like starting/stopping sources, saving rules).
• The Push Pipe handles asynchronous live telemetry streaming (pushing SourceValuesChanged, Heartbeat, Rule Execution Traces) out to subscribed UI clients with sub-millisecond precision.

2.2 In-Memory Storage & State Persistence

Uniflow includes a built-in internal memory registry:

• Storage Points: Structured definitions of memory variables (Boolean, Integer, Double, String) that act as intermediates to chain multi-stage logic pipelines.
• Persistence: Selected memory points can be flagged as "Persistent," wherein the background service continually writes the latest state to local disk storage, allowing full state recovery upon server reboots or power failures.

2.3 Visual Rule Engine Architecture

The rule engine is built on a visual graph logic structure (Directed Acyclic Graph):

• Nodes: Atomic computational blocks (Triggers, Logic, Math, Flow Control, Sinks).
• Topological Ordering: The graph executes deterministically from upstream ingestion to downstream execution sinks. Logic nodes (e.g., Multi-Condition If) will not evaluate until all requisite input connections are fully resolved.
• Node Catalog: Comprehensive built-in catalog spanning basic arithmetic to Advanced Bitwise packing (for PLCs), Cryptography (AES, RSA, SHA-2), and Array/Collection manipulation.

3. Data Ingestion & Protocol Processing

3.1 Unified Source Abstraction

Uniflow implements an abstraction layer allowing rules to ingest data generically, oblivious to the underlying hardware protocol. The background service (SourceManager) dynamically loads and manages instances of various source adapters.

3.2 Protocol Adapter Coverage

• Industrial Automation: Modbus TCP (Client & Server), OPC UA (Client & Server), CAN Bus (with custom Vector DBC parsing support).
• Networking & IT: SNMP (Walker & Agent supporting v2c and secure v3 USM), TCP Echo, HTTP Client (REST polling).
• IoT & Telemetry: MQTT (Pub/Sub).
• Physical Security / VMS: Deep native integrations with Avigilon and Milestone Video Management Systems (Alarm ingestion, motion events), Hexagon Lidar, and SIA alarm receivers.

4. Performance & Concurrency

Rules execute asynchronously across .NET ThreadPool workers. When multiple independent sources emit telemetry simultaneously, their bound rules are dispatched and evaluated in parallel. This guarantees high-throughput telemetry ingestion without single-threaded bottlenecks.

5. Areas of Appliance