Control design
- Build FB networks (applications) and device configurations
- Map I/O points (e.g., Modbus registers, OPC UA nodes) into the program
- Export designs for deployment artifacts and configuration generation
Platform
ENGINEERING OVERVIEW.
BootCtrl is centered around Eclipse 4diac FORTE (IEC 61499) running on edge devices, managed by a central backend and configured via a web UI.
UI
DESIGN STUDIO
A web interface for configuring systems/devices, building IEC 61499 control logic, mapping I/O, and monitoring runtime state.
Canvas versioning
- Save/load versioned snapshots through backend versioning endpoints
- Store metadata in Postgres and assets/thumbnails in S3-compatible storage (MinIO in dev)
- Rehydrate the UI state from any snapshot for traceability and rollback
I/O mapping
- Define I/O points once and reuse them across applications
- Bind protocol addresses and scaling to stable identifiers
- Validate mappings before deployment to reduce field surprises
Live observability
- Inspect device health, runtime state, and deployment status
- View variable snapshots and recent events in context
- Correlate design versions with what is running in the field
The Engine
EDGE AGENT
A Rust daemon that runs near machines, supervises the runtime, bridges industrial protocols, and forwards telemetry.
Execution
- Supervises the local control runtime via a runtime adapter (UDS gRPC preferred)
- Exposes a local API for health/status and variable operations
- Designed to run on real devices or in lab/testbed environments
Operations
- OTA updates plus restart/rollback supervision mechanisms
- Optional Bearer-token RBAC and rate limiting for the local API
- Protocol connectors (e.g., Modbus) and MQTT telemetry publishing
Connectivity
- Bridges industrial protocols at the edge (e.g., Modbus, OPC UA)
- Normalizes data into stable tags/points for the control program
- Supports offline-first operation with safe reconnection behavior
Telemetry + events
- Publishes metrics, events, and logs upstream (often via MQTT)
- Adds device identity and version metadata for traceability
- Optimized for low bandwidth with batching and backpressure
The Runtime
CONTROL RUNTIME
Eclipse 4diac FORTE packaged with a runtime adapter layer for control and variable access.
IEC 61499
- Event-driven execution model
- Explicit interfaces and composable function blocks
- Systems/devices/resources as core domain concepts
Runtime adapter
- A consistent API surface between FORTE and the edge-agent
- Supports local control operations (start/stop, deploy, query variables)
- Delivered as part of the runtime image via infrastructure Docker builds
Deterministic loops
- Prioritizes predictable execution paths for critical logic
- Separates control from supervision/telemetry concerns
- Designed for repeatable behavior across devices
Safety surfaces
- Explicit start/stop/deploy operations through the adapter
- Health checks and guarded transitions for runtime state
- Rollback-friendly deployments paired with versioned artifacts
The Brain
ORBITAL BACKEND
A Spring Boot backend with REST + WebSocket APIs, orchestration, versioning, and multi-store persistence.
Orchestration
- REST API at /api/v1 plus WebSocket endpoints for live updates
- Canvas versioning: metadata in Postgres, blobs in S3-compatible storage
- Persists configurations, deployments, and system topology
Telemetry
- Ingests telemetry (often via MQTT) and stores time-series/analytics data
- Backed by Postgres/Timescale + optional InfluxDB and/or ClickHouse
- Streams updates to the UI over WebSocket for monitoring and correlation
Versioning
- Stores immutable snapshots of designs and deployment artifacts
- Enables rollback and reproducibility across environments
- Maintains audit-friendly metadata tied to devices and missions
Security
- Token-based auth and role-aware API access patterns
- Separates control-plane operations from data-plane telemetry
- Designed for multi-tenant deployments and least-privilege access
Data Flows
END-TO-END BEHAVIOR.
How designs become deployments, how runtimes are supervised, and how telemetry returns to operators.
Design → persist → artifacts
- Engineers build control logic and device configs in the UI
- Backend persists configurations and assigns stable identifiers
- Artifacts and payloads are generated for edge deployment
Versioning and traceability
- Snapshots/assets/thumbnails are stored via versioning endpoints
- Object storage holds large blobs; Postgres holds metadata
- UI can restore any snapshot to reproduce incidents and roll back
Runtime supervision and I/O
- Edge-agent talks locally to the runtime adapter (UDS gRPC preferred)
- Adapter controls FORTE: deploy programs, query variables, health
- Industrial protocols are bridged at the edge (e.g., Modbus/OPC UA)
Telemetry and monitoring
- Edge-agent publishes telemetry/events upstream (often via MQTT)
- Backend ingests and stores it (InfluxDB/ClickHouse depending on deployment)
- UI receives live updates over WebSocket for dashboards and diagnostics
Core Concepts
DOMAIN MODEL.
The objects you configure in the UI and persist in the backend when working with IEC 61499/FORTE systems.
System / Device
A physical or virtual controller target (industrial PC, Raspberry Pi, edge computer).
Resource
A FORTE execution container on a device (often a named MainResource).
Function Block (FB)
A reusable control component with event/data inputs and outputs.
FB Network / Application
A connected graph of FB instances and connections—the deployed control program.
I/O Point
A physical signal mapped into/out of the control program (e.g., Modbus register, OPC UA node).
Version / Snapshot
A point-in-time saved design (canvas state + assets) stored and retrievable for traceability and rollback.
Infrastructure
STORAGE + TRANSPORT.
A pragmatic stack for configuration data, snapshots, and telemetry—from local dev to deployments.
Datastores
- PostgreSQL/Timescale for configuration and relational metadata
- Redis for caching and fast access patterns
- InfluxDB and/or ClickHouse for time-series and high-volume analytics (deployment dependent)
Telemetry transport
- MQTT is a common upstream transport (Mosquitto in local stacks)
- Backend ingests and correlates telemetry with config and deployment changes
- UI receives live updates via WebSocket
Object storage
- S3-compatible storage for snapshots/assets/thumbnails
- MinIO used in local development stacks
- Keeps large blobs out of the relational database
Local stacks
- Docker Compose runs backend + runtime + dependencies
- UI can run outside Docker and proxy /api and /ws
- Edge-agent is typically run separately for end-to-end testing
Ready to modernize your control stack?
Join the engineers building the future of industrial automation.