Event-Driven Runtime Environment for Distributed Function Block Sync
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Designing application programs for automation systems is complex due to dependencies between function blocks and synchronization requirements, particularly in distributed control systems that require event-driven execution.
Innovation Solution
A runtime environment that executes function blocks event-driven when their respective trigger events occur, using an event executor for each computing resource, with instance memory to store and manage events and data, and data structures to handle event and data connections between function blocks, ensuring efficient data transfer and synchronization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If function blocks use shared global memory to store state, then access flexibility is improved, but data integrity and synchronization complexity worsen
Solution Approach 1:
The patent segments the shared global memory into instance-specific memory spaces, where each function block instance has its own dedicated memory region. This segmentation isolates data access, eliminating the need for complex synchronization mechanisms while maintaining access flexibility. Each instance can independently read/write its own memory without affecting other instances.
Solution Approach 2:
The patent introduces an instance memory as an intermediary layer between the function block algorithm and the global memory system. This intermediary encapsulates the state data, providing controlled access through well-defined interfaces. The instance memory acts as a buffer that manages data flow between multiple function blocks without requiring direct synchronization of global memory accesses.
2Manufacturing precision
If function blocks execute in scan cycles, then deterministic timing is improved, but event responsiveness worsens
Solution Approach 1:
The patent implements a dynamic execution model where function blocks can execute both periodically (for deterministic timing) and event-driven (for responsiveness). The system dynamically switches between scan-cycle execution and event-triggered execution based on the specific function block and its operational context. Events can trigger immediate execution outside the regular scan cycle, ensuring timely response while maintaining periodic synchronization for deterministic behavior.
Solution Approach 2:
The patent maintains periodic scan cycles for functions requiring deterministic timing while supplementing them with event-driven triggers. The periodic execution ensures that all function blocks are systematically updated in a predictable sequence, while event triggers can initiate immediate execution when specific conditions occur, combining the benefits of both periodic and event-driven approaches.
3Loss of information
If data is transferred after each potential change, then data freshness is improved, but bandwidth consumption and CPU utilization worsen
Solution Approach 1:
The patent implements a feedback mechanism where the system monitors data change events and only triggers transfers when actual changes occur. The instance memory tracks the state of data, and transfer operations are initiated based on feedback from event triggers rather than continuous polling. This feedback-driven approach ensures data freshness by transferring updates promptly while avoiding unnecessary transfers that would consume bandwidth and CPU resources.
Solution Approach 2:
The patent enables function blocks to self-manage their data transfer needs through event-driven mechanisms. When a function block's output changes, it automatically generates an event that triggers the necessary data transfer without requiring external intervention or continuous monitoring. This self-service approach ensures that data is transferred when needed (maintaining freshness) while minimizing unnecessary transfers (reducing bandwidth and CPU consumption).
Data Source
Figure 1A~1C
Figure 2
Figure 3A~3B
AI summary
The invention relates to a runtime environment for execution of an event driven control program for a distributed control system comprising one or multiple computing resources, wherein the control program comprises at least two function blocks. The runtime environment comprises 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.