Skill-based engineering is a term used in automation research for a couple of approaches trying to describe machines and their functionalities as skills. Semantic Web Technologies like ontologies using the Web Ontology Language (OWL) are seen as a promising solution to create such descriptions in a machine-readable and vendor-neutral way. But using OWL models places high demands on machine engineers and software developers involved in developing a machine. In addition to programming the machine behavior - which has to be done anyway - they have to provide an interface to invoke this machine behavior and they have to create an ontological description for this interface. This leads to many challenges: There are very few ontology experts in automation industry and these tasks are both tedious and error-prone when done manually. This is where Skill-Up comes into play.
Skill-Up is a Java-framework which can be used to develop machine skills without any additional effort. You can implement your machine behavior as plain Java classes only adding a few annotations, everything else will be generated automatically. In a bit more detail, these things that are generated are:
- A state machine according to ISA 88 containing your behavior. The state machine makes sure the behavior is only executed in the right state.
- An invocation interface (either via RESTful webservices or OPC UA) which can be used to interact with the state machine (trigger commands, get current state)
- An ontological description of the state machine and the invocation interface. This description can be consumed by other systems that want to interact with a machine.
Skill-Up is based on this Machine Capability and Skill Model. For more details about the model, please visit this repository. SkillUp is best used in combination with SkillMEx which is also available on Github: https://github.com/aljoshakoecher/SkillMEx
SkillUp distinguishes between modules (i.e., machines that may provide skills) and skills (i.e., machine functionality that is provided by a module and can be executed). In order to develop your own modules and skills, all you need to do is create a Maven project and import the following dependency in order to use the necessary annotations:
<dependency>
<groupId>io.github.aljoshakoecher.skillup</groupId>
<artifactId>skillup.annotations</artifactId>
<version>2.0.3</version>
</dependency>
After building a module or skill, you can deploy both inside a SkillUp runtime.
@Module
is the only annotation that is needed in order to decorate a module class. It is a class annotation that accepts two arguments
moduleIri
: This IRI will be used for the module individual when creating the semantic descriptioncapabilityIri
(optional): Currently not useddescription
(optional): A human-readable description of this module
@Skill
is a class annotation which is mandatory in order to mark your class as a skill. It is needed by Skill-Up to get notified about a newly deployed skill in a SkillUp runtime.
You can pass in additional arguments to @Skill
:
skillIri
: This IRI will be used for the skill individual when creating the semantic descriptioncapabilityIri
: IRI of the capability that this skill is able to executemoduleIri
: IRI of the module that this skill belongs to. Important: A skill can only be activated if a module bundle is already deployedtype
: This is used to specify the implementation of a skill. A class extendingSkillType
has to be passed as a value. Currently, there are only two possible candidates:OpcUaSkillType
(for skills implemented via OPC UA) andRestSkillType
(for skills implemented as web services).description
(optional): A human-readable description of this skill
This is a field annotation that can be used to mark certain fields as parameters of your skill. Specifying fields as @SkillParameter
creates an interface to change these parameters at runtime when the skill is used. This annotation accecpts arguments:
name
(optional): Typically, the variable name will be used when creating the semantic skill mode. This argument can be used to use a different name in the model.description
(optional): A human-readable description of this skillisRequired
: Specifies whether or not this parameter has to be set on skill invocationsoption
(optional): A string array of possible options. Can be used in case a parameter should only accept certain values.
@SkillOutput
is another field annotation that defines which fields will be returned by the skill. Note that skill execution is asynchronous and that other systems can get result information when a skill is completed. This annotation accecpts arguments:
name
(optional): Typically, the variable name will be used when creating the semantic skill mode. This argument can be used to use a different name in the model.description
(optional): A human-readable description of this skillisRequired
(optional): Specifies whether or not this parameter has to be set on skill invocations
Together with @Skill
these annotations are important to create a functioning skill. There is a total of 11 annotations in this group that represent so-called active states of the ISA 88 state machine. These annotations have to be placed in front of a method. Using these annotations makes sure that this method is executed in the corresponding state of the ISA 88 state machine.
- @Aborting: Ensures that the method following this annotation is executed in Aborting state
- @Clearing: Ensures that the method following this annotation is executed in Clearing state
- @Completing: Ensures that the method following this annotation is executed in Completing state
- @Execute: Ensures that the method following this annotation is executed in Execute state
- @Holding: Ensures that the method following this annotation is executed in Holding state
- @Resetting: Ensures that the method following this annotation is executed in Resetting state
- @Starting: Ensures that the method following this annotation is executed in Starting state
- @Stopping: Ensures that the method following this annotation is executed in Stopping state
- @Suspending: Ensures that the method following this annotation is executed in Suspending state
- @Unholding: Ensures that the method following this annotation is executed in Unholding state
- @Unsuspending: Ensures that the method following this annotation is executed in Unsuspending state
Build your module and skill classes as OSGi bundles and fire up your SkillUp runtime. You can then deploy a module by dropping the according bundle into the include-directory of your SkillUp runtime. Skill-Up will pick up the module and register it to SkillMEx.
After deploying a module, you can deploy skills of that module (i.e., with the same moduleIri
). SkillUp will pick up every skill and register it to SkillMEx from where skills can be executed.
Skill-Up is implemented as a collection of OSGi bundles that create a runtime in which modules and skills can be deployed dynamically. A preconfigured SkillUp-Runtime (i.e. an OSGi container running certain necessary bundles as well as Skill-Up) is provided with the releases. You can use this preconfigured runtime on a machine's controller and manage (add, start, stop) skills while others are running.
If you want to setup your own OSGi container to be used as a runtime for SkillUp, you need to compile all the bundles of SkillUp. This is best done by executing a mvn install
from the project root. Furthermore, the dependencies of the SkillUP bundles are needed. A list of required bundles will be provided soon.
Check out the example module and skills in the examples folder to see an example module and different skills. The latest release also has a pre-built version of these examples that are ready to be used. Feel free to create an issue if you have questions.
🚧 The way SkillUp works will be explained soon 🚧
We are excited about everyone using SkillUp in their own applications. If you use SkillUp in research, please consider giving credit by citing the following paper that initially introduced SkillUp:
@inproceedings{KHC+_AutomatingtheDevelopmentof_2020,
author = {Köcher, Aljosha and Hildebrandt, Constantin and Caesar, Birte and Bakakeu, Jupiter and Peschke, Joern and Scholz, Andre and Fay, Alexander},
title = {{Automating the Development of Machine Skills and their Semantic Description}},
pages = {1013--1018},
publisher = {IEEE},
isbn = {978-1-7281-8956-7},
booktitle = {{2020 25th IEEE International Conference on Emerging Technologies and Factory Automation (ETFA)}},
year = {9/8/2020 - 9/11/2020},
doi = {10.1109/ETFA46521.2020.9211933},
shorthand = {KHC+20}
}