To edit the states and transitions you can use the properties view. It has an integrated Xtext support. This makes correct editing easier. You can also change the appearance of the model elements.
On the palette you will also find a composite submachine state. This is a state that contains a complete statemachine. You can choose an existing statemachine or create a new one.
Statemachine Elements reference
Textual modeling lanuage Reference
The statemachine is validated automatically during build. The elements that cause problems get error markers. You can find the details about the problems on the problems view.
The YAKINDU simulation engine supports simulation modes:
The default setting is cycle based with a cycle period of 200 ms. In this mode the simulation engine processes the state machine transitions in steps of the given cycle duration. The following statechart illustrates this. It is simulated cycle based with a cycle period of 3 seconds.
What happend during simulation is the following:
In contrast to cycle based the event driven simulation mode concentrates on the events of a state machine. The same state machine above could be simulated as follows:
Start a simulation with the different modes as follows
Simulation Concept
Simulation perspective
Simulation View
For configuring the code generation process, YAKINDU Statechart Tools uses a textual generator model called
SGen. It can be created either by using the provided wizard
Yakindu Statechart Generator Model or by creating a new text file with the file extension ‚.sgen’.
To create a generator model with the wizard,
The result is an .sgen file of the following format:
GeneratorModel for [GeneratorId] {
statechart [StatechartReference] {
feature [Feature] {
[ParameterName] = [ParameterValue]
}
}
}
The [GeneratorId] is the unique id of the Generator. Currently, the following Generators are supported out of the box:
One GeneratorModel can contain several [StatechartReference]s. These are cross references to statechart models for which the code should be generated. For each reference, the generator process can be configured with [Feature]s. Each Feature consists of several parameters. These parameters can be configured with [ParameterName] = [ParameterValue].
The Generator Model is executed by a builder. Thus, the artifacts are generated automatically if Project > Build Automatically is checked. If you want to execute your Generator Model by hand, select Generate Statechart Artifacts from the Package Explorer’s context menu.
The following section describes the Core Features which are available for all code generators:
The Outlet feature specifies the target project and folder for the generated artifacts. It is a required feature and consists of the following parameters:
Example configuration:
feature Outlet {
targetProject = "ExampleProject"
targetFolder = "src-gen"
}
The LicenseHeader feature specifies the license text that should be added as a header to the generated artifacts. It is an optional feature and consists of the following parameters:
Example configuration:
feature LicenseHeader {
licenseText = "Copyright (c) 2012 committers of YAKINDU and others."
}
The
FunctionInlining feature allows the inlining of expressions instead of generating separate functions or methods. This might reduce the readability of the generated code, but increases performance because less operation calls are necessary.
It is an
optinal feature and consists of the following parameters:
Example configuration:
feature FunctionInlining {
inlineChoices = false
inlineEnterRegion = true
inlineEntries = true
}
The Debug feature dumps the Execution Model to the target folder as xmi model. It is an optional feature and consists of the following parameters:
Example configuration:
feature Debug {
dumpSexec = true
}
The
Naming feature allows the configuration of package names as well as class name prefix / suffix.
It is an
optional feature and consists of the following parameters:
Example configuration:
feature Naming {
basePackage = "org.yakindu.sct"
implementationSuffix = "Impl"
}
The GeneralFeatures feature allows to configure additional services to generate with the statemachine. Per default, all parameters are configured to false It is an optional feature and consists of the following parameters:
Example configuration:
feature GeneralFeatures {
EventBasedStatemachine = true
InterfaceObserverSupport = true
RuntimeService = true
TimerService = true
GenericInterfaceSupport = true
StatemachineFactorySupport = true
}
The CCodeFeature feature allows to configure c code specific generator properties. It is an optional feature and consists of the following parameters:
Example configuration:
feature CCodeFeature {
InterfaceEventListerner = true
Singleton = true
}
YAKINDU Statechart Tools provides a rich feature set to supports custom code generators out of the box. These code generators can be either written in Java, Xtend or in Xpand
First, you have to create a new Xtend2 generator project. Click File > New > Other... > YAKINDU > YAKINDU Xtend2/Java Generator Project to create a new Xtend2 Generator Project.
The wizards asks for a Project name and the name of the Generator class, where you have to specify a full qualified class name. If you check the Use Xtend checkbox, the Generator class will be initially created as an Xtend class. Otherwise, Java will be used for the generator.
The check box Configure for Plugin Export adds all required extension point registrations to the new project for exporting as a plugin The Generator Model can refer to the new Generator Plugin via its unique Generator ID. If you want to contribute custom generator features for your code generator, check the Create Feature Library check box.
After click on Finish a new project is created in your workspace. All required plugin dependencies and extension points are registered and you can start to write your code generator based on the ExecutionFlow meta model [Link].
YAKINDU Statechart Tools provide a convenient way to execute your generator while you are developing it.
Therefore, you have to create a new
Generator Model with the generator id
yakindu::generic, either by using the
New Statechart Generator Model wizard or by simple creating a new text file with the file extension
.sgen. the following feature allows to configure your code generator.
The Generator feature allows the configuration of a custom code generator located in the workspace and written in Java or another JVM language. It is a required feature and consists of the following parameters:
Example configuration:
feature Generator {
generatorProject = "org.yakindu.sct.mygenerator"
generatorClass = "org.yakindu.sct.MyGenerator"
}
to execute an xpand based custom code generator, you have to create a new Generator Model with the generator id yakindu::xpand, either by using the New Statechart Generator Model wizard or by simple creating a new text file with the file extension .sgen. the following feature allows to configure your code generator.
The Generator feature allows the configuration of a custom code generator located in the workspace and written in Java or another JVM language. It is a required feature and consists of the following parameters:
Example configuration:
feature Template {
templateProject = "ExampleProject"
templatePath = "org::yakindu::sct::generator::xpand::Main::main"
}