Smart Object Binding for Multi-Controller Industrial IDE Projects
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current industrial control program development platforms require initial binding to a specific industrial controller, limiting flexibility and scalability, as they support a one-to-one relationship between the control project and the controller, making it inflexible for scenarios where hardware implementation is unknown or when scaling control programs across multiple controllers.
Innovation Solution
An integrated development environment (IDE) system that allows decoupled development of industrial control programs by defining and storing them as smart objects, which can be assigned to selected industrial controllers later, enabling a one-to-many relationship and facilitating reuse across multiple automation systems.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a control project is bound to a single industrial controller at the early stage of development, then the project structure is simple and easy to manage, but the flexibility and scalability are limited when needing to deploy to multiple controllers
Solution Approach 1:
The control program is segmented into a smart object definition that can be independently developed and stored, separate from the controller definition. This allows the control logic to be reused across multiple controllers by creating instances of the smart object definition and binding them to different controllers, resolving the contradiction between simple project structure and deployment flexibility.
Solution Approach 2:
The smart object definition serves as a template that can be copied and instantiated multiple times, each instance bound to a different controller. This copying mechanism enables scalable deployment across multiple controllers while maintaining a single source of truth for the control program, achieving both structural simplicity and adaptability.
2Ease of manufacture
If a control project is bound to a single industrial controller, then the development workflow is straightforward, but the scalability to multiple controllers is poor
Solution Approach 1:
The control program is developed and stored as a smart object definition in advance, before being bound to any specific controller. This preliminary action allows the control logic to be fully developed and tested independently, and then efficiently deployed to multiple controllers by creating instances and binding them, thereby maintaining straightforward development while improving scalability.
Solution Approach 2:
The smart object definition is designed to be universal and controller-agnostic, capable of being bound to multiple different controller definitions. This multi-functionality allows a single control program definition to serve multiple controllers with different configurations, enhancing scalability without complicating the development workflow.
3Reliability
If control programs are developed for specific controllers, then the control logic is optimized for hardware, but the reuse across different controllers is limited
Solution Approach 1:
The smart object definition acts as an intermediary layer between the control logic and the specific controller hardware. This intermediary allows the control program to be developed with hardware optimization considerations while remaining abstract enough to be instantiated for multiple different controller types, thereby maintaining reliability through optimization while enabling reuse across different hardware platforms.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
An industrial integrated development environment (IDE) supports decoupled development of industrial control programs without requiring the programs to be initially bound to a specific industrial controller. The IDE system allows industrial control programs to be defined as smart objects within an industrial control project. These smart objects can be created without an initial binding to an industrial controller, and can subsequently be assigned to selected industrial controllers after development of the control programs is complete, or while program development is in progress. A smart object can be reused and deployed to multiple industrial controllers, providing a simple means to implement common control functionality on multiple different automation systems. To allow for deployment of smart objects to selected controllers, the IDE system supports creation of a control project having a one-to-many relationship with industrial controllers, such that multiple controllers can be defined within a single project.