Automatic software component selection and solution architecture generation for automated use cases
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2023-09-15
- Publication Date
- 2026-04-14
Smart Images
Figure CN121866538A_ABST
Abstract
Description
Technical Field
[0001] This disclosure generally relates to automation systems, and more particularly to systems, methods, and computer program products for automatically selecting software components and generating solution architectures to operationally configure automation systems for specified use cases. Background Technology
[0002] In many modern automation systems (such as those used for building automation and factory automation), a growing trend is towards open, ready-to-use edge computing platforms comprised of edge devices, edge applications, edge connectivity, and application and device management infrastructure. As the catalogue and use cases of edge applications continue to grow in complexity, navigating the catalogue to determine which applications are used for which use cases can become increasingly challenging. For example, the problem may be exacerbated by the availability of third-party applications and applications with similar functionality. Summary of the Invention
[0003] The purpose of this disclosure is to address at least the aforementioned technical problems through a system and method for automatically selecting software components (e.g., applications) and generating a solution architecture for deployment in computing devices (e.g., edge devices) that can scale to support an increasing number of use cases and the number and complexity of available software components. The disclosed method is based on a formal representation using a data model of both the capabilities or "skills" of use cases and software components. This allows the software components required to solve the use cases to be automatically selected from a database and sequentially combined based on the skills they provide.
[0004] A first aspect of this disclosure provides a system for operationally configuring a computing device for an automated system for specified use cases. The system includes a first database of software components represented using a software component data model, wherein each software component is modeled according to data ingress, data egress, and provided skills, and each skill is linked to solving one or more tasks. The system also includes one or more processors and a non-transitory computer-readable storage medium storing a computing module executable by the one or more processors. The computing module includes a use case representation generator configured to process user input for specified use cases to generate use case representations modeled according to system components with which the computing device will interact and a sequence of tasks that define an order of tasks that the computing device can execute to solve the use cases. The computing module includes a skill mapper configured to query the first database using the use case representations to select software components based on the mapping of provided skills of the software components to tasks in the task sequence. The computing module also includes a solution architecture generator, which is configured to generate a solution architecture for deployment in a computing device by assigning selected software components to tasks in a task sequence based on a mapping, such that the input / output interfaces of the software components assigned to successive tasks in the task sequence are aligned.
[0005] Another aspect of this disclosure relates to a corresponding computer-implemented method and a computer program product including instructions executable by a processor to perform such a method.
[0006] Additional technical features and benefits can be achieved through the technology disclosed herein. Embodiments and aspects of this disclosure are described in detail herein and are considered part of the claimed subject matter. For a better understanding, reference is made to the specific embodiments and accompanying drawings. Attached Figure Description
[0007] The foregoing and other aspects of this disclosure can be best understood from the following detailed description when read in conjunction with the accompanying drawings. For ease of identification of any element or action being discussed, the highest digit or a plurality of highest digits in the reference numerals denote the figure number in which the element or action is first introduced.
[0008] Figure 1 An edge computing platform for an automated system is shown, in which aspects of the disclosed methods can be implemented.
[0009] Figure 2 It is a schematic block diagram of an edge device or other computing device for operationally configuring an automation system for a specified use case, according to the disclosed embodiments.
[0010] Figure 3Examples of use case representations based on the disclosed implementation are shown.
[0011] Figure 4 It is a class diagram that describes a knowledge graph of software components according to the disclosed implementation.
[0012] Figure 5 An exemplary output of a solution architecture generator according to the disclosed implementation is shown.
[0013] Figure 6 A computing system is shown that, according to the disclosed embodiments, can support the operational configuration of an automation system for specified use cases. Detailed Implementation
[0014] The exponential growth of Internet of Things (IoT) devices and the data they generate makes edge computing particularly well-suited for automation systems. Compared to remote servers or cloud infrastructure, edge computing can meet the requirements of many real-time applications by offering lower latency, higher reliability, and lower costs associated with data storage and transmission. Edge computing brings computation and data storage closer to the devices that generate the data, i.e., at the edge of the network. Edge devices are computing devices with the processing capabilities to enable edge computing. Edge computing is a form of topology- or location-sensitive distributed computing. Therefore, the term "edge" refers to the architecture rather than a specific technology.
[0015] In automation systems, data is generated from field-level devices, where edge devices may be located. Edge devices can be operationally configured to perform automation use cases (e.g., in areas such as condition monitoring, predictive analytics and maintenance, fault prediction, security and safety management, etc.) by executing modular software components (e.g., applications). These modular software components can provide integrated connectivity with the devices and cloud infrastructure that the edge devices need to interact with to resolve use cases.
[0016] Workflows based on manually selecting edge applications to resolve use cases can be designed using expert knowledge. For example, if a customer defines a use case (e.g., monitoring the health of a specific machine), experts (such as application engineers) can know which applications are relevant to that use case. However, such a manual selection process can be error-prone, time-consuming, and difficult to scale to accommodate the increasing number of available applications, including third-party applications, and the complexity of use cases.
[0017] The disclosed method provides a technological advancement that addresses the aforementioned problems by automatically selecting software components and generating solution architectures for deployment on edge devices to solve specific use cases, thus supporting the growing trend of edge-based automated systems. For the purpose of illustrating the disclosed method, software components are exemplified in this specification as edge applications (or simply "applications") without loss of generality. For example, in some implementations, the disclosed method can be used to select, configure, and deploy plugins as "applications".
[0018] Figure 1 A non-limiting example of an edge platform 100 for implementing the disclosed methods in an automation system is shown. The automation system may include, for example, building automation systems, production line automation systems, process automation systems, etc. The edge platform 100 shown is implemented in three levels (i.e., field level 102, monitoring level 104, and cloud level 106).
[0019] At the field level 102 is an automation system, which may include at least one controller 108 connected to multiple field devices 110. For example, in the context of building automation, field devices 110 may include actuators, HVAC sensors, metering devices, dampers, ventilation controls, pneumatic systems, etc. Controller 108 may include, for example, a programmable logic controller (PLC) or another type of industrial controller configured to control the local operation of field devices 110. The automation system may additionally include an operator interface (e.g., an HMI panel) 112 to allow operators to monitor or control the automation system.
[0020] Edge device 114 can provide local computing and data storage to perform tasks according to specified use cases. Edge device 114 may include a runtime software layer 116 configured to deploy multiple modular applications or applications 118, which provide integrated connectivity for exchanging data with various system components to solve specified use cases. Such system components may include field-level components (such as controller 108, HMI panel 112), monitoring-level components (such as field server 120), and cloud infrastructure 122. System components may communicate via different interfaces or protocols. Deployed applications 118 may include, for example, one or more types of protocol-specific data connectors, stream creators, analytics applications, dashboard applications, etc. In some embodiments, runtime software layer 116 may include a container engine, such as Docker, for deploying containerized applications. Edge device 114 may be a dedicated computing device for edge computing only (e.g., an industrial PC), or an edge-enabled computing device (e.g., a PLC, HMI panel, etc.) in which the aforementioned runtime software layer 116 can be installed to activate edge capabilities.
[0021] At monitoring level 104 is an edge management system 124. Edge management system 124 may include a field computer or virtual machine for monitoring one or more automation systems and edge devices at field level 102. For example, edge management system 124 may be used to manage multiple automation systems and edge devices at field level 102 using a centralized application menu and management view. Optionally, monitoring level 104 may also include a field server 120.
[0022] Cloud-level 106 includes cloud infrastructure 122 for big data storage and analysis. Edge center 126 can provide a central access point for cloud-level 106. For example, edge center 126 can provide a central portal for monitoring multiple deployed edge management systems 124 across many geographic locations. Edge center 126 can also provide a central portal for purchasing applications from app store 128. App store 128 may include a repository of vendor-specific edge applications and may optionally provide a gateway for purchasing third-party applications. Applications can be purchased from app store 128 via edge center 126 and downloaded by edge management system 124. Each edge management system 124 can then distribute the application to various edge devices 114.
[0023] The disclosed method enables the automatic selection of software components (e.g., applications) based on formal representations using data models for both software components and use cases, and the generation of solution architectures for deployment in computing devices (e.g., edge device 114) within an automated system to solve specified use cases. A database of software components is created using a software component data model, in which each software component is modeled according to data ingress, data egress, and provided skills, with each skill linked to solving one or more tasks. According to the disclosed implementation, software components can be modeled to create a knowledge graph capturing the relationships between linked software components, skills, and solved tasks. Use case representations are modeled according to system components with which the computing device interacts and task sequences that define the tasks that can be executed by the computing device to solve use cases. The database is queried using the use case representations to select software components based on the mapping of provided skills of the software components to tasks in the task sequence. A solution architecture is generated based on the data flow used to execute the task sequence by aligning the input / output interfaces of the software components.
[0024] The disclosed method ensures that the generated solution architecture will be effective in the design due to the automatic mapping of skills to tasks. Unlike artificial intelligence (AI)-based recommendation engines, the disclosed method can provide deterministic outputs because the generated solution architecture can be "solved" solely based on user input—that is, the same input will produce the same output solution. Furthermore, the disclosed method can also embed expert knowledge, as the expertise required to accurately match software capabilities with use cases can be encoded in a data model representing the catalog software components (e.g., a knowledge graph).
[0025] The disclosed methods are particularly suitable for, but not limited to, edge computing platforms, such as... Figure 1 The edge computing platform shown in the image.
[0026] Figure 2 A system 200 for operationally configuring an automation system for specified use cases is illustrated, according to one or more exemplary embodiments. Various computing modules described herein, including use case representation generator 202, software component modeler 212, skill mapper 216, and solution architecture generator 222 (including components thereof), can be implemented in various ways in a computing environment, e.g., as hardware and programming. Programming of modules 202, 212, 216, and 222 can take the form of processor-executable instructions stored on a non-transitory machine-readable storage medium, and the hardware for the modules can include a processor for executing these instructions. The processing power of the systems, devices, and modules described herein (including use case representation generator 202, software component modeler 212, skill mapper 216, and solution architecture generator 222) can be distributed among multiple system components, such as distributed among multiple processors and memories, optionally including multiple distributed processing systems or cloud / network elements.
[0027] like Figure 2 As shown, the use case representation generator 202 is configured to process user input for a specified use case input via the use case input interface 204 to generate a use case representation 206 (in... Figure 3 (As described in the text). Figure 1In the context of the illustrated example, the use case input interface 204 may include a web-based GUI provided by edge center 126, accessible via a remote browser, for example, by a user at monitoring level 104 or at another location. The generated use case representation 206 is based on a data model, wherein the use cases are described according to the system components with which the edge device interacts and a sequence of tasks that define the tasks that the edge device can perform to resolve the use cases. In some implementations, the sequence of tasks in the use case representation may be further defined according to a set of task-level characteristics, including one or more boundary conditions imposed on the data by system components (e.g., implemented protocols, supported data types and formats, etc.) and / or one or more performance requirements (e.g., loop or cycle type, maximum computational load, etc.).
[0028] Example of use case representation 206 in Figure 3 As shown in the example, use case representation 206 is based on a data model, which is (partially) represented as tree 302 in this document. In the example shown, data model 302 is defined by attributes that broadly include "use case domain," "requirements," "system components," and "task sequences." Depending on the exemplary implementation, the attributes involved in data model 302 can be described in a metamodel defined by a JavaScript Object Notation (JSON) schema.
[0029] refer to Figure 3 The “Use Case Domain” specifies the domain in which the use case applies. For example, in the use case representation shown, the use case domain is status monitoring. “Requirements” include overall performance requirements. For example, requirements can be described by loop time and CPU load, as shown in the figure. “System Components” includes all components outside the edge device that are necessary to resolve the use case and impose boundary conditions on the data in the task sequence. In the use case representation shown, system components include multiple panels (Panel 01, Panel 02, Panel 03) and a cloud database (Cloud 01). Although not shown in this document, each system component can also be described by a set of characteristics, including available interfaces, implemented protocols, or supported data types and formats that define the boundary conditions of the data. Finally, the “Task Sequence” captures the logical order of operations or tasks that need to be performed by the edge device. Tasks can be defined by task IDs (e.g., Task 01, Task 02, etc.) and task descriptions that specify the task category (e.g., input, processing, output, etc.) and the origin and goal of the tasks in the task sequence. Tasks can be selected from an existing catalog of use case tasks.
[0030] Figure 3An exemplary visualization of a simple task sequence 304 based on the illustrated data model 302 is also shown. In this document, system components are represented within boxes, and tasks are represented within ellipses. For clarity, task descriptions appear outside the ellipses. In the implementation, tasks at this stage are represented as generally as possible (e.g., “read data points from a panel,” “write data to a file,” “encrypt,” “compress,” “process an image,” etc.) so that as many feasible matches as possible can be found in the software component database 210. As described below, task-level characteristics (including implemented protocols, supported data types, loop times, CPU load, etc.) can be used to constrain the skill mapper 216's selection of software components.
[0031] Continue to refer to Figure 2 In one implementation, the use case representation generator 202 can be configured to generate use case representation 206 by retrieving template use case representations from a database 208 of template use case representations, based on a use case domain specified by user input. The template use case representations can be created based on the use case data model described above. Database 208 can store template use case representations for a large number of use case domains, such as status monitoring, predictive analytics and maintenance, fault prediction, security and safety management, etc. In some instances, the retrieved templates may need to be modified based on additional user input to generate the final use case representation 206. This implementation is particularly suitable for non-domain expert users, such as sales personnel or end customers. In an alternative implementation, the GUI of the use case input interface 204 can be configured to allow users to input every detail of the use case, for example, within the structure defined by the illustrated use case data model 302, to generate use case representation 206. This implementation may be more suitable for domain experts, such as application engineers. Consistent with the disclosed implementation, use case representation 206 can be generated as a corresponding JSON object and subsequently used to query the software component database 210.
[0032] The software component database 210 is created based on a data model 220 of software components, where each software component is modeled according to data ingress, data egress, and provided skills. Skills define, in an abstract sense, the capabilities of a software component, which can be linked to the resolution of one or more tasks. A software component can be linked to multiple skills. In the disclosed implementation, the data model 220 in the software component database 210 includes a knowledge graph capturing the relationships linking software components, skills, and resolved tasks. The database 210 can be created using a software component data modeler 212, which can transform the product data of the software components into such a knowledge graph.
[0033] Figure 4Class diagram 400 illustrates a representative knowledge graph of a software component (referred to herein as an "application") according to the disclosed implementation. In this diagram, boxes represent classes. For example, the contents of box 402 represent objects in the "Application" class, the contents of box 404 represent objects in the "Skill" class, and so on. Dashed lines represent relationships linking classes. In the knowledge graph shown, each application (class 402) is modeled according to data ingress and egress, dependencies on other applications, and skills (class 404). Each skill is modeled as a set of utilities (class 406), where each utility solves exactly one task (class 408). The knowledge graph can be expanded as new applications are added to database 210 and as new features are added to existing applications.
[0034] like Figure 4 As shown, links between applications can capture dependencies, such as "required" and "optional." If a second application requires the first application to run on an edge device as a prerequisite for its operation, then the first and second applications can have a "required" relationship. On the other hand, if the first application is typically installed with the second application but is not essential for the second application to function, then the first and second applications can have an "optional" relationship.
[0035] Furthermore, the links between applications and skills can capture relationships such as "has an entry point," "has an exit point," "required," and "provided." A skill linked to an application via an "has an entry point" relationship is a skill that acts as a data entry point for that application. An example of an entry point skill could be "reading data using the Profinet protocol." A skill linked to an application via an "has an exit point" relationship is a skill that acts as a data exit point for that application. An example of an exit point skill could be "publishing data using the MQTT protocol." A skill linked to an application via a "required" relationship is a skill required by that application. For example, if an application uses data using the MQTT protocol, a required skill could be "MQTT broker," which could be provided by another application. Finally, a skill linked to an application via a "provided" relationship is a skill that the application provides or gives as a service. For a given application, the sets of entry point skills, exit point skills, required skills, and provided skills do not necessarily have to be mutually exclusive. For example, a provided skill of an application could be either an entry point skill or an exit point skill of that application. However, a provided skill may not be a required skill of the same application.
[0036] The knowledge graph also includes links between applications and data attributes (class 412). Data attributes can define, for example, the set of data types, hardware, language, and supported patterns linked to the application. Data attributes linked to applications can be used to constrain the skill mapper 216's selection of applications.
[0037] As another feature, knowledge graphs can also include links between skills and solved use case domains. For example... Figure 4 As shown, the knowledge graph includes links from each utility linked to a skill to its solved use case domain (class 410). These skill-to-use case domain links can be useful, for example, for traceability and visibility of product and capability usage. Furthermore, such links can provide additional context for selecting a solution architecture among multiple solution architectures output by the solution architecture generator 222.
[0038] refer to Figure 2 According to the disclosed implementation, product data of software components used to create the software component database 210 can be input by the user via the software component data input interface 214. Figure 1 In the context of the illustrated example, the software component data input interface 214 may include a web-based GUI provided by edge center 126, accessible via a remote browser by a user (such as the product owner or developer of the software component) to input skill information and data attributes of the software component required by the data model of knowledge graph 220. Knowledge graph 220 may be created based on skills and their linked tasks from a known skills catalog. The GUI can be developed using such a catalog to allow users to input skill information by selecting from a list of skills. The catalog may list skills by category, such as under main and subcategories, which can be used to assist data entry via the GUI. In another embodiment, product data may be automatically extracted from product-related documents (such as product manuals or other entries), for example, using a free text parsing algorithm driven by natural language processing. The extracted skill or ability information may then undergo semantic processing to match the known skills catalog with linked tasks, thereby creating knowledge graph 220.
[0039] In one implementation, a skill catalog with linked tasks can be organized to match a use case task catalog used to create use case representation 206. For example, the skill "Profinet I / O" can be linked to the task "Read data points from PLC" in the skill catalog, which can also match entries in the use case task catalog. This approach can be used to implement simple text-based matching for skill mapper 216. The use case task catalog can include known use case tasks across multiple use case domains.
[0040] Software component data modeler 212 is configured to create knowledge graph 220 using product data of software components, which can be obtained as described above. Product data for each software component can be created, for example, as a JSON object. Software component data modeler 212 can be configured to convert JSON objects corresponding to multiple software components into knowledge graph 220 represented using a standard information model, such as a Resource Description Framework (RDF). In various implementations, knowledge graph 220 can be represented using other standard information models that are aligned with Industry 4.0 and can be further enhanced for automation needs (e.g., utilizing runtime interface definitions).
[0041] Still referencing Figure 2 Skill mapper 216 is configured to query software component database 210 using the generated use case representation 206 to retrieve a list 218 of selected software components based on the mapping of provided skills of software components in database 210 to tasks in a task sequence defined in use case representation 206. Therefore, the function of skill mapper 216 is to extract a subset of software components from database 210 that can perform any one (or more) of the tasks in the task sequence of the specified use case. This helps limit the search space of solution architecture generator 222 when creating an effective data flow in subsequent steps.
[0042] According to the disclosed implementation, skill mapper 216 can perform an initial selection of software components from database 210 based on a text-based match between tasks solved by software component skills and tasks in the task sequence of use case representation 206. Simple text-based matching is facilitated by ensuring a perfect match between the skill catalog with linked tasks used to create database 210 and the use case task catalog used to create use case representation 206, where tasks in the task sequence are selected from the use case task catalog. In a next step, skill mapper 216 can refine the initial selection by performing a secondary mapping between task-level characteristics of use case representation 206 (e.g., implemented protocols, supported data types, performance requirements, etc.) and data attributes linked to the software components selected by the initial text-based matching. These steps ensure that only those software components that can perform the necessary tasks under the constraints or boundary conditions imposed on the data by the specified use cases are considered in the final generated solution architecture.
[0043] In some implementations, the skill mapper 216 may be configured to notify of missing skills, for example, by visually highlighting tasks that cannot be performed by any software component in the database 210, or by mapping virtual software components to such tasks as placeholders.
[0044] Solution architecture generator 222 is configured to generate solution architecture 224 for deployment in edge device 114 by concatenating software components from a list 218 of selected software components to construct a data flow for a task sequence that performs use case representation 206. The data flow can be established by assigning software components from list 218 to tasks in the task sequence via mapping based on skill mapper 216, such that the input / output interfaces of software components assigned to consecutive tasks in the task sequence are aligned. As described above, according to the disclosed method, each software component is modeled as having a data inlet and a data outlet. Two software components can be connected when the data output of a software component assigned to a task in the task sequence matches the data input of another software component assigned to the next task in the task sequence, such that the data flow flows from the output of the first software component to the input of the next software component. Solution architecture 224 is generated as output when at least one valid data flow is established for the entire task sequence. The output may additionally include a software component bill of materials (BOM) 226, which can be generated by reading the list of software components used to generate solution architecture 224.
[0045] According to one implementation, the input / output interfaces to be aligned are defined by a data protocol. Alternatively, the aligned input / output interfaces may be defined by data types. Therefore, according to the disclosed implementation, establishing a data flow by the solution architecture generator 222 may include matching the protocol and / or data type of the data output of a software component assigned to a task in a task sequence with the protocol and / or data type of the data input of another software component assigned to an adjacent (adjacent) task in the task sequence.
[0046] Figure 5An exemplary output 500 of a solution architecture generator 222 according to a disclosed implementation is shown, which includes at least one solution architecture 224 and a corresponding BOM 226. As shown, the solution architecture 224 is created using multiple applications (application A, application B, application C, application D, application E, and application F) that are concatenated together to establish a data flow for the entire task sequence in use case representation 206. Applications (application A, application B, application C, application D, application E, and application F) can be selected from a list 218 of applications generated by skill mapper 216. Solution architecture 224 may also include applications that provide “required” skills to the selected applications. The data flow is established by assigning applications to use case tasks based on a mapping of application skills to use case tasks. If an application can provide skills linked to multiple use case tasks, then that application can be assigned to those use case tasks. Moreover, a given use case task in the task sequence can be solved by more than one application. In this case, different data flows branching off from each of those alternatives can be created. In this way, multiple valid data streams can be generated and output as multiple recommended solution architectures with corresponding BOMs. When a valid data stream cannot be established, the solution architecture generator 222 can be configured to visually highlight tasks that cannot be connected sequentially due to the lack of application interfaces.
[0047] To help users choose a solution architecture from multiple options, each application in List 218 can be rated based on one or more of the following: popularity, price, performance, relevance to use case domain, etc. As each application's score accumulates over time, this provides users with some mechanisms to differentiate between different technically viable solution architectures.
[0048] Once the solution architecture for deployment in edge device 114 is determined, configuration files can be automatically generated for each required application within the solution architecture. Figure 1 In the context of the example shown, the deployed solution architecture can be executed by the edge device 114 via the runtime software layer 116 as a modular application 118 that provides device connectivity to system components and the operational capabilities for executing task sequences.
[0049] Figure 6 An example of a computing system 600, according to the disclosed embodiments, is shown that can support the operational configuration of an automated system for a specified use case. The computing system 600 can be implemented as part of a cloud infrastructure, such as... Figure 1As shown in the diagram. The computing system 600 includes at least one processor 610, which may take the form of a single processor or multiple processors. The processor 610 may include a central processing unit (CPU), a graphics processing unit (GPU), a neural processing unit (NPU), a microprocessor, or any hardware device suitable for executing instructions stored on a memory including a machine-readable medium. The computing system 600 also includes a machine-readable medium 620. The machine-readable medium 620 may take the form of any non-transitory electronic, magnetic, optical, or other physical storage device that stores executable instructions, use case representation generation instructions 622, software component data modeling instructions 624, skill mapping instructions 626, and solution architecture generation instructions 628, such as... Figure 6 As shown. Therefore, for example, machine-readable medium 620 can be random access memory (RAM) such as dynamic RAM (DRAM), flash memory, spin-transfer torque memory, electrically erasable programmable read-only memory (EEPROM), storage drive, optical disc, etc.
[0050] The computing system 600 can execute instructions stored on the machine-readable medium 620 via the processor 610. Executing the instructions (e.g., use case representation generation instruction 622, software component data modeling instruction 624, skill mapping instruction 626, and solution architecture generation instruction 628) can cause the computing system 600 to perform any of the technical features described herein, including any features of the use case representation generator 202, software component modeler 212, skill mapper 216, and solution architecture generator 222 as described above.
[0051] The systems, methods, devices, and logic described above (including use case representation generator 202, software component modeler 212, skill mapper 216, and solution architecture generator 222) can be implemented in many different ways in many different combinations of hardware, logic, circuitry, and executable instructions stored on a machine-readable medium. For example, these modules may include circuitry in a controller, a microprocessor, or an application-specific integrated circuit (ASIC), and may be implemented with discrete logic or components, or combinations of other types of analog or digital circuitry, combined on a single integrated circuit or distributed among multiple integrated circuits. A product (such as a computer program product) may include a storage medium and machine-readable instructions stored on the medium that, when executed in an endpoint, computer system, or other device, cause the device to perform any of the operations described above, including any features of use case representation generator 202, software component modeler 212, skill mapper 216, and solution architecture generator 222. The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to a corresponding computing / processing device, or downloaded via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network) to an external computer or external storage device.
[0052] The processing power of the systems, devices, and modules described herein (including the use case representation generator 202, software component modeler 212, skill mapper 216, and solution architecture generator 222) can be distributed across multiple system components, such as across multiple processors and memories, optionally including multiple distributed processing systems or cloud / network elements. Parameters, databases, and other data structures can be stored and managed separately, can be merged into a single memory or database, can be logically and physically organized in many different ways, and can be implemented in many ways, including data structures such as linked lists, hash tables, or implicit storage mechanisms. Programs can be parts of a single program (e.g., subroutines), standalone programs, distributed across multiple memories and processors, or implemented in many different ways, such as in libraries (e.g., shared libraries).
[0053] Although this disclosure has been described with reference to specific embodiments, it should be understood that the embodiments and variations shown and described herein are for illustrative purposes only. Those skilled in the art can make modifications to the present design without departing from the scope of the claims of this patent.
Claims
1. A system (200) for operationally configuring a computing device (114) of an automation system for specified use cases, comprising: The first database (210) of software components is represented by a software component data model (220, 400), wherein each software component is modeled according to data entry, data exit and provided skills, and each skill is associated with solving one or more tasks; One or more processors (610) and a non-transitory computer-readable storage medium (620) storing a computing module executable by the one or more processors (610), the computing module comprising: A use case representation generator (202) is configured to process user input for a specified use case to generate a use case representation (206), which is modeled according to the system components that the computing device (114) will interact with and a sequence of tasks that are ordered to be executed by the computing device (114) to resolve the use case; Skill mapper (216) is configured to query the first database (210) using the use case representation (206) to select a software component based on the mapping of the provided skills of the software component to the tasks in the task sequence; and A solution architecture generator (222) is configured to assign selected software components to tasks in the task sequence based on the mapping, such that the input / output interfaces of the software components assigned to successive tasks in the task sequence are aligned, thereby generating a solution architecture (224) for deployment in the computing device (114) based on the data stream used to execute the task sequence.
2. The system (200) according to claim 1, wherein, The computing device (114) is an edge device including a runtime software layer (116) configured to execute the deployed solution architecture as a modular application (118) that provides device connectivity to the system components and the ability to perform the sequence of tasks.
3. The system (200) according to any one of claims 1 and 2, wherein, The task sequence in the use case representation (206) is also defined according to a task-level feature group, which includes one or more performance requirements and / or one or more boundary conditions imposed on the data by the system components.
4. The system (200) according to any one of claims 1 and 3, wherein, The use case representation generator (202) is configured to generate the use case representation (206) by retrieving template use case representations from a second database (208) of template use case representations, based at least in part on the use case domain specified by the user input.
5. The system (200) according to any one of claims 1 to 4, wherein, The software component data model (220, 400) includes a knowledge graph that captures the relationships between linked software components, skills, and solved tasks.
6. The system (200) according to claim 5, wherein, In the knowledge graph, the links between software components capture dependencies, which include one or more of the following: required software components and optional software components.
7. The system (200) according to any one of claims 5 and 6, wherein, In the knowledge graph, the links between software components and skills capture the following relationships: skills provided by software components, skills required by software components, skills that act as data entry points for software components, and skills that act as data exit points for software components.
8. The system (200) according to any one of claims 5 to 7, wherein, The knowledge graph also includes links between skills and use case domains.
9. The system (200) according to any one of claims 1 to 8, wherein, The computing module also includes a software component data modeler (212) configured to create a software component data model (220, 400) using product data of the software component.
10. The system (200) according to any one of claims 1 to 9, wherein, The software component data model (220, 400) is created using a skill catalog with linked tasks, which is matched with a use case task catalog used to create the use case representation (206), and the tasks in the task sequence are selected from the use case task catalog.
11. The system (200) according to any one of claims 3 to 10, wherein, The skill mapper (216) is configured as follows: Based on the text-based matching of the tasks solved by the software component skills with the tasks in the task sequence of the use case representation (206), an initial selection of software components from the first database (210) is performed; as well as The initial selection is refined by performing a secondary mapping between task-level features and data attributes linked to the software components selected through the text-based matching.
12. The system (200) according to any one of claims 1 to 11, wherein, The solution architecture generator (222) is configured to align the input / output interfaces of software components by matching the protocol and / or data type of the data output of the first software component assigned to the first task in the task sequence with the protocol and / or data type of the data input of the second software component assigned to the second task in the task sequence adjacent to the first task.
13. The system (200) according to any one of claims 1 to 12, wherein, The solution architecture generator (222) is configured to generate multiple solution architectures (224) with effective data flow.
14. A computer-implemented method for operationally configuring a computing device (114) of an automation system for specified use cases, the method comprising: User input for a specified use case is processed to generate a use case representation (206), which is modeled according to the system components that the computing device (114) will interact with and a sequence of tasks that are ordered to be executed by the computing device (114) to resolve the use case; The use case representation (206) is used to query a database (210) of software components represented using a software component data model (220, 400), wherein each software component is modeled according to data ingress, data egress, and provided skills, and each skill is linked to solving one or more tasks, wherein the database (210) is queried to select a software component based on the mapping of the provided skills of the software component to the tasks in the task sequence; and By assigning selected software components to tasks in the task sequence based on the mapping, the input / output interfaces of the software components assigned to successive tasks in the task sequence are aligned, thereby generating a solution architecture (224) for deployment in the computing device (114) based on the data flow constructed for executing the task sequence.
15. A non-transitory computer-readable storage medium comprising instructions that, when processed by a computing system, configure the computing system to perform the method of claim 14.