Event-Driven Runtime for Distributed Function Block Synchronization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The complexity of designing application programs for automation systems is exacerbated by dependencies between function blocks and the need for synchronization, particularly in distributed control systems that require event-driven execution.
Innovation Solution
A runtime environment is configured to execute function blocks event-drivenly when their respective trigger events occur, utilizing an event executor and memory resources to store and manage events and data for each function block, ensuring efficient data and event transfer between blocks.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If function blocks share global memory for state storage, then ease of operation is improved, but device complexity increases due to synchronization requirements
Solution Approach 1:
The patent segments the global memory space into separate instance memory spaces for each function block. Each function block has its own dedicated memory region where it stores its state variables, eliminating the need for shared global memory and the complex synchronization mechanisms that would be required to manage concurrent access to shared resources.
2Reliability
If data is transferred after each potential change in shared memory, then reliability is improved, but productivity decreases due to bandwidth consumption and CPU utilization
Solution Approach 1:
The patent extracts the data transfer mechanism from the continuous shared memory model and implements it within the discrete event framework. Data is only transferred when an event occurs that triggers a state change, rather than continuously monitoring and transferring data after every potential change. This reduces unnecessary data transfers and improves system productivity while maintaining reliability through event-driven updates.
3Productivity
If event-driven execution is implemented, then productivity is improved, but device complexity increases due to encapsulation requirements
Solution Approach 1:
The patent merges the event-driven execution model with the function block architecture by integrating event handling directly into the function block instance structure. Each function block instance has its own event queue and executes algorithms in response to events, combining the productivity benefits of event-driven execution with the modular function block approach without requiring separate complex encapsulation mechanisms.
Data Source
AI summary
A runtime environment for execution of an event driven control program for a distributed control system including one or multiple computing resources, wherein the control program includes at least two function blocks. The runtime environment includes for each computing resource an event executor which is configured for execution of sets of events and respective associated data on the respective computing resource. And wherein the runtime environment includes for each function block a memory resource, which memory resource is configured to: store a set of events and associated data for each function block if the data is produced by the function block; and/or store a reference to a set of events and associated data for each function block if the data is consumed by the function block.