Five-minutes tutorial

The five-minutes tutorial gives you a brief introduction into modeling state machines with itemis CREATE by a simple example. It models a light switch, which has the states on and off. Operating the switch repeatedly turns the light on, off, back on again, and so forth. You can simulate this behavior in a dynamic statechart model (state machine model). Here’s how it looks like:

Interactive light switch statechart simulation

In the simulation screenshot above, the light switch is currently in the on state. To toggle the light switch, the user clicks on operate on the right-hand side of the window.

Importing light switch example

Now try this for yourself. We are assuming that you have already installed and started itemis CREATE. If you don’t, please see the Installation Guide for details.

1. If the “Welcome” page is still open, close it.

   

2. In the main menu, select File → New → Example….
3. In the dialog, select itemis CREATE Statechart Examples, then click Next >.
4. The example wizard opens. If needed, follow the instructions to download the examples repository.
5. On the left-hand side of the example wizard, select Basic Tutorial, then click Finish.
6. The sample project named org.yakindu.sct.examples.basic.tutorial is created.
7. In the project explorer on the left-hand side of the window, open the org.yakindu.sct.examples.basic.tutorial project by clicking on the small triangle left on the left of the project name (“org.yakindu.sct.examples.basic.tutorial”). Open the model folder and the 01_basic folder.

   

8. The light switch statechart is defined in the file 01_lightSwitch.ysc. Double-click on this file to open the model.

Simulating the light switch

1. Right-click on 01_lightSwitch.ysc and select Run As → Statechart Simulation in the context menu.
2. The simulation starts and shows the light switch model in its off state. The rectangle named Off is highlighted in yellow, meaning it is the active state.

   

1. At the right side of the window, the simulation view is located. In this view, you can change variable values and raise events during a simulation run. Click on the small triangle left from default to unfold the switch link. This link represents the switch event to switch the light on or off.

   

2. Click on the switch link. The active state changes accordingly from Off to On.

   

3. Click on switch again to switch off the light.

Generating statechart code

You have developed and tested your statechart model, and now you need it as a C, C++, or Java implementation? itemis CREATE can create it for you.

As an example, we will take the light switch statechart and generate Java source code from it. Please proceed as follows:

1. In the project explorer, right-click on 01_lightSwitch.ysc and select New → Code generator model in the context menu.

   

2. In the dialog, replace Statechart.sgen by light_switch.sgen, then click Next >.
3. In the next dialog, check the checkbox left from 01_lightSwitch.ysc under the 01_basic folder, then click Finish.
4. Java classes implementing the statechart model are generated. You can find the generated source code in the folders src and src-gen.

   

That’s it. If you want to know more, take the time and work through the Comprehensive Tutorial.

Comprehensive tutorial

This tutorial introduces itemis CREATE which provides an integrated modeling environment for the specification and development of reactive, event-driven systems based on the concepts of Finite State Machines (FSM) and Harel Statecharts. It is an easy-to-use tool featuring sophisticated graphical statechart editing, validation and simulation of statecharts as well as code generation for C, C++, or Java.

This tutorial will teach you how to

• create a new statechart model, and
• execute it using the simulation engine.

Please note that this tutorial will not explain statecharts in general, so you should familiarize yourself with the basic concepts of state machines first, see UML state machine.

In order to get a fully-working state machine implementation that you can integrate with your project, you will have to familiarize yourself with code generation, which is covered by chapter Code generation in this documentation. You can generate your state machine implementation as source code in C, C++, and Java out of the box. Alternatively, you can write your own code generator for other programming languages or for other purposes.

Before we get started, make sure you have itemis CREATE installed. For installation instructions, see the itemis CREATE Installation Guide.

The light switch example

The most basic example of a state machine that actually does something is a light switch. In this scenario there is a light bulb and a switch to turn the bulb on and off. Of course there’s also a power source and some electrical cabling to put it all together, but for the purpose of our model we can omit them.

The behavior of a light switch

When modeling the light switch example as a statechart, we can disregard everything (even the bulb) except for the switch. The behavior of the switch is very simple:

• Initially the light switch is off, i.e., it is in its Off state.
• If the light switch is operated while being in its Off state, it changes to its On state.
• If the light switch is operated while being in its On state, it changes to its Off state.

Modeling the light switch as a statechart

Now let’s model the light switch as a statechart using itemis CREATE. This involves the following steps:

1. Creating an Eclipse project. It will serve as a container for the statechart model.
2. Modeling the light switch using the itemis CREATE editor. The result will be a static statechart model.
3. Simulating the model. We can play around with the model, operate the light switch and observe its behavior.

Creating an Eclipse project

The first step is to create a new Eclipse project that can serve as a container for our model. From the main menu, select File → New → Project...:

Selecting File → New → Project... in the main menu

The New Project wizard opens, showing a couple of different project types structured in various folders.

The New Project wizard

Select General → Project and click Next >.

The wizard shows its next page:

Specifying project name and location

Specify a meaningful Project name, e. g. LightSwitch, and optionally select a Location to create the project in.

Click Finish.

Eclipse creates the new project:

Project LightSwitch created

Creating a folder for the model

Now that we have created the Eclipse project, we can establish the statechart model of the light switch. It is good practice to use a separate directory for models, so let’s create a new folder called model.

Right-click on the project’s root, i.e., on LightSwitch, then select New → Folder from the context menu.

Selecting New → Folder in the context menu

The New Folder wizard opens:

The New Folder wizard

Give the model folder a reasonable name, e. g. model, and type it into the Folder Name text field. Then click Finish.

The new model folder is created and appears in the Project Explorer view at the left.

Starting with an empty statechart model

Using the itemis CREATE Statechart wizard

Now we are going to create an empty statechart model in the model folder. Right-click on the model folder and select New → Other in the context menu:

Selecting New → Other in the context menu

The New wizard opens. Select itemis CREATE → Statechart model

Selecting itemis CREATE → Statechart model

Click Next >. The wizard shows the New itemis CREATE Statechart dialog:

The New itemis CREATE Statechart dialog

The dialog asks you for the project, the directory, and the name of the model file to be created. Eclipse project and directory should be preset correctly already. In our case the corresponding text field contains LightSwitch/model which means the directory named model is in the LightSwitch project. If you want, you can change the preset values.

The default file name in the File Name field is Statechart.ysc, however. You should change that to something more meaningful. In our case we type LightSwitch.sct into the File name field, see the screenshot above.

Click Next.

In the next dialog, in the dropdown menu you can select the domain you want to create a statechart for. A short description helps you to decide for the right domain for you, depending on your needs. In this example, the Default Domain is selected.

Click Finish.

Since there’s a dedicated perspective for statechart models, Eclipse asks you whether you want to change to it now or not:

Dialog Confirm Perspective Switch

Please answer the question regarding switching to the itemis CREATE Modeling perspective by clicking on the Yes button. The itemis CREATE Modeling perspective has a graphical editor for statechart models, and you will need it to create and modify them. On the other hand your answer really doesn’t matter that much, because you can switch perspectives at any time. If you check Do not offer to switch perspective in the future before clicking Yes, Eclipse will never ask this question again, at least regarding the itemis CREATE Modeling perspective.

Please note: If the Confirm Perspective Switch dialog does not appear as described above you probably have already confirmed Do not offer to switch perspective in the future once before.

The initial model

An empty statechart is created and displayed in the statechart editor in the middle of the Eclipse workbench. In the screenshot below the statechart editor is marked by a red rectangle. Subsequently, we will use the statechart editor to graphically develop the light switch statechart.

The statechart editor

Actually the new statechart isn’t really empty. It already contains the initial state (a small filled black circle), two “normal” states, and three transitions.

Let’s start our editing with a simple operation, and delete the state called StateB. To do so, just right click on the state and select Delete from Model. Alternatively, you can just press the DEL key on your keyboard.

As you can see not only the state, but the transitions connected to it had been deleted. This is the expected behavior, but let’s get back to transitions in a later part!

Giving a state a name

As we have seen, the created state has the default name StateA. You can rename any state depending on your requirements.

Remember our light switch example? The first requirement demands the switch to be off initially. The state is reached from the initial state immediately, so it is appropriate to name it Off.

Double-click on the string <StateA> in the state object. The string turns into a text input field with <StateA> being highlighted:
Type the state’s new name, i.e., Off:
Hit the [Enter] key or click anywhere outside the text field. Bingo! The state now has a proper name:
However, since the state box’s size is smaller than before now while the box’s left position remains unchanged, the graph looks crooked.
We can improve it by dragging the state box a little bit to the right. When it is centered below the initial state symbol, a vertical blue line appears giving the user a visual hint:
Drop the state box at this very place, and everything looks much better now:
Alternatively, we could have used the state box’s handles to resize it. However, we just deselect the box by clicking elsewhere:

Creating a state

With the Off state only, the light switch statechart isn’t complete yet. We also need an On state, and we going to create it now.

In order to add another state, move the mouse pointer to the Palette compartment at the right-hand side of the statechart editor. Click on the State symbol in the palette without releasing the mouse button, and drag the symbol over to the editing area.
Release the mouse button over a gray area, a region:
The new state appears in the model graph:
Rename the new state to On. Vertically align it to the Off state, if you like:
You’ll notice that the new state is showing an error marker. The reason is that it is not yet possible to reach the On state.
Before we’ll go on and fix that problem, here’s another way to create a new state. When you are hovering with the mouse pointer over the main region, i.e., the large rectangle with a gray background, a pop-up menu shows up. If you click on the ‘S' symbol in that menu, a new state will be created. Other options in this menu are to create an initial state, a final state, or a choice.

Statechart validation

Error markers in the model graph

In the previous section, after dragging the new state into the editing area and before you gave a name for it, the state had a small filled red circle containing a white ‘X' attached. This is an error marker and tells you that something is wrong with your model, particularly with the object it is attached to. Let’s create a new state, but don’t give a name for it, to guide you through the basics of the error display.

Error markers in the project explorer

The error marker is also shown in the Project Explorer view at the left-hand side of the main window. In this way you can see immediately which of your projects contain errors. Click on the small show/hide symbol (triangle) left of a project’s or any other resource’s name to show or hide its respective contents. By doing so, you can quickly encircle the directories and files that are affected by errors. In the screenshot above we have clicked open the LightSwitch project and the model directory, showing the error is in the LightSwitch.sct file.

Validation principles

This error marker exemplifies itemis CREATE' model validation capabilities. Statechart validation includes syntactical and semantical checks of the whole statechart. For example, a statechart is checked for unreachable states, dead ends, or references to unknown events. These validation constraints are checked during editing. In case any constraints are violated, error or warning markers are attached to the faulty model elements. Thus, the user receives direct and immediate feedback on the validation state of his statechart.

Hovering with the mouse over the error marker in the statechart editor reveals what the problem is. A small pop-up appears and displays the error description: "A state must have a name."

An error marker and a pop-up window explaining it

Error markers in the “problems” view

An alternative place to see error messages is the Problems view. This view has the particular advantage to comprise all notifications in a clearly arranged list form, see the screenshot above. It displays:

• A summary comprising the total number of errors, warnings, and others. In our case we have one error and nothing else.
• Zero or more lists containing errors, warnings, and other types of messages, if available. In our example there is just a single list containing error messages. Click on the show/hide symbol to show the message list’s contents or the list’s header only.

Double-clicking on an error message in the Problems view brings you directly to the erroneous object.

That’s all for now! This knowledge can help you in the future to speed up the fixing of errors in your projects. Let’s delete the incorrect state and move on to the next part to create our virtual light switch!

Creating a transition

As we have seen above, the On state is not reachable as of yet. So let’s model switching the light switch from “off” to “on” as a transition leading from the Off state to the On state.

In the Palette, click on the Transition symbol. The symbol’s background turns blue.
Click on the Off state, but don’t release the mouse button. Drag the mouse pointer towards the On state. The arrow representing the transition to be established is drawn.
Once the mouse pointer reaches the target state, it changes its shape.
Releasing the mouse button establishes the transition. A text input field to specify event trigger, guard condition and effect appears. We want the transition to be triggered when the light switch is operated, so let’s type operate into the text field.
If you suspect that something is not in order, because the input text is underlined in red, you are right. We will explain and deal with that in a minute.
Clicking anywhere outside the text field terminates the editing mode:

The event trigger operate is flagged as an error. The reason is that an event with that name is not known yet. To change that:

Double-click into the definition section on the left-hand side of the statechart editor. The section becomes an editable text field.

Modify the existing text to the following:

interface:
    in event operate

The keyword interface makes the following definition of the operate event belong to the external scope, thus we can interact with it throughout the simulation. The latter is explained in section "Internal scope".

Click anywhere outside of the text field, which terminates editing the definition section. The statechart editor digests the definition, recognizes the definition of the operate event, and validates the model as being okay:

Creating definitions [1]

In its current state the model would not allow to turn the light switch off again, which is somewhat unsatisfactory. Operating the light switch while it is on should turn it off again. Let’s model this by adding another transition. It should lead from the source state On to the target state Off.

However, in order to not get two straight lines being close together in the graph, let’s first make some room and turn the present line into an arc. Move the mouse pointer over the transition line, but not over the text. The mouse pointer changes its shape to indicate that you can insert a control point. Click and hold to add the control point, then drag it to an appropriate position.
Now let’s insert the second transition. This time we won’t use the palette, but instead use another method. Hover the mouse pointer over the source state, i.e., On. An incoming and an outgoing arrow appear, both with a handle. Click and hold the handle of the outgoing arrow and drag it to the Off target state.
Upon releasing the mouse button the transition is established. Type operate as the transition’s event trigger into the text field. Reshape the transition arrow to make the graph look nice.

Simulating the light switch model

Simulating a statechart model means to execute it, raise events manually, have time-based and other events being triggered automatically, and observe the model’s behavior.

Start the simulation by right-clicking on the LightSwitch.sct file in the project explorer and selecting Run As → Statechart Simulation:

Selecting Run As → Statechart Simulation in the context menu

The perspective changes from SC Modeling to SC Simulation. This perspective defines two additional views:

• The Debug view at the top shows all running state machine instances and allows to select one of them. itemis CREATE allow multiple executions of the same state machine as well as parallel executions of different state machines at the same time.
• The Simulation view on the right-hand side is used to raise events and to inspect and modify variables. Depending on your screen resolution and font size settings, you might not be able to spot the Simulation view by its name, because the tab containing it is quite narrow and might not provide enough space for displaying the title. Hover over the tabs to reveal their respective titles in a pop-up window. Figure "Light switch simulation in "off" state" is demonstrating this: The user has hovered the mouse pointer over a tab that is just displaying the starting letter ‘S’ of its title. However, a tooltip right beside the pointer is showing the tab’s full title “Simulation View”.

Not surprisingly, the simulation starts at the initial state and then transitions to the Off state immediately. The latter becomes the active state now. It is highlighted by a yellow background:

Light switch simulation in “off” state

Now that the light switch is off, let’s turn the lights on by operating the switch. In the simulation, we will have to raise the operate event. How can we do this?

In the Simulation view at the right-hand side of the Eclipse workbench, click on the default entry’s show/hide symbol to display its contents.

Displaying event names in the statechart simulator’s Simulation view

The operate event is shown. Click on it to raise the event, i.e., to operate the light switch.

The transition arc leading from the Off state to the On state flashes briefly in red, and then the On state becomes active. Its background color changes to yellow while the Off state’s background color becomes normal again.

Light switch simulation in “on” state

Click on operate again, and the active state changes back to Off. Click on operate several times and enjoy watching the state machine’s behavior.

Stop the simulator by clicking at the little red termination button in the toolbar at the top.

Code generation

itemis CREATE include code generators for Java, C, and C++ out of the box. The code generators are following a “code-only” approach: They are generating all the code that is needed and do not rely on any additional runtime libraries. The generated code provides a well-defined application programming interface and can be integrated easily with any client code. In this tutorial we will generate Java code for a sample statechart modeling the handling of a phone call, the CallHandling example.

The CallHandling example

The state machine handling a phone call works as follows:

• After startup, the system is in an idle state and is waiting for incoming calls.
• When a call comes in, the user can either accept the call or dismiss it.
• If the user accepts the call and opens a connection, the system is tracking the duration of the call and is waiting for the user to hang up.
• After hanging up, the system displays the total time of call and then returns to its idle state.

The complete statechart model is shown below:

The CallHandling statechart model

In order to eventually obtain the CallHandling example in the form of executable code, we have to create the model in the statechart editor first, followed by creating a suitable generator model, followed by executing the code generator to create the source code we need.

Creating the statechart model

In the previous section we have seen how to work with the statechart editor. So let’s create a new project now and use the statechart editor to create the CallHandling statechart model as outlined above.

Since we are going to generate Java code, we should use a Java project to host the statechart model. Use File → New → Java Project and follow the New Java Project wizard to create one.

In addition to what we have learned above already, there is one new concept: interfaces.

Creating interfaces

Statecharts can describe very complex interactions between a multitude of actors and an even bigger multitude of events these actors can receive or trigger. It is therefore good practice to structure such events and associate them with their respective actors. For this purpose itemis CREATE provides the concept of so-called interfaces.

In the CallHandling example, we have two actors: the user and the phone. Let’s model their communication as two interfaces:

• The Phone interface provides a single incoming event named incoming_call.
• The User interface comprises two incoming events: accept_call and dismiss_call.

We have to enter the respective definitions in textual form into the statechart editor. Here’s how the interface definitions look like:

@EventDriven
@ChildFirstExecution

interface User:
    in event accept_call
    in event dismiss_call

interface Phone:
    var duration : integer
    in event incoming_call

As you can see, the Phone interface also has an integer variable duration which will track the duration of the call. The interface definitions above have to go into the statechart editor’s definition block on the left-hand side of the statechart editor.

If everything went well, any error markers in the model are gone. Your model should look like the one in the screenshot below:

The CallHandling statechart modeled in the statechart editor

Creating a generator model

For code generation, itemis CREATE use a textual generator model called SGen. The generator model holds key parameters for the code generation process and allows for the latter’s customization.

The first step to code generation is to create a new SGen model. Right-click on the model folder in the project explorer and select New → Code generator model from the context menu.

Selecting New → Code generator model in the context menu

The itemis CREATE generator model wizard opens. Change the File name to CallHandling.sgen, then click Next >.

Selecting a filename for the generator model

From the Generator drop-down menu at the top, select itemis CREATE Java Code Generator.

In the statechart tree beneath that menu, check the CallHandling.sct model, then click Finish.

Selecting generator type and statechart model

Now the wizard creates the default SGen model for Java code generation and opens it in an SGen editor. The project explorer on the left-hand side shows the new model file CallHandling.sgen.

The generator model

Here’s the generator model once again as plain text:

GeneratorModel for create::java {

    statechart CallHandling {

        feature Outlet {
            targetProject = "CallHandling"
            targetFolder = "src-gen"
            libraryTargetFolder = "src"
        }
    }
}

Let’s have a closer look at the listing above:

• create::java is the unique ID of the Java code generator.
• The statechart CallHandling { … } block references the statechart model we want to generate code for.
• The feature Outlet { … } block specifies where the generated code artifacts are to be placed:
  • The parameters targetProject and targetFolder define the Eclipse project CallHandling as destination for generated code and within that project the src-gen folder.
  • However, certain source code modules are generated only once and won’t change with the underlying statechart. By default, these source code artifacts are generated into the folder specified by the libraryTargetFolder option which by default is src. You can change the folder name or even remove the libraryTargetFolder option at all. In the latter case the “library” components are generated into the targetFolder.

A statechart reference may contain various configuration features. You will learn more about them later.

Enhancing the generator model by timing capabilities

The default generator model is insufficient yet. The CallHandling statechart model uses after and every expressions. That is, it is dealing with time events, requiring a timer service to trigger them. We can instruct the code generator to provide us with a default timer service implementation by adding the following feature to the generator model:

feature GeneralFeatures {
    TimerService = true
}

Generating Java source code

What do we have to do to actually start the Java source code generation? Nothing!

The generator model is executed by a so-called Eclipse builder. That is, as long as the Project → Build Automatically menu item is checked (which it is by default), the artifacts are generated automatically with each modification of the statechart model or of the generator model.

As you can see in the project explorer, the folder src-gen has been created and populated with the generated Java source code artifacts.

Adding the timer service feature

Add the generated artifacts to the Java build path by right-clicking on the src-gen folder and selecting Build Path → Use as source folder in the context menu.

Declaring src-gen as a source folder

If you want to execute your generator model manually, select Generate Code Artifacts from the .sgen file’s context menu in the project explorer.

Integration with client code

Now that we have a generated Java implementation of the CallHandling state machine available, we want to actually use it from some client code. We’ll create that client code in a second.

Creating client code

Let’s establish a new Java class CallHandlingClient and integrate the state machine with it:

1. Right-click on the src folder.
2. Select New → Other.. → Java → Class in the context menu.
3. Name it CallHandlingClient.
   
4. Click Finish.

Next, copy the following code into the created class:

package callhandling;

import callhandling.callhandling.CallHandlingStatemachine;

public class CallHandlingClient {

	public static void main(String[] args) throws InterruptedException {

		// Create the state machine:
		CallHandlingStatemachine sm = new CallHandlingStatemachine();
		sm.setTimer(new TimerService());

		// Enter the state machine and implicitly activate its "Idle" state:
		sm.enter();

		// Raise an incoming call:
		sm.getSCIPhone().raiseIncoming_call();
		sm.runCycle();

		// Accept the call:
		sm.getSCIUser().raiseAccept_call();
		sm.runCycle();

		// Keep the phone conversation busy for a while:
		for (int i = 0; i < 50; i++) {
			Thread.sleep(200);
			sm.runCycle();
		}

		// Before hang-up, output the duration of the call:
		System.out.println(String.format("The phone call took %d seconds.", sm.getSCIPhone().getDuration()));

		// Hang up the phone:
		sm.getSCIUser().raiseDismiss_call();
		sm.runCycle();
	}
}

Let’s have a detailed look at this client code:

• First, this program creates a new instance of the state machine by calling the default CallHandlingStatemachine constructor:
  • CallHandlingStatemachine sm = new CallHandlingStatemachine();
• Since we are using time events, the state machine implementation requires an implementation of the ITimer interface. And since we added the TimerService feature to the generator model, the code generator creates a default implementation com.yakindu.scr.TimerService that uses the java.util.Timer class. A new instance of the default TimerService is created and set to the state machine:
  • sm.setTimer(new TimerService());
• After that, sm.enter() enters the state machine and – via its initial state – activates its Idle state.
• For each interface in the statechart definition block a getter method has been generated, here getSCIPhone() and getSCIUser(). You can access all incoming events and all variables via these interfaces.
  • sm.getSCIPhone().raiseIncoming_call(); raises the incoming_call event, activating the Incoming Call state after the next run cycle has been executed. The latter is triggered by sm.runCycle().
• sm.getSCIUser().raiseAccept_call() accepts the call or, to be more precise, raises the accept_call event via the User interface. It activates the Active Call state after the next run cycle has been performed by sm.runCycle();.
• In the for loop, the run cycle is executed periodically every 200 milliseconds. This simulates the duration of the phone call.
• Before hanging up the phone, let’s find out how much time we spent in the call. sm.getSCIPhone().getDuration() retrieves the call’s duration, which is then formatted and printed to the console.
• Finally, sm.getSCIUser().raiseDismiss_call() raises the dismiss_call event. It activates the Dismiss Call state after the next run cycle.

Executing the client code

You can execute the client code via Run As → Java Application from the class file’s context menu.

Closing remarks

At this point you have mastered the comprehensive tutorial and got to know the most important itemis CREATE features up to a certain degree. The itemis CREATE Statechart User Guide will explain statechart language, statechart editor, simulation, testing, programming language support, and code generation in detail.

Statechart concepts tutorial

This tutorial introduces main concepts which will be helpful for understanding and defining statecharts in itemis CREATE. While the previous tutorials explain how to use itemis CREATE, this tutorial does not require an installation of itemis CREATE as it makes use of embedded statechart players.

The different concepts are introduced step by step using a light control example. Starting from a simple On/Off switch, we will add further features like brightness adjustment and motion detection step-by-step while introducing new statechart elements with each iteration. In that way you will learn how to use:

• States and transitions
• Transition triggers, guards, and actions
• Statechart interfaces, and where to declare events, variables and operations
• Composite states, and how they help structuring your statechart
• History states, and the difference between shallow and deep history

While itemis CREATE supports even more concepts, this is a good starting point to dive into itemis CREATE headfirst. Within itemis CREATE these tutorial statecharts are also provided as an example project.

States, transitions and events

interface:
	in event switch 

Variables

While the classic theory of input/output automata is only aware of events, Harel statecharts and as such CREATE Statecharts have many more features, including variables. Variables allow to use quantitative values in statecharts and are very comparable to variables in programming languages.

interface:
	in event switch
	in event changeBrightness
	var brightness: integer

Composite States

interface:
	in event switch
	in event changeBrightness
	in event toggleMode
	in event motionDetected
	var brightness: integer

History Entries and Named Interfaces

interface:
	var brightness: integer
interface hmi:
	in event switch
	in event toggleMode
	in event changeBrightness
interface motion:
	const timeout: integer = 30
	in event detected
interface luminosity:
	const delay: integer = 10
 	in event bright
 	in event dark

Orthogonal States, Internal Events and Operations

interface:
	var brightness: integer

interface hmi:
	in event switch
	in event toggleMode
	in event changeBrightness

interface simulation:
	var WAIT_MIN: integer = 5
	var WAIT_MAX: integer = 1200
	var UPDATE_PERIOD : integer = 2


internal:
	var wait_time: integer
	var hour: integer
	
	event changePresence
	event startSimulation
	event stopSimulation
	
	operation get_rand(): real
	operation get_hour(): integer

Video tutorials

You can find some video tutorials on the itemis website.