Industrial Module Arbitration via Unique Identifier Resource Manager
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Industrial module class components often compete for shared resources, requiring custom arbitration code and leading to increased time and costs in preparing industrial processes for production, due to timing and synchronization issues.
Innovation Solution
Implementing arbitration functionality within modules using unique identifiers to manage access to shared resources, allowing for hierarchical arbitration schemes that reduce the need for custom arbitration coding and mitigate synchronization problems.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If custom arbitration code is constructed for each module to manage access to shared resources, then resource access control is achieved, but device complexity and overhead costs increase
Solution Approach 1:
The patent introduces a resource manager as an intermediary component that handles arbitration for shared resources. Instead of embedding custom arbitration code in each module, the resource manager centrally manages access requests from multiple equipment modules, simplifying individual module design while maintaining reliable resource control.
Solution Approach 2:
The resource manager provides a universal arbitration mechanism that serves multiple equipment modules competing for the same shared resource. This single multi-functional component replaces numerous custom arbitration codes, reducing overall system complexity while maintaining access control reliability.
2Adaptability or versatility
If custom arbitration code is tailored for each shared resource, then specific resource access requirements are met, but manufacturing time and overhead costs increase
Solution Approach 1:
The resource manager is designed as a universal component that can handle different types of shared resources (valves, sensors, actuators) through a standardized interface. This eliminates the need to craft custom arbitration code for each resource, significantly reducing production preparation time while maintaining adaptability to specific resource requirements.
Solution Approach 2:
The system uses configurable parameters and identifiers to adapt the universal resource manager to specific resource requirements. By changing parameters such as resource IDs, priority levels, and access rules rather than rewriting arbitration code, the system maintains versatility while easing manufacturing and deployment.
3Productivity
If arbitration code is implemented with multiple modules competing for shared resources, then resource allocation is achieved, but timing and synchronization problems arise
Solution Approach 1:
The resource manager acts as a centralized mediator that sequentially processes access requests from multiple equipment modules. This centralized coordination eliminates timing and synchronization problems that arise from distributed arbitration, ensuring that only one module accesses the shared resource at a time while maintaining high productivity through efficient request handling.
Solution Approach 2:
The system implements feedback mechanisms where the resource manager tracks the state of shared resources and communicates availability status to requesting modules. This feedback loop ensures proper synchronization by informing modules when resources become available, preventing conflicts while maintaining continuous productivity.
Data Source
AI summary
Arbitrating access to industrial resources as a function of controller identify is provided herein. For example, a unique identifier can be associated with a control module that can distinguish the module from other components of a system. Upon receiving a request to control a resource, the identifier of the requesting module can be associated with that resource. In a case of multiple requests, an arbitrated ID can be chosen and added to an owner queue. The chosen ID is then published and, if the published identifier matches the module identifier, the module can assume control of the resource; if not, the module's request is placed into a request queue for further arbitration. The subject innovation provides for generally applicable arbitration that can reduce redundant code crafted for each module of a system, greatly reducing overhead costs associated with such redundancy.