Automata Controls Logo

AUTOMATA CONTROLS BMS

Building Management System

Powered By Nexus
Intelligent Building Management for the Modern World

Real-Time Monitoring

Monitor your building systems in real-time with advanced analytics

Smart Controls

Intelligent automation and control for optimal efficiency

Energy Optimization

Reduce costs and environmental impact with smart energy management

InfluxData Webcast
Tuesday, October 28, 2025 | 1:00-2:00 PM ET

Andrew Jewell Sr.
Founder & CTO, AutomataNexus AI
Logo

Architecting Industrial IoT Systems
with Time Series Data

Real-World Patterns from Building the Nexus BMS Platform
Enterprise IoT Architecture: Scaling to 16 Facilities with InfluxDB 3.0
InfluxData Webcast
Tuesday, October 28, 2025 | 1:00-2:00 PM ET

Andrew Jewell Sr.
Founder & CTO, AutomataNexus AI
Slide 2

The Enterprise IoT Challenge

What Enterprise Developers Are Being Asked to Build

Today's Focus: How we architected the Nexus BMS platform to solve these challenges, from initial hackathon prototype to production system managing 16 facilities with 99.8% uptime.

What We'll Cover

Slide 3

The Complete Nexus Ecosystem

Four Independent Systems Working Together

  • Nexus BMS: Cloud platform (DigitalOcean)
  • NexusEdge: 16 Raspberry Pi controllers
  • NexusNeural: AI inference engine (RPI5 + Hailo-8)
  • Nexus Apollo: Portable diagnostic device
System Architecture Diagram - 4 systems interconnected
┌───────────────────────────────────────────────────────────┐ │ 1. NEXUS BMS (Cloud - DigitalOcean) │ │ ├── Next.js 15 Application (React 19 + TypeScript) │ │ ├── InfluxDB 3.0 (Ports 8181-8196, one per facility) │ │ ├── PostgreSQL (Customer/Equipment configuration) │ │ └── Cloudflare Tunnel (Secure remote access) │ │ Receives sensor data from all NexusEdge controllers │ └───────────────────────────────────────────────────────────┘ ↓ POST sensor data (45s) ↑ GET commands (5min) ┌───────────────────────────────────────────────────────────┐ │ 2. NEXUSEDGE CONTROLLERS (16 Raspberry Pi units) │ │ ├── Deployed at 16 facilities │ │ ├── Monitor 106 equipment units │ │ ├── 6 PM2 Services (local-controller, bms-reporter, etc) │ │ ├── Local SQLite (5 databases for offline operation) │ │ └── Autonomous failover when cloud unreachable │ │ POST sensor data → Nexus BMS (every 45 seconds) │ │ POLL commands ← Nexus BMS (every 5 minutes) │ └───────────────────────────────────────────────────────────┘ ↓ Query equipment data ┌───────────────────────────────────────────────────────────┐ │ 3. NEXUSNEURAL (RPI5 + Hailo-8 NPU at workstation) │ │ ├── Runs 8 AI models (43.5M parameters, 26 TOPS) │ │ ├── Queries 106 equipment metrics from Nexus BMS │ │ ├── Performs inference on Hailo-8 NPU (11Hz refresh) │ │ └── Returns predictions/diagnostics to BMS │ │ Detects failures 7-14 days before they occur │ └───────────────────────────────────────────────────────────┘ ┌───────────────────────────────────────────────────────────┐ │ 4. NEXUS APOLLO (Portable Diagnostic Device) │ │ ├── Field technician tool (separate from BMS) │ │ ├── 21-sensor diagnostic kit + 8 AI models │ │ ├── Used for commissioning, diagnostics, temp logging │ │ └── RPI5 + Hailo-8 + 10.1" 4K touchscreen │ └───────────────────────────────────────────────────────────┘
Today's Focus: Slides 5-13 cover Nexus BMS + NexusEdge architecture. Slides 14-19 deep dive into NexusNeural AI system. Slide 20 briefly covers Apollo diagnostic device. Slides 21-26 showcase all four UIs.
Slide 4

Nexus BMS + NexusEdge Architecture

Design Principles

Legacy Equipment (Modbus/BACnet) ↓ NexusEdge Controller (Raspberry Pi + Node.js) ↓ POST sensor data (45 sec) Nexus BMS + InfluxDB (processes logic) ↑ GET command results via API (5 min) NexusEdge Controller (executes + local SQLite backup) ↓ Equipment Control

Technology Stack

Slide 5

Bidirectional Data Flow

Upstream: Sensor Data to Cloud

// JavaScript: Edge controller posting sensor data (bmsReporter.js) const http = require('http'); async function postSensorData() { // 1. Read sensors via CLI (boardController.js) const sensorData = await boardController.readBoardInputs(); // 2. Write to local SQLite first (never lose data) await db.insertNodeRedReadings(sensorData); // 3. POST to Nexus BMS InfluxDB via HTTP (line protocol) const lineProtocol = `metrics,location=ElementLabs,equipmentId=${equipmentId} ` + `SpaceTemp=${sensorData.space},SupplyTemp=${sensorData.supply}`; try { const response = await fetch( `http://${NEXUS_BMS_IP}:8181/api/v3/write_lp?db=Locations`, { method: 'POST', body: lineProtocol, timeout: 5000 } ); } catch (err) { console.log('Upload failed, data safe in SQLite'); } } // Post every 45 seconds setInterval(postSensorData, 45000);

Downstream: Commands from Cloud to Edge

Slide 6

NexusEdge Controller Service Architecture

Six Independent Node.js Services (PM2-Managed)

Data Services

  • local-controller
    • Reads sensors via CLI every 15s
    • Writes to SQLite metrics.db
    • Memory limit: 300MB
  • bms-reporter
    • POSTs sensor data to Nexus BMS every 45s
    • InfluxDB line protocol format
    • Memory limit: 200MB
  • processing-reporter
    • GETs commands from Nexus BMS every 5min
    • Queries InfluxDB via SQL
    • Memory limit: 200MB

Control & Monitoring

  • logic-executor
    • Executes control algorithms
    • Writes commands to equipment
    • Memory limit: 300MB
  • vibration-monitor
    • Predictive maintenance monitoring
    • Analyzes sensor patterns
    • Memory limit: 200MB
  • nexus-portal
    • Express.js + React UI (port 8000)
    • Socket.IO for real-time updates
    • Memory limit: 500MB

Why Independent Services Instead of Monolith

Total Resource Footprint: All 6 services combined use less than 2GB RAM, less than 15% CPU on Raspberry Pi 4
Slide 7

One-Click Deployment System

The Challenge: Complex Multi-Service Installation

  • Installing a production edge controller traditionally requires 40+ manual steps across 4-6 hours
  • System dependencies, Node.js packages, database schemas, Cloudflare tunnels, PM2 services, hardware libraries
  • High error rate from manual configuration (typos, missed steps, version conflicts)
  • Difficult to reproduce identical installations across multiple sites
SetupNexus.py GUI Screenshot - Python installer interface

The Solution: SetupNexus.py GUI Installer

16
Installation Steps
2,400+
Lines of Python
20 min
Install Time

What the Installer Automates (16 Steps)

System Setup (Steps 1-6)

  • Step 1: Clean previous installations
  • Step 2: Generate unique controller serial
  • Step 3: Install system dependencies
  • Step 3.5: Install hardware libraries
  • Step 4: Build React app with Webpack
  • Step 5: Patch server.js with terminal handlers
  • Step 6: Generate .env file with API keys

Services & Deployment (Steps 7-16)

  • Step 7: Initialize 5 SQLite databases
  • Step 8: Create Node-RED flow configuration
  • Step 9: Install Cloudflare tunnel
  • Step 10: Create Cloudflare tunnel via API
  • Step 11: Skip NGINX (tunnel direct to app)
  • Step 12: Setup log directory and logrotate
  • Step 13: Install PM2, create ecosystem config
  • Step 14: Start all PM2 services + systemd
  • Step 15: Configure fullscreen auto-launch
  • Step 16: Optional Claude Code CLI
Slide 8

Automated Database Schema Creation

SQLite Schema Generation (Step 7 of Installer)

# Python: Creating metrics.db with sqlite3 import sqlite3 metrics_db = sqlite3.connect(f'{portal_dest}/data/metrics.db') cursor = metrics_db.cursor() # Create nodered_readings table cursor.execute(''' CREATE TABLE IF NOT EXISTS nodered_readings ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, setpoint REAL, space_temp REAL, supply_temp REAL, return_temp REAL, valve_position REAL, alarm_status TEXT, extra_data TEXT ) ''') # Create board_configs table (matches app expectations) cursor.execute(''' CREATE TABLE IF NOT EXISTS board_configs ( id INTEGER PRIMARY KEY AUTOINCREMENT, board_id TEXT UNIQUE NOT NULL, board_type TEXT, firmware_version TEXT, last_seen DATETIME, config_data TEXT, created_at DATETIME DEFAULT CURRENT_TIMESTAMP ) ''') # Create indexes for fast queries cursor.execute('CREATE INDEX idx_nodered_timestamp ON nodered_readings(timestamp)') metrics_db.commit() metrics_db.close()

The Five Edge Databases

Slide 9

Automated Cloudflare Tunnel Provisioning

Zero-Configuration Secure Remote Access

# Python: Create tunnel programmatically via Cloudflare API import requests, uuid, base64 # Generate unique credentials tunnel_id = str(uuid.uuid4()) tunnel_secret = base64.b64encode(os.urandom(32)).decode() tunnel_name = f"nexuscontroller-anc-{random_hex}" # Create tunnel via Cloudflare API headers = {'Authorization': f'Bearer {CLOUDFLARE_API_TOKEN}'} tunnel_response = requests.post( f'https://api.cloudflare.com/client/v4/accounts/{account_id}/tunnels', headers=headers, json={ 'name': tunnel_name, 'tunnel_secret': tunnel_secret, 'config_src': 'local' } ) tunnel_id = tunnel_response.json()['result']['id'] # Create DNS CNAME record dns_response = requests.post( f'https://api.cloudflare.com/client/v4/zones/{zone_id}/dns_records', headers=headers, json={ 'type': 'CNAME', 'name': tunnel_name, 'content': f'{tunnel_id}.cfargotunnel.com', 'proxied': True # Enable Cloudflare proxy } )
Result: 20 minutes after starting installer, controller is accessible worldwide at https://nexuscontroller-anc-XXXXXX.automatacontrols.com with zero manual network configuration.
Slide 10

InfluxDB as Embedded Cloud Database

Why Embedded InfluxDB in Nexus BMS

Multi-Database Strategy

// TypeScript: Next.js API route writes to InfluxDB export async function POST(request: Request) { const { equipment_id, location_id, sensor_data } = await request.json(); // Route to correct facility database const influx_port = 8181 + parseInt(location_id); const influx_db = `${facility_name}-node`; // Write sensor data via InfluxDB HTTP API const line_protocol = `equipment,equipment_id=${equipment_id} temp=${sensor_data.temp} ${timestamp}`; await fetch(`http://localhost:${influx_port}/api/v3/write_lp?db=${influx_db}`, { method: 'POST', body: line_protocol }); return Response.json({ success: true }); }
Slide 11

Autonomous Failover Design

The Critical Requirement

Implementation Strategy

// JavaScript: Heartbeat check with failover logic (bmsMonitor.js) let consecutiveFailures = 0; async function checkCloudHeartbeat() { try { const response = await fetch( `http://${NEXUS_BMS_IP}:8181/health`, { timeout: 5000 } ); if (response.ok) { consecutiveFailures = 0; return true; } } catch (err) { consecutiveFailures++; } if (consecutiveFailures >= 3) { console.log('Nexus BMS unreachable, switching to local control'); return false; } return true; // Give cloud benefit of doubt for 1-2 failures } // Run local control logic (identical to cloud) async function runLocalControlLogic(sensorData) { const logicExecutor = require('./logicExecutor'); return await logicExecutor.executeLogicCycle(); }

Production Results

Slide 12

CLI-Based Hardware Control

Why CLI Commands Instead of Native Libraries

  • Portability: Works across ARM (Raspberry Pi) and x86 architectures without recompilation
  • No Dependencies: No Python/C libraries to install or maintain
  • Simple Debugging: Can test commands manually in terminal
  • Vendor Updates: Hardware vendor maintains CLI tools, we just use them
MegaBAS HAT 16-Universal Input HAT
// JavaScript: boardController.js provides unified API const { exec } = require('child_process'); const { promisify } = require('util'); const execAsync = promisify(exec); // Read temperature from 16-Universal Input board async function readTemperatureSensor(channel) { // Read 1K RTD via CLI command const { stdout } = await execAsync( `16univin 0 1kinrd ${channel}` ); const tempC = parseFloat(stdout.trim()); const tempF = (tempC * 9/5) + 32; return tempF; } // Control relay via CLI async function setRelay(channel, state) { const onOff = state ? 'on' : 'off'; await execAsync( `16relind 0 write ${channel} ${onOff}` ); } // Set analog output (0-10V) async function setAnalogOutput(channel, voltage) { await execAsync( `megabas 0 dacwr ${channel} ${voltage}` ); }

Supported Hardware

Slide 13

NexusNeural: 8-Model AI Ensemble

The Separate AI Inference System

The Challenge: 106 Equipment Units, 530-2,120 Sensors

The Solution: Hierarchical Ensemble Architecture

APOLLO (Master Coordinator - 20.8M params) → Final authority on all decisions │ COLOSSUS (Aggregator - 17.3M params) + GAIA (Safety Validator - 2.4M params) → Multi-system correlation → Safety validation │ │ ┌─┴──────┬──────────┬─────────┬────┴───┐ │ │ │ │ │ AQUILO BOREAS NAIAD VULCAN ZEPHYRUS (Electrical) (Refrigeration) (Water) (Mechanical) (Airflow) 608K 1.2M 533K 476K 845K 96.7% 91.91% 99.99% 98.1% 99.8%
8
Neural Networks
43.5M
Total Parameters
79
Fault Types Detected
NexusNeural NPU System
RPI5 + Hailo-8 NPU running 8 AI models
View Live NexusNeural NPU Demo
Slide 14

Domain-Specialized Neural Networks

Why 5 Separate Specialist Models?

AQUILO - Electrical (608K params)

  • 96.7% accuracy, 13 fault types
  • 64 sensors (voltage, current, PF, THD)
  • Detects: Phase imbalance, harmonics, motor faults
  • Approximately 8ms inference
AQUILO Certificate 
# AQUILO - Electrical Fault Detection Model
import hailo_platform as hp

class AQUILOModel:
    def __init__(self):
        self.target = hp.Target('hailo8')
        self.model = self.target.configure('aquilo_electrical.hef')
        self.input_shape = (64,)  # 64 electrical sensors
        
    def predict(self, sensor_data):
        # Voltage, current, power factor, THD analysis
        features = self.extract_features(sensor_data)
        inference = self.model.run(features)
        return self.decode_faults(inference)
        
    def decode_faults(self, output):
        fault_types = ['phase_imbalance', 'harmonics', 
                      'motor_fault', 'overcurrent']
        return {f: conf for f, conf in zip(fault_types, output)}

BOREAS - Refrigeration (1.2M params)

  • 91.91% accuracy, 17 fault types
  • 80 sensors (pressures, temps, superheat)
  • Detects: Charge issues, TXV hunting, fouling
  • Approximately 12ms inference
BOREAS Certificate 
# BOREAS - Refrigeration System Analysis
class BOREASModel:
    def __init__(self):
        self.model = load_hailo_model('boreas_refrigeration.hef')
        self.sensors = {
            'suction_pressure': 0, 'discharge_pressure': 1,
            'superheat': 2, 'subcool': 3,
            'evap_temp': 4, 'cond_temp': 5
        }
        
    def analyze_refrigeration(self, data):
        # Calculate refrigeration metrics
        cop = self.calculate_cop(data)
        charge_level = self.estimate_charge(data)
        txv_status = self.check_txv_hunting(data)
        
        # Run neural network inference
        features = np.array([cop, charge_level, txv_status])
        faults = self.model.predict(features)
        
        return {
            'refrigerant_leak': faults[0],
            'txv_hunting': faults[1],
            'condenser_fouling': faults[2]
        }

NAIAD - Water Systems (533K params)

  • 99.99% accuracy, 16 fault types
  • 64 sensors (flow, pressure, temp, quality)
  • Detects: Pump cavitation, scaling, leaks
  • Approximately 7ms inference
NAIAD Certificate 
# NAIAD - Water Systems Monitoring
class NAIADModel:
    def __init__(self):
        self.model = HailoModel('naiad_water_v2.hef')
        self.thresholds = {
            'flow_min': 0.5, 'pressure_max': 150,
            'ph_range': (6.5, 8.5), 'tds_max': 500
        }
        
    def detect_water_faults(self, sensor_array):
        # Preprocess water quality metrics
        flow_rate = sensor_array[0:16]
        pressure = sensor_array[16:32]
        temperature = sensor_array[32:48]
        quality = sensor_array[48:64]
        
        # Neural network inference at 99.99% accuracy
        predictions = self.model.infer({
            'flow': flow_rate, 'pressure': pressure,
            'temp': temperature, 'quality': quality
        })
        
        return self.classify_water_issues(predictions)

VULCAN - Mechanical (476K params)

  • 98.1% accuracy, 16 fault types
  • 96 sensors (vibration 3-axis, acoustics)
  • Detects: Bearing wear, belt slippage, misalignment
  • Approximately 10ms inference
VULCAN Certificate 
# VULCAN - Mechanical Vibration Analysis
class VULCANModel:
    def __init__(self):
        self.npu = HailoNPU()
        self.model = self.npu.load('vulcan_mechanical.hef')
        self.sampling_rate = 25600  # 25.6kHz for vibration
        
    def analyze_vibration(self, accel_data):
        # 3-axis accelerometer data processing
        x, y, z = accel_data[:, 0], accel_data[:, 1], accel_data[:, 2]
        
        # FFT for frequency domain analysis
        freq_features = np.fft.rfft([x, y, z])
        
        # Extract bearing fault frequencies
        bpfo = self.extract_bpfo(freq_features)
        bpfi = self.extract_bpfi(freq_features)
        
        return self.model.predict({
            'time_domain': accel_data,
            'freq_domain': freq_features,
            'bearing_freqs': [bpfo, bpfi]
        })

ZEPHYRUS - Airflow (845K params)

  • 99.8% accuracy, 17 fault types
  • 72 sensors (velocity, pressure, humidity, CO2)
  • Detects: Filter clogging, duct leakage, damper failures
  • Approximately 9ms inference
ZEPHYRUS Certificate 
# ZEPHYRUS - Airflow System Intelligence
class ZEPHYRUSModel:
    def __init__(self):
        self.hailo = HailoRuntime()
        self.model = self.hailo.model('zephyrus_airflow.hef')
        self.sensors = 72  # velocity, pressure, humidity, CO2
        
    def diagnose_airflow(self, readings):
        # Process multi-zone airflow data
        velocities = readings['velocity'].reshape(-1, 18)
        static_pressure = readings['static_p']
        differential_p = readings['diff_p']
        
        # Calculate system resistance curve
        system_curve = self.calc_resistance(velocities, differential_p)
        
        # 99.8% accurate fault detection
        faults = self.model.infer({
            'flow_profile': velocities,
            'resistance': system_curve,
            'filter_dp': differential_p[0]
        })
        
        return {
            'filter_loading': faults['filter'],
            'duct_leakage': faults['leaks'],
            'damper_fault': faults['dampers']
        }

Parallel Execution on Hailo-8

  • All 5 run simultaneously on NPU
  • Total specialist time: approximately 12ms (longest pole)
  • Results feed COLOSSUS aggregator
Key Innovation: Each specialist achieves 91-99% accuracy on its narrow domain. A single generalist model attempting all 79 fault types achieved only 73% accuracy.
Slide 15

Orchestration Layer Intelligence

COLOSSUS - Master Aggregator (17.3M parameters)

  • Role: Combines outputs from all 5 specialists into unified system diagnosis
  • Architecture: Multi-head Attention Fusion
  • Accuracy: 100% on test set
  • Key Capability: Detects cascade failures spanning multiple domains
  • Example: Refrigerant leak leads to compressor overload leads to vibration increase leads to airflow degradation
  • Inference: Approximately 15ms
COLOSSUS Certificate 
# COLOSSUS - Master Aggregator Neural Network
class COLOSSUSAggregator:
    def __init__(self):
        self.model = HailoModel('colossus_aggregator_v3.hef')
        self.attention_heads = 16
        self.specialist_inputs = {
            'aquilo': 13, 'boreas': 17, 'naiad': 16,
            'vulcan': 16, 'zephyrus': 17
        }
        
    def aggregate_predictions(self, specialist_outputs):
        # Multi-head attention fusion mechanism
        attention_weights = self.calculate_attention(specialist_outputs)
        
        # Cross-domain correlation analysis
        correlations = self.cross_correlate_faults(specialist_outputs)
        
        # Cascade failure detection
        cascade_patterns = self.detect_cascades(correlations)
        
        return self.model.infer({
            'specialist_preds': specialist_outputs,
            'attention': attention_weights,
            'cascades': cascade_patterns
        })

GAIA - Safety Validator (2.4M parameters)

  • Role: Final safety validation before any automated action
  • Accuracy: 100%, 8,029 safety overrides during training
  • 5 Output States: SAFE, WARNING, OVERRIDE, EMERGENCY, UNCERTAIN
  • Key Feature: Zero false negatives on safety-critical scenarios
  • Inference: Approximately 10ms
GAIA Certificate 
# GAIA - Safety Validation Neural Network
class GAIASafetyValidator:
    def __init__(self):
        self.model = HailoModel('gaia_safety_validator.hef')
        self.safety_states = ['SAFE', 'WARNING', 
                             'OVERRIDE', 'EMERGENCY', 'UNCERTAIN']
        self.override_threshold = 0.95
        
    def validate_action(self, proposed_action, system_state):
        # Analyze proposed control action
        risk_factors = self.assess_risk_factors(proposed_action)
        
        # Check safety constraints
        constraints = self.check_safety_constraints(system_state)
        
        # Historical incident analysis
        similar_scenarios = self.query_incident_db(proposed_action)
        
        # Neural network inference for safety decision
        safety_score = self.model.predict({
            'action': proposed_action,
            'state': system_state,
            'risks': risk_factors,
            'constraints': constraints,
            'history': similar_scenarios
        })
        
        # Zero tolerance for safety-critical scenarios
        if safety_score.critical_risk > 0.01:
            return 'OVERRIDE', 'Critical safety risk detected'
            
        return self.safety_states[np.argmax(safety_score.states)]

APOLLO - Master Coordinator (20.8M parameters)

  • Role: Supreme authority making final diagnostic decisions
  • Architecture: Multi-task LSTM with 9 output heads
  • Accuracy: 99.92% overall system diagnosis
  • Capabilities: 12 fault categories, cost prediction, 5 priority levels, 7 optimization strategies
  • Inference: Approximately 20ms
APOLLO Certificate 
# APOLLO - Master Coordinator & Decision Engine
class APOLLOMasterCoordinator:
    def __init__(self):
        self.model = HailoModel('apollo_master_coordinator.hef')
        self.output_heads = {
            'fault_classification': 12,  # 12 fault categories
            'cost_prediction': 1,      # Repair cost estimate
            'priority_level': 5,       # 5 priority levels
            'time_to_failure': 1,      # Days until failure
            'confidence_score': 1,     # 0-100% confidence
            'optimization_strategy': 7, # 7 strategies
            'maintenance_action': 4,    # Immediate/Schedule/Monitor/None
            'root_cause': 15,          # 15 root cause types
            'impact_assessment': 3      # Low/Medium/High
        }
        
    def make_final_decision(self, colossus_output, gaia_validation):
        # LSTM processes temporal patterns
        temporal_features = self.extract_temporal_patterns()
        
        # Multi-task inference across 9 output heads
        decisions = self.model.infer({
            'aggregated_faults': colossus_output,
            'safety_state': gaia_validation,
            'temporal_context': temporal_features,
            'equipment_history': self.equipment_db.query()
        })
        
        # 99.92% accuracy final diagnosis
        return {
            'diagnosis': self.decode_diagnosis(decisions),
            'action_plan': self.generate_action_plan(decisions),
            'cost_estimate': decisions['cost_prediction'] * 1000,
            'urgency': self.priority_names[decisions['priority_level']]
        }
Complete Pipeline: 5 Specialists (12ms parallel) leads to COLOSSUS (15ms) leads to GAIA (10ms) leads to APOLLO (20ms) equals 57ms for 79-fault comprehensive analysis
Slide 16

Model Training Pipeline

Data Collection: 106 Equipment Units Over 2-5 Years

Feature Engineering with InfluxDB Window Functions

-- InfluxDB SQL: Extract rolling statistics for failure prediction SELECT time, equipment_id, bearing_temp, vibration_rms, -- 20-point rolling average (5 minutes at 15s intervals) AVG(bearing_temp) OVER ( PARTITION BY equipment_id ORDER BY time ROWS BETWEEN 20 PRECEDING AND CURRENT ROW ) as temp_rolling_avg, -- Standard deviation for anomaly detection STDDEV(vibration_rms) OVER ( PARTITION BY equipment_id ORDER BY time ROWS BETWEEN 20 PRECEDING AND CURRENT ROW ) as vibration_stddev FROM equipment_metrics WHERE equipment_type = 'compressor' AND time >= now() - INTERVAL '24 hours'

3-Stage Training Approach

Slide 17

Edge AI with Hailo-8 NPU

Why Hailo-8 for NexusNeural?

  • M.2 Form Factor: Plugs directly into RPI5 M.2 slot (no USB bottleneck)
  • 26 TOPS Performance: INT8 operations
  • Power Efficiency: 1.73 TOPS/watt vs 0.3 TOPS/watt GPU alternatives
  • Deterministic Latency: Less than 6ms variance, critical for real-time
  • No Cloud Dependency: Complete inference at edge, works offline
Hailo-8 NPU Photo

Inference Performance: CPU vs Hailo-8 NPU

CPU (RPI5 Cortex-A76)

  • AQUILO: 340ms
  • BOREAS: 520ms
  • NAIAD: 280ms
  • VULCAN: 410ms
  • ZEPHYRUS: 380ms
  • COLOSSUS: 680ms
  • GAIA: 390ms
  • APOLLO: 890ms
  • Total: 3,890ms (0.26 Hz)
  • CPU: 380% (maxed out)
  • Power: 12W

Hailo-8 NPU

  • AQUILO: 8ms
  • BOREAS: 12ms
  • NAIAD: 7ms
  • VULCAN: 10ms
  • ZEPHYRUS: 9ms (parallel)
  • COLOSSUS: 15ms
  • GAIA: 10ms
  • APOLLO: 20ms
  • Total: 57ms (17.5 Hz)
  • CPU: 15% (preprocessing)
  • Power: 15W
Result: Hailo-8 delivers 68x faster inference (3,890ms to 57ms) while using only 25% more power. Enables real-time analysis of 106 equipment units at 11Hz.
Slide 18

Nexus Apollo: Portable AI Diagnostic Device

A Separate Tool from NexusEdge Controllers

1. New System Commissioning

  • Connect 21 sensors during startup
  • Establish baseline performance profiles
  • Verify manufacturer specifications
  • Document "healthy" signatures
  • Time: 30 min connect, 2-4 hrs baseline

2. Field Diagnostics

  • Technician brings to service calls
  • Immediate AI-powered fault detection
  • Compare current vs baseline
  • All 8 models analyze simultaneously
  • Result: Minutes vs hours troubleshooting

3. Temporary On-Prem Logging

  • Leave device for extended monitoring
  • Capture intermittent faults
  • Trend analysis over days/weeks
  • All data stored on 1TB SSD
  • Duration: Hours to months

Key Difference

  • Apollo: Diagnostic tool, portable, technician-operated
  • NexusEdge: Permanent BMS, automated, 24/7
  • Apollo finds problems, Edge prevents them
  • Can use Apollo to commission Edge
Workflow: Technician unpacks Apollo, connects 21 sensors (30 min), device captures baseline (2-4 hrs), stores equipment "fingerprint". Later, reconnect Apollo to compare current vs baseline - AI instantly identifies deviations.
Slide 19

Four Purpose-Built User Interfaces

One Platform, Four Specialized Interfaces

1. NEXUS BMS (Cloud Dashboard)

  • Users: Facility managers, building owners
  • Tech: Next.js 15 + React 19 + WebSocket
  • Scope: 16 facilities, 106 equipment units
  • Focus: Multi-site oversight, real-time monitoring

2. NEXUSEDGE (Local Controller Portal)

  • Users: On-site HVAC technicians
  • Tech: Express.js + React + xterm.js
  • Scope: Local facility equipment control
  • Focus: Terminal access, offline operation

3. NEXUSNEURAL (AI Inference Dashboard)

  • Users: System admins, AI engineers
  • Tech: RPI5 + Hailo-8 NPU visualization
  • Scope: 8-model ensemble monitoring
  • Focus: Real-time inference (11Hz), predictions

4. NEXUS APOLLO (Portable Diagnostic Interface)

  • Users: Field service technicians
  • Tech: RPI5 + 10.1" touchscreen + 21 sensors
  • Scope: Standalone diagnostic device
  • Focus: Commissioning, troubleshooting
Next 4 Slides: Deep dive into each UI with architecture details and screenshots
Slide 20

Nexus BMS - Cloud Command Center

Global Fleet Management Dashboard

  • Built With: Next.js 15 (App Router) + React 19 + TypeScript
  • Real-Time: WebSocket (Socket.IO) for live equipment status updates
  • Visualization: Chart.js time series + custom React components
  • Query Engine: Direct InfluxDB SQL (ports 8181-8196)

Key Features

  • Multi-facility switching (16 locations)
  • Equipment health cards (106 units)
  • AI diagnostic integration (NexusNeural predictions)
  • Historical trend analysis
  • Alarm management system
  • Mobile-responsive design
Nexus BMS Dashboard Screenshot
Less than 2s
Page Load Time
Less than 100ms
WebSocket Latency
Less than 500ms
InfluxDB Queries
Slide 21

NexusEdge - Local Controller Interface

NexusEdge Portal Screenshot

On-Site Technician Portal (Port 8000)

  • Built With: Express.js + React 18 + Socket.IO + xterm.js
  • Terminal: Full SSH-like access to controller
  • Database: SQLite 3 (5 databases) with real-time queries
  • Autonomous: Works when cloud connection lost

Key Features

  • Live equipment control (setpoints, enable/disable)
  • Embedded terminal for diagnostics (xterm.js)
  • Local sensor graphs (no cloud required)
  • PM2 service status monitoring
  • System health metrics (CPU, memory, disk)
  • Log viewer (6 PM2 service logs)
Why This Matters: Technicians can diagnose issues on-site without cloud access. Full control authority at the edge (safety requirement). Terminal access enables advanced troubleshooting.
Slide 22

NexusNeural - AI Inference Dashboard

Real-Time AI Model Monitoring

NexusNeural AI Dashboard Screenshot
8-model ensemble visualization with live predictions and confidence scores

Built For AI Engineers

  • Live Inference: 11Hz refresh rate (all 8 models)
  • Data Source: Queries 106 equipment metrics from Nexus BMS InfluxDB
  • NPU Metrics: Hailo-8 performance tracking

8-Model Ensemble Visualization

  • AQUILO, BOREAS, NAIAD, VULCAN, ZEPHYRUS (specialists)
  • COLOSSUS (aggregator)
  • GAIA (safety validator)
  • APOLLO (master coordinator)

Live Predictions Display

  • Fault type detection (79 categories)
  • Confidence scores per model
  • Cost predictions (APOLLO)
  • Time-to-failure estimates

Model Performance Metrics

  • Inference latency per model
  • NPU utilization (26 TOPS)
  • Prediction accuracy tracking
  • False positive/negative rates
Update Frequency: 30-second inference cycles across all 106 equipment units
Slide 23

Nexus Apollo - Portable Diagnostic Interface

Field Technician Diagnostic Device

  • Hardware: RPI5 + Hailo-8 + 10.1" 4K Touchscreen
  • Sensors: 21-sensor diagnostic kit (live readouts)
  • AI: All 8 models run locally on Hailo-8
  • Storage: 1TB SSD for baseline capture

Three Operating Modes

  • Commissioning: Capture equipment "healthy" baseline signatures
  • Diagnostic: Real-time comparison (current vs baseline) with AI fault detection
  • Logging: Extended monitoring (hours to months) for intermittent faults
Nexus Apollo Device Screenshot
10.1" touchscreen showing sensor readouts and AI diagnostics
Standalone Operation: No internet required. Complete diagnostic capability in field. Think: Medical diagnostic scanner vs permanent health monitoring system. Apollo finds problems, NexusEdge prevents them.
Slide 24

UI Architecture Philosophy

Separation of Concerns by User Role

Design Principle: Right Interface for Right User Nexus BMS (Cloud) ├─ User: Facility managers, building owners ├─ Access: Anywhere with internet ├─ Focus: Fleet overview, long-term trends, operational metrics └─ Authority: View + approve AI recommendations NexusEdge (Local) ├─ User: On-site HVAC technicians ├─ Access: Local network at facility ├─ Focus: Equipment control, real-time diagnostics └─ Authority: Full control (setpoints, enable/disable) NexusNeural (AI Monitoring) ├─ User: System administrators, AI engineers ├─ Access: Workstation (RPI5 + Hailo-8 at Andrew's desk) ├─ Focus: Model performance, prediction accuracy └─ Authority: Read-only analysis (no equipment control) Nexus Apollo (Portable) ├─ User: Field service technicians ├─ Access: Physical device brought to site ├─ Focus: Commissioning, troubleshooting, validation └─ Authority: Diagnostic only (no control of live systems)

Why Four UIs Instead of One?

  • Security: Separation limits blast radius of compromise
  • Performance: Each optimized for specific use case
  • Offline Operation: Edge and Apollo work without cloud
  • User Experience: Purpose-built workflows, not generic dashboards

Questions & Discussion

IoT Architecture - Edge AI - Production Deployment
Today's Journey:
Edge-First IoT Architecture with Autonomous Failover
Bidirectional API-Driven Communication (No MQTT)
One-Click Installer Deploying 6 PM2 Services
8-Model AI Ensemble on Hailo-8 NPU
68x Faster Inference vs CPU
Four Specialized UIs for Different User Roles
Key Takeaway:
From 40-hour manual BAS installations to 20-minute automated deployments
From reactive maintenance to 7-14 day failure prediction
From proprietary systems to open architecture
Contact:
andrew@automatanexus.com
GitHub: AutomataControls
Live Demo: apollo-anc-3c7a20.automatacontrols.com
1 / 27
×