Automatic software component selection and solution architecture generation for automation use-cases

Abstract

A system (200) for operationally configuring a computing device (114) of an automation system for a specified use-case includes a database (210) of software components represented using a data model (220, 400), wherein each software component is modeled in terms of data inlet, data outlet and provided skills, each skill solving one or more tasks. A use case representation generator (202) processes a user input to generate a use-case representation (206) modeled in terms of system components that the computing device (114) is to interact with and a task sequence executable by the computing device (114) to solve the use-case. A skill mapper (216) utilizes the use-case representation (206) to query the database (210) to select software components based on mapping of provided skills of the software components to the tasks in the task sequence. A solution architecture generator (222) uses the selected software components to build a data flow to execute the task sequence by aligning input / output interfaces of the software components.

Description

AUTOMATIC SOFTWARE COMPONENT SELECTION AND SOLUTION ARCHITECTURE GENERATION FOR AUTOMATION USE-CASESTECHNICAL FIELD

[0001] The present disclosure relates generally to automation systems, and in particular to systems, methods and computer program products for automatically selecting software components and generating a solution architecture to operationally configure a computing device (such as an Edge device) of an automation system for a specified use-case.BACKGROUND

[0002] An increasing trend in many modern-day automation systems (e.g., used in building automation, factory automation, among others) is to move toward open, ready-to-use Edge computing platforms consisting of Edge devices, Edge apps, Edge connectivity, and an application and device management infrastructure. As the catalog of Edge apps and the complexity of use-cases continue to grow, it can become increasingly challenging to navigate the catalog to determine which apps are to be used for which use-cases. The problem may be compounded, for example, with the availability of third-party apps and apps with similar functionality.SUMMARY

[0003] An object of the present disclosure is to address at least the above-mentioned technical problem via a system and a methodology for automatically selecting software components (e.g., apps) and generating a solution architecture for deployment in a computing device (e.g., an Edge device) that is scalable to support the ever-increasing number and complexity of use-cases and available software components. The disclosed methodology is based on formal representations using data models for both, the use-case, and the software components’ capabilities or “skills” , which can enable software components needed to solve a use-case to be automatically selected from a database and combined in sequence based on their offered skills.

[0004] A first aspect for the disclosure provides a system for operationally configuring a  computing device of an automation system for a specified use-case. The system comprises a first database of software components represented using a software component data model, wherein each software component is modeled in terms of data inlet, data outlet and provided skills, each skill being linked to solving one or more tasks. The system further comprises one or more processors and a non-transitory computer-readable storage medium storing computational modules executable by the one or more processors. The computational modules comprise a use case representation generator configured to process a user input specifying a use-case to generate a use-case representation modeled in terms of system components that the computing device is to interact with and a task sequence defining an ordering of tasks executable by the computing device to solve the use-case. The computation modules further comprise a skill mapper configured to utilize the use-case representation to query the first database to select software components based on a mapping of provided skills of the software components to the tasks in the task sequence. The computational modules further comprise a solution architecture generator configured to generate a solution architecture for deployment in the computing device based on building of a data flow to execute the task sequence, by assigning the selected software components to tasks in the task sequence based on the mapping in a manner such that input / output interfaces of software components assigned to consecutive tasks in the task sequence are aligned.

[0005] Further aspects of the disclosure are directed to a corresponding computer-implemented method and to a computer program product including instructions executable by a processor to carry out such a method.

[0006] Additional technical features and benefits may be realized through the techniques of the present disclosure. Embodiments and aspects of the disclosure are described in detail herein and are considered a part of the claimed subject matter. For a better understanding, refer to the detailed description and to the drawings.BRIEF DESCRIPTION OF THE DRAWINGS

[0007] The foregoing and other aspects of the present disclosure are best understood from the following detailed description when read in connection with the accompanying drawings. To easily identify the discussion of any element or act, the most significant digit or digits in a reference number refer to the figure number in which the element or act is first introduced.

[0008] FIG. 1 illustrates an Edge computing platform for an automation system wherein aspects of the disclosed methodology may be implemented.

[0009] FIG. 2 is a schematic block diagram of a system for operationally configuring an Edge device or other computing device of an automation system for a specified use-case according to a disclosed embodiment.

[0010] FIG. 3 illustrates an example of a use-case representation according to a disclosed embodiment.

[0011] FIG. 4 is a class diagram describing a knowledge graph of software components according to a disclosed embodiment.

[0012] FIG. 5 illustrates an example output of a solution architecture generator according to a disclosed embodiment.

[0013] FIG. 6 illustrates a computing system that can support operationally configuring a computing device of an automation system for a specified use-case according to disclosed embodimentsDETAILED DESCRIPTION

[0014] The exponential growth of Internet of Things (IoT) devices and data generated has made Edge computing particularly suitable for automation systems as it can meet the requirements of many real time applications by providing lower latency, higher reliability, and lower costs associated with data storage and transmission compared to remote servers or cloud infrastructure. Edge computing brings computation and data storage closer to the device where data is generated, i.e., at the edge of the network. An Edge device refers to a computing device having processing capability to realize Edge computing. Edge computing is a topology or location sensitive form of distributed computing. As such, the term “Edge” refers to an architecture rather than a specific technology.

[0015] In automation systems, data is generated from devices at a field level, which is where Edge devices may be located. An Edge device can be operationally configured to carry out an automation  use-case (e.g., in domains such as condition monitoring, predictive analytics and maintenance, fault prediction, security and safety management, etc. ) by executing modular software components (e.g., apps) which can provide integrated connectivity with the devices and the cloud infrastructure that the Edge device needs to interact with to solve the use-case.

[0016] A workflow based on a manual selection of Edge apps to solve a use-case can be engineered using expert knowhow. For example, if a customer defines a use-case (e.g., monitoring the health of specific machine) , an expert, such as an application engineer, may know what apps are relevant to that use-case. However, such a manual selection process can be error-prone, time-consuming, and difficult to scale to meet the increasing number of available apps, including third-party apps, and the complexity of the use-cases.

[0017] The disclosed methodology provides a technical advancement that can solve the above-described problem and support the increasing trend of Edge-based automation systems by automatically selecting software components and generating a solution architecture for deployment in an Edge device to solve a specified use-case. For illustrating the disclosed methodology, in the present description, a software component is exemplified as an Edge app (or simply “app” ) without loss of generality. For example, in some embodiments, the disclosed methodology can be used to select, configure and deploy plug-ins as “apps” .

[0018] FIG. 1 illustrates a non-limiting example of an Edge platform 100 for an automation system where the disclosed methodology can be implemented. The automation system can include, for example, a building automation system, a production line automation system, a process automation system, among others. The illustrated Edge platform 100 is implemented at three levels, namely at a field level 102, at a supervisory level 104 and at a cloud level 106.

[0019] At the field level 102 is an automation system, which may include at least one controller 108 connected to a number of field devices 110. For example, in the context of building automation, the field devices 110 may include actuators, HVAC sensors, metering devices, dampers, ventilation controls, pneumatic systems, etc. The controller 108 may include, for example, a programmable logic controller (PLC) or another type of industrial controller configured to control local operations of the field devices 110. The automation system may additionally include an operator interface (e.g., an HMI panel) 112 to allow an operator to monitor or control the automation system.

[0020] An Edge device 114 may provide local computing and data storage to carry out tasks according to a specified use-case. The Edge device 114 may include a runtime software layer 116 configured to deploy a number of modular applications or apps 118 that provide integrated connectivity for data exchange with various system components to solve the specified use-case. Such system components can include field level components such as the controller 108, the HMI panel 112, supervisory level components, such as an on-site server 120, as well as cloud infrastructure 122. The system components may communicate via different interfaces or protocols. The deployed apps 118 may include, for example, one or more types of protocol-specific data connectors, flow creators, analytical apps, dashboarding apps, etc. In some embodiments, the runtime software layer 116 may include a container engine, such as Docker, for deploying containerized apps. An Edge device 114 may be a dedicated computing device that is solely used for Edge computing (e.g., an industrial PC) , or an Edge enabled computing device (e.g., a PLC, an HMI panel, etc. ) in which the above-described runtime software layer 116 may be installed to activate Edge capability.

[0021] At the supervisory level 104 is an Edge management system 124. The Edge management system 124 may include an on-site computer or a virtual machine to supervise one or more automation systems and Edge devices at the field level 102. For example, the Edge management system 124 may be used to manage multiple automation systems and Edge devices at the field level 102 with a centralized app menu and admin view. Optionally, the supervisory level 104 may also include an on-site server 120.

[0022] The cloud level 106 includes cloud infrastructure 122 for storage and analysis of big data. An Edge hub 126 may provide a central access point at the cloud level 106. For example, the Edge hub 126 may provide a central portal for monitoring a number of deployed Edge management systems 124 across many geographical locations. The Edge hub 126 may also provide a central portal for purchasing apps from an app store 128. The app store 128 may include a repository of vendor-specific Edge apps, and may optionally provide a gateway for purchasing third-party apps. Apps may be purchased from the app store 128 via the Edge hub 126 and downloaded by the Edge management systems 124. Each Edge management system 124 may then distribute the apps to individual Edge devices 114.

[0023] The disclosed methodology can enable automatic selection of software components (e.g.,  apps) and generation of a solution architecture for deployment in a computing device (e.g., Edge device 114) of an automation system to solve a specified use-case, based on formal representations using data models for both, the software components and the use-case. A database of software components is created using a software component data model in which each software component is modeled in terms of data inlet, data outlet and provided skills, each skill being linked to solving one or more tasks. According to disclosed embodiments, the software components may be modeled to create a knowledge graph capturing relationships linking software components, skills and solved tasks. A use-case representation is modeled in terms of system components that the computing device is to interact with and a task sequence defining an ordering of tasks executable by the computing device to solve the use-case. The use-case representation is utilized to query the database to select software components based on mapping of provided skills of the software components to the tasks in the task sequence. A solution architecture is generated based on building of a data flow to execute the task sequence by aligning input / output interfaces of the software components.

[0024] The disclosed methodology can ensure that the generated solution architectures will be valid by design due to the automatic mapping of skills to tasks. Unlike artificial intelligence (AI) -based recommendation engines, the disclosed methodology can provide deterministic outputs, since the generated solution architectures can be “solved for” based solely on the user’s input, i.e., the same input will yield the same output solution. Furthermore, the disclosed methodology may also embed expert knowledge since the expertise required to accurately match the software capabilities to a use-case can be encoded in the data model (e.g., knowledge graph) representing the catalog software components.

[0025] The disclosed methodology is particularly suitable for, but is not limited to, an Edge computing platform, such as that shown in FIG. 1.

[0026] FIG. 2 illustrates a system 200 for operationally configuring an Edge device or other computing device of an automation system for a specified use-case according to one or more example embodiments. The various computational modules described herein, including the use-case representation generator 202, the software component modeler 212, the skill mapper 216 and the solution architecture generator 222, including components thereof, may be implemented in a computing environment in various ways, for example, as hardware and programming. The programming for the modules 202, 212, 216, 222 may take the form of processor-executable  instructions stored on non-transitory machine-readable storage mediums and the hardware for the modules may include processors to execute those instructions. The processing capability of the systems, devices, and modules described herein, including the use-case representation generator 202, the software component modeler 212, the skill mapper 216 and the solution architecture generator 222, may be distributed among multiple system components, such as among multiple processors and memories, optionally including multiple distributed processing systems or cloud / network elements.

[0027] As shown in FIG. 2, the use-case representation generator 202 is configured to process a user input specifying a use-case entered via a use-case entry interface 204 to generate a use-case representation 206 (described in FIG. 3) . In the context of the example shown in FIG. 1, the use-case entry interface 204 may include a web-based GUI provided by the Edge hub 126, which may be accessible via a remote browser, for example, by a user at the supervisory level 104 or at another location. The generated use-case representation 206 is based on a data model in which the use-case is described in terms of system components that the Edge device is to interact with and a task sequence defining an ordering of tasks executable by the Edge device to solve the use-case. In some embodiments, the task sequence in the use-case representation may be further defined in terms of a set of task-level features, including one or more boundary conditions for data imposed by the system components (e.g., implemented protocols, supported data types and formats etc. ) and / or one or more performance requirements (e.g., cycle or loop type, maximum computational load, etc. ) .

[0028] An example of a use-case representation 206 is illustrated in FIG. 3. The use-case representation 206 is based on a data model, which is represented (in part herein) as a tree 302. In the shown example, the data model 302 is defined by attributes that broadly include “use-case domain” , “requirements” , “system components” and “task sequence” . According to an example implementation, the attributes involved in the data model 302 may be described in a meta-model defined by a JavaScript Object Notation (JSON) schema.

[0029] Referring to FIG. 3, the "use-case domain” specifies a domain that points to a field of application of the use-case. For example, in the shown use-case representation, the use-case domain is condition monitoring. The “requirements” include overall performance requirements. For example, the requirements may be described by loop time and CPU load, as shown. The “system components” include all components outside of the Edge device that are necessary to solve-the use case and which impose boundary conditions for data in the task sequence. In the shown use-case  representation, the system components include a number of panels (panel 01, panel 02, panel 03) and a cloud database (cloud 01) . Though not shown herein, each system component may be further described in terms of a set of features, including available interfaces, implemented protocols or supported data types and formats which define the boundary conditions for data. Finally, the “task sequence” captures the logical ordering of operations or tasks that need to be executed by the Edge device. The tasks may be defined in terms of a task ID (e.g., task 01, task 02, etc. ) and a task description which specifies the task category (e.g., input, processing, output, etc. ) and the origins and targets of the tasks in the task sequence. The tasks may be selectable from a catalog of existing use-case tasks.

[0030] FIG. 3 also shows an example visualization of a simple task sequence 304 based on the shown data model 302. Herein, the system components are represented inside boxes and the tasks are represented inside ovals. The task descriptions appear outside the ovals for clarity. In embodiments, the tasks are represented as generically as possible at this stage (e.g., “read a datapoint from a panel” , “write data to a file” , “encryption” , “compression” , “process an image” , etc. ) so that as many viable matches as possible can be found in a software component database 210. As described hereinafter, the task-level features, including implemented protocols, supported data types, loop time, CPU load, etc. may be used to constrain the selection of software components by a skill mapper 216.

[0031] Continuing with reference to FIG. 2, in one embodiment, the use-case representation generator 202 may be configured to generate the use-case representation 206 by retrieving a template use-case representation from a database 208 of template use-case representations, based on a use-case domain specified by the user input. The template use-case representations may be created based on a use-case data model described above. The database 208 may store template use-case representations for a large number of use-case domains, such as condition monitoring, predictive analytics and maintenance, fault prediction, security and safety management, among many others. In some instances, a retrieved template may need to be modified based on additional user input to generate the final use-case representation 206. This embodiment is particularly suitable for users who are not domain experts, such as sales personnel or end customers, among others. In an alternate embodiment, the GUI of the use-case entry interface 204 may be configured to allow a user to enter every detail of the use-case, for example, in a structure defined by the shown use-case data model 302, to generate the use-case representation 206. This embodiment may be more suitable domain  experts, such as application engineers. Consistent with the disclosed implementation, the use-case representation 206 may be generated in the form a corresponding JSON object, which may be subsequently used for querying the software component database 210.

[0032] The software component database 210 is created based on a data model 220 of software components, wherein each software component is modeled in terms of data inlet, data outlet and provided skills. A skill defines, in an abstract sense, a capability of the software component, which can be linked to the solving of one or more tasks. A software component may be linked to a number of skills. In a disclosed embodiment, the data model 220 in the software component database 210 includes a knowledge graph capturing relationships linking software components, skills and solved tasks. The database 210 may be created using a software component data modeler 212 that can transform product data of the software components into such a knowledge graph.

[0033] FIG. 4 is a class diagram 400 illustrating a representative knowledge graph of software components (herein, “apps” ) according to a disclosed embodiment. In this diagram, the boxes represent classes. For example, the contents of the box 402 represent objects in the class “app” , the contents of the box 404 represent objects in the class “skill” , and so on. The dashed lines represent relationships linking the classes. In the illustrated knowledge graph, each app (class 402) is modeled in terms of data inlets &outlets, dependencies on other apps, and skills (class 404) . Each skill is modeled as a set of utilities (class 406) , each of which solves exactly one task (class 408) . The knowledge graph can be expanded as new apps are added to the database 210 and as new capabilities are added to existing apps.

[0034] As shown in FIG. 4, the linking between apps may capture dependency relationships, such as “required” and “selectable” . A first app may have a “required” relationship with second app if the second app requires the first app to be running in the Edge device as a prerequisite in order to function. On the other hand, a first app may have a “selectable” relationship with second app if the first app is typically installed together with the second app but is not necessary for the second app to function.

[0035] Furthermore, the linking between apps and skills may capture relationships such as “has inlet” , “has outlet” , “require” and “provide” . A skill linked to an app by the relationship “has inlet” is a skill that functions as data inlet of the app. An example of an inlet skill can be “read data in  Profinet protocol” . A skill linked to an app by the relationship “has outlet” is a skill that functions as data outlet of the app. An example of an outlet skill can be “publish data in MQTT protocol” . A skill linked to an app by the relationship “require” is a skill that is required by the app. For example, if an app uses data in MQTT protocol, a required skill can be “MQTT broker” , which may be provided by another app. Finally, a skill linked to an app by the relationship “provide” is a skill provided or offered by the app as a service. For a given app, the inlet skill collection, outlet skill collection, required skill collection and provided skill collection may not be mutually exclusive. For example, a provided skill of an app can be an inlet skill or an outlet skill of the app. However, a provided skill cannot be a required skill of the same app.

[0036] The illustrated knowledge graph further includes a linking between apps and data properties (class 412) . The data properties may define, for example, a collection of data types, hardware, language and supported modes associated with the app. The data properties linked to the apps may be used to constrain the selection of apps by the skill mapper 216.

[0037] As a further feature, the knowledge graph may also include a linking between skills and solved use-case domains. As shown in FIG. 4, the illustrated knowledge graph includes a link from each utility associated with a skill to its solved use-case domains (class 410) . The linking of skills to use-case domains may be useful for example, for traceability and visibility into product and capability usage. Furthermore, such a linking may provide additional context to select a solution architecture between a plurality of solution architectures output by a solution architecture generator 222.

[0038] Referring back to FIG. 2, according to a disclosed embodiment, the product data of the software components utilized for creating the software component database 210 may be entered by a user via a software component data entry interface 214. In the context of the example shown in FIG. 1, the software component data entry interface 214 may include a web-based GUI provided by the Edge hub 126, which may be accessible via a remote browser by a user, such as a product owner or developer of a software component, to enter the skill information and data properties of the software component as required by the data model of the knowledge graph 220. The knowledge graph 220 may be created based on skills from a catalog of known skills and their linked tasks. The GUI may be developed using such a catalog, to enable a user to enter skill information by selecting from a list of skills. The catalog may list skills by categories, for example under a main category and a sub- category, which can be used to aid data entry via the GUI. In another embodiment, the product data may be extracted automatically from product-related documentations, such as product manuals or other entries, for example, using natural language processing driven free text parsing algorithms. The extracted skill or capability information may then be semantically processed to match the catalog of known skills with linked tasks to create the knowledge graph 220.

[0039] In one embodiment, the catalog of skills with linked tasks may be curated to match the catalog of use-case tasks used for creating the use-case representation 206. For example, the skill “Profinet I / O” may be linked to the task “read datapoint from PLC” in the catalog of skills, which may also match an entry in the catalog of use-case tasks. This approach may be useful to realize a simple text-based matching by the skill mapper 216. The catalog of use-case tasks may include known use-case tasks across a number of use-case domains.

[0040] The software component data modeler 212 is configured to create the knowledge graph 220 using product data of the software components, which may be obtained as described above. The product data of each software component may be created, for example, as a JSON object. The software component data modeler 212 may be configured to convert the JSON objects corresponding to a number of software components into a knowledge graph 220 represented in a standard information model, such Resource Description Framework (RDF) . In various embodiments, the knowledge graph 220 may be represented using other standard information models, which may be aligned with industry 4.0, and which can further be enhanced for automation requirements (e.g., with runtime interface definitions) .

[0041] Still referring to FIG. 2, the skill mapper 216 is configured to utilize the generated use-case representation 206 for querying the software component database 210 to retrieve a list of selected software components 218, based on a mapping of provided skills of the software components in the database 210 to the tasks in the task sequence defined in the use-case representation 206. The function of the skill mapper 216 is thus to extract a subset of the software components from the database 210, which can perform any one (or more) of the tasks in the task sequence of the specified use-case. This is helpful in limiting the search space for the solution architecture generator 222 in creating a valid data flow in a latter step.

[0042] According to a disclosed embodiment, the skill mapper 216 may perform an initial  selection of software components from the database 210 based on a text-based matching of tasks solved by software components’ skills to tasks in the task sequence of the use-case representation 206. A simple text-based matching may be facilitated by ensuring that the catalog of skills with linked tasks used for creating the database 210 exactly matches the catalog of use-case tasks used for creating the use-case representation 206, from which the tasks in the task sequence are selected. In a next step, the skill mapper 216 may refine the initial selection by performing a secondary mapping between the task-level features of the use-case representation 206 (e.g., implemented protocols, supported data types, performance requirements, etc. ) and the data properties linked to the software components selected by the initial text-based matching. These steps may ensure that only those software components which can perform the required tasks under the constraints or boundary conditions for data imposed by the specified use-case are considered in the final generated solution architecture.

[0043] In some embodiments, the skill mapper 216 may be configured to notify missing skills, for example, by visually highlighting tasks that cannot be achieved by any software component in the database 210, or by mapping dummy software components to such tasks as placeholders.

[0044] The solution architecture generator 222 is configured to generate a solution architecture 224 for deployment in the Edge device 114 by stitching together software components, from the list of selected software components 218, in order to build a data flow to execute the task sequence of the use-case representation 206. A data flow may be established by assigning software components from the list 218 to tasks in the task sequence based on the mapping by the skill mapper 216, in a manner such that input / output interfaces of software components assigned to consecutive tasks in the task sequence are aligned. As described above, as per the disclosed methodology, each software component is modeled with data inlets and data outlets. 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 a next task in the task sequence, these two software components can be connected, such that the data flow is from the output of the first software component to the input of the next software component. A solution architecture 224 is generated as an output when at least one valid data flow for the entire task sequence is established. The output may additionally include a software component Bill of Materials (BOM) 226, which may be generated by reading off a list of software components that are utilized to generate the solution architecture 224.

[0045] According to one embodiment, the input / output interfaces to be aligned are defined by a data protocol. Additionally, or alternately, the aligned input / output interfaces may be defined by a data type. Thus, according to disclosed embodiment, establishing of a data flow by the solution architecture generator 222 may include matching a protocol and / or datatype of a data output of a software component assigned to a task in the task sequence to a protocol and / or datatype of a data input of another software component assigned to a next (adjacent) task in the task sequence.

[0046] FIG. 5 illustrates an example output 500 of a solution architecture generator 222 according to disclosed embodiments, which includes at least one solution architecture 224 and a corresponding BOM 226. As shown, the solution architecture 224 is created using a number of apps (App A, App B, App C, App D, App E and App F) that are stitched together to establish a data flow for the entire task sequence in the use-case representation 206. The apps (App A, App B, App C, App D, App E and App F) can be selected from a list of apps 218 generated by the skill mapper 216. The solution architecture 224 may also include apps providing “required” skills to the selected apps. The data flow is established by assigning apps to use-case tasks based on the mapping of app skills to the use-case tasks. An app may be assigned to multiple use-case tasks if it can provide the skills linked to those use-case tasks. Also, a given use-case task in the task sequence may be solved by more than one app. In that case, a different data flow may be created branching out from each of those alternatives. In this manner, multiple valid data flows may be generated and output as multiple recommended solution architectures with corresponding BOMs. When no valid data flow can be established, the solution architecture generator 222 may be configured to visually highlight tasks that cannot be connected sequentially due to a missing app interface.

[0047] To aid a user to select a solution architecture out of multiple choices, each app in the list 218 may be provided with a rating score in terms of one or more of: popularity, price, performance, relevance to use-case domain, etc. As each app’s scores are accumulated over time, this may provide the user some mechanisms to differentiate between different technically viable solution architectures.

[0048] When a solution architecture has been determined for deployment in the Edge device 114, configuration files may automatically be generated for each required app in the solution architecture. In the context of the example shown in FIG. 1, the deployed solution architecture may be executed by the Edge device 114 via the runtime software layer 116 as modularized apps 118 providing device connectivity to the system components and operational capability for carrying out the task  sequence.

[0049] FIG. 6 shows an example of a computing system 600 that can support operationally configuring a computing device of an automation system for a specified use-case according to disclosed embodiments. The computing system 600 may be implemented as part of a cloud infrastructure, as shown in FIG. 1. The computing system 600 includes at least one processor 610, which may take the form of a single or multiple processors. The processor (s) 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 comprising a machine-readable medium. The computing system 600 further 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, as shown in FIG. 6. As such, the machine-readable medium 620 may be, for example, Random Access Memory (RAM) such as a dynamic RAM (DRAM) , flash memory, spin-transfer torque memory, an Electrically-Erasable Programmable Read-Only Memory (EEPROM) , a storage drive, an optical disk, and the like.

[0050] The computing system 600 may execute instructions stored on the machine-readable medium 620 through the processor (s) 610. Executing the instructions (e.g., the use-case representation generation instructions 622, the software component data modeling instructions 624, the skill mapping instructions 626 and the solution architecture generation instructions 628) may cause the computing system 600 to perform any of the technical features described herein, including according to any of the features of the use-case representation generator 202, the software component modeler 212, the skill mapper 216 and the solution architecture generator 222 described above.

[0051] The systems, methods, devices, and logic described above, including the use-case representation generator 202, the software component modeler 212, the skill mapper 216 and the solution architecture generator 222, may 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) , or may be implemented with discrete logic or components, or a combination 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, which when executed in an endpoint, computer system, or other device, cause the device to perform operations according to any of the description above, including according to any features of the use-case representation generator 202, the software component modeler 212, the skill mapper 216 and the solution architecture generator 222. Computer readable program instructions described herein can be downloaded to respective computing / processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and / or a wireless network.

[0052] The processing capability of the systems, devices, and modules described herein, including the use-case representation generator 202, the software component modeler 212, the skill mapper 216 and the solution architecture generator 222, may be distributed among multiple system components, such as among multiple processors and memories, optionally including multiple distributed processing systems or cloud / network elements. Parameters, databases, and other data structures may be separately stored and managed, may be incorporated into a single memory or database, may be logically and physically organized in many different ways, and may be implemented in many ways, including data structures such as linked lists, hash tables, or implicit storage mechanisms. Programs may be parts (e.g., subroutines) of a single program, separate programs, distributed across several memories and processors, or implemented in many different ways, such as in a library (e.g., a shared library) .

[0053] Although this disclosure has been described with reference to particular embodiments, it is to be understood that the embodiments and variations shown and described herein are for illustration purposes only. Modifications to the current design may be implemented by those skilled in the art, without departing from the scope of the patent claims.

Claims

1.A system (200) for operationally configuring a computing device (114) of an automation system for a specified use-case, comprising:a first database (210) of software components represented using a software component data model (220, 400) , wherein each software component is modeled in terms of data inlet, data outlet and provided skills, each skill being linked to solving one or more tasks,one or more processors (610) and a non-transitory computer-readable storage medium (620) storing computational modules executable by the one or more processors (610) , the computational modules comprising:a use case representation generator (202) configured to process a user input specifying a use-case to generate a use-case representation (206) modeled in terms of system components that the computing device (114) is to interact with and a task sequence defining an ordering of tasks executable by the computing device (114) to solve the use-case,a skill mapper (216) configured to utilize the use-case representation (206) to query the first database (210) to select software components based on a mapping of provided skills of the software components to the tasks in the task sequence, anda solution architecture generator (222) configured to generate a solution architecture (224) for deployment in the computing device (114) based on building of a data flow to execute the task sequence, by assigning the selected software components to tasks in the task sequence based on the mapping in a manner such that input / output interfaces of software components assigned to consecutive tasks in the task sequence are aligned.2.The system (200) according to claim 1, wherein the computing device (114) is an Edge device comprising a runtime software layer (116) configured to execute the deployed solution architecture as modularized applications (118) providing device connectivity to the system components and operational capability for carrying out the task sequence.3.The system (200) according to any of claims 1 and 2, wherein the task sequence in the use-case representation (206) is further defined in terms of a set of task-level features, including one or more boundary conditions for data imposed by the system components and / or one or more performance requirements.4.The system (200) according to any of claims 1 and 3, wherein the use-case representation generator (202) is configured to generate the use-case representation (206) , at least in part, by retrieving a template use-case representation from a second database (208) of template use-case representations, based on a use-case domain specified by the user input.5.The system (200) according to any of claims 1 to 4, wherein the software component data model (220, 400) comprises a knowledge graph capturing relationships linking software components, skills and solved tasks.6.The system (200) according to claim 5, wherein, in the knowledge graph, linking between software components capture dependency relationships, which include one or more of: required software component and selectable software component.7.The system (200) according to any of claims 5 and 6, wherein, in the knowledge graph, linking between software components and skills capture relationships including: skill provided by software component, skill required by software component, skill functioning as data inlet of software component and skill functioning as data outlet of software component.8.The system (200) according to any of claims 5 to 7, wherein the knowledge graph further comprises linking between skills and use-case domains.9.The system (200) according to any of claims 1 to 8, wherein the computational modules further comprise a software component data modeler (212) configured to create the software component data model (220, 400) using product data of the software components.10.The system (200) according to any of claims 1 to 9, wherein software component data model (220, 400) is created using a catalog of skills with linked tasks that match a catalog of use-case tasks used for creating the use-case representation (206) , from which the tasks in the task sequence are selected.11.The system (200) according to any of claims 3 to 10, wherein the skill mapper (216) is configured to:perform an initial selection of software components from the first database (210) based on a text-based matching of tasks solved by software component skills to tasks in the task sequence of the use-case representation (206) , andrefine the initial selection by performing a secondary mapping between the task-level features and data properties linked to the software components selected by the text-based matching.12.The system (200) according to any of claims 1 to 11, wherein the solution architecture generator (222) is configured to align input / output interfaces of software components by matching a protocol and / or datatype of a data output of a first software component assigned to a first task in the task sequence to a protocol and / or datatype respectively of a data input of a second software component assigned to a second task next to the first task in the task sequence.13.The system (200) according to any of claims 1 to 12, wherein the solution architecture generator (222) is configured to generate multiple solution architectures (224) with valid data flows.14.A computer-implemented method for operationally configuring a computing device (114) of an automation system for a specified use-case, the method comprising:processing a user input specifying a use-case to generate a use-case representation (206) modeled in terms of system components that the computing device (114) is to interact with and a task sequence defining an ordering of tasks executable by the computing device (114) to solve the use-case,utilizing the use-case representation (206) to query a database (210) of software components represented using a software component data model (220, 400) , wherein each software component is modeled in terms of data inlet, data outlet and provided skills, each skill being linked to solving one or more tasks, wherein the database (210) is queried to select software components based on a mapping of provided skills of the software components to the tasks in the task sequence, andgenerating a solution architecture (224) for deployment in the computing device (114) based on building of a data flow to execute the task sequence, by assigning the selected software components to tasks in the task sequence based on the mapping in a manner such that input / output interfaces of software components assigned to consecutive tasks in the task sequence are aligned.15.A non-transitory computer-readable storage medium including instructions that, when processed by a computing system, configure the computing system to perform the method according to claim 14.

Images