YAKINDU Statechart Tools 2.6 released!

Today we released the new version 2.6.0 of YAKINDU SCT!

During the last four month since the last release we invested a lot of effort in improving usability, documentation, and maturing the existing features and also providing some new features. In total, we completed 145 issues. So it will be worth for downloading. Get it for free.

download

So what does the new version contain? Lets have a look.

New code generators features

The C code generator is the first generator that supports tracing callbacks. You can enable this feature using the config feature called Tracing in the sgen file. It will allow you to trace state entries and exists in order to react to it in your custom code.

The Java code generator now supports the generation of a thread-safe state machine implementation in addition to the queue based implementation that we introduced with release 2.5. Again you can simply enable the feature in the sgen file using the SynchronizedWrapper config feature. 

Standalone generators

To support a better integration with build systems (including CI builds) we refactored the generator infrastructure. Now it is possible to run code generators independent from the IDE.

Usability

Lots of effort was spent to improve the usability of YAKINDU SCT. We are happy that Sandra Schering and Jasmin Kuhn joined our team as usability engineers. So we will be able to work on these topics continuously. By the way - you can see who's in the team here.

A lot more stuff ...

Of course there are a lot more functional improvements, documentation and bug fixes. For a detailed list take a look at our release notes. In addition to those things that you will notice as a end user we also changed a lot "under the hood" as preliminary work for the upcoming YAKINDU Statechart Tools Professional Edition.

So if you have any issues regarding the new version, we would be happy to get feedback!

Download YAKINDU Statechart Tools

download 

Supersonic 5 Minute Lego Bot

In order to experiment with our new YAKINDU SCT4NXT statechart tool for Lego Mindstroms NXT i was looking for a simple Lego bot that can be build within few minutes. I came across the building instructions of the 'Five Minute Bot'. This was a good basis for and just had to attach the desired supersonic and touch sensors.

It looks like this ...




... and here are the building instructions.

The design is based on the ‘Five Minute Bot’ from www.nxtprograms.com. So start with those building instructions and continue here when you are ready…

Mounting the ultrasonic sensor

For the ultrasonic sensor you’ll need the sensor itself as well as few other parts.
step one
step two
step three
step four Now first connect the cable and then mount the ultrasonic sensor to the bots bottom side.

Mounting the touch sensors

Mounting the right and left touch sensors are identical so the instructions below are for one sensor and you have to build it twice.

Each sensor needs some parts for attaching it to the bot as well as some part that are mounted on the tip of the sensor in order to have a larger touch area.
step one
step two For the left sensor the mounting bar has to be attached to the other side of the sensor.
step three
step four connect it to the right (and left) side of the NXT brick

… done !!

The bot should now look like this ...

You can also download these building instructions as PDF. It is provided under the terms of the Creative Commons Attribution 4.0 International Public License

Executable HMI Specifications with Flash and Yakindu Statecharts

Human machine interfaces (HMI) are inherently interactive and dynamical. An important goal of HMI engineering is to optimize the interaction between the human being and the machine. The ergonomics and efficiency of an HMI is mainly driven by the quality of its design. This makes the HMI design a central part of HMI specifications. Due to the HMIs dynamical nature the design must cover the interfaces functional behavior as well as its form and appearance. From this point of view executable specifications would be desirable.

Statecharts are an executable formalism that can be used to specify the reactive behavior of HMIs at an adequate level of abstraction. Using statechart the function can be specified very well, but statecharts do not cover the design aspect of form at all. So they can't provide any concrete visual experience. This part could be covered by different approaches. A prominent one is to use Adobe's Flash technology for prototyping visual designs. Flash allows rich visual effects including animations etc. and is very popular in the 'design oriented' disciplines. So putting both together seems to be a promising approach - and that is what we did. We integrated our Yakindu Statechart Tools with Flash applications and set up two showcases. The first shows a electric window lifter and the second an interactive driver information panel.

Check out the the screencast to get an impression how the solution works.

Each showcase consists of a Flash application, a statechart, and a simple textual mapping model that describes how Flash and statechart events and data have to be mapped towards each other.Technically the mapping model is used to generate a flash component that has to be embedded into the  Flash application. This component registers the appropriate event handlers and handles the communication issues with the Yakindu statechart simulator that executes the statechart. When working with the Flash based design active states, transitions, and value changes are also visualized on the model level.

The whole tooling is based on the Eclipse platform. The Adobe Flash Builder is based on Eclipse as well as the Yakindu Statechart Tools and the mapping model including the model parser and the rich editor including content assist for references to Flash components is based on Eclipse Xtext technology.

This approach brings up some interesting questions. First of all - how can the formal statechart model help when it comes to the concrete implementation of the HMI? Can it be used to generate code? What are the preconditions and must the statechart be refined for that purpose? I think i will cover some of these questions in following posts.

Another interesting point is of course that this approach also can be useful for other use cases than HMI specifications. It can be used whenever a visual rich animated frontend will be required in simulation contexts. And of course Flash applications may be integral part of  concrete System implementations...

First Embedded Project at Eclipse Labs

At the weekend i set up the yakindu project at Eclipse Labs. Initially we planned to provide public access to source code, issue tracker, forums, etc. by hosting the project on Sourceforge. That plan changed when the Eclipse Foundation announced on May 13th that they coorperate with Google on the project hosting platform Eclipse Labs. Since that platform is closer to Eclipse and promises a much better visibility of the Yakindu Tools (and even though it has some drawbacks compared to the functionality of the Sourceforge platform) we decided to switch to that hosting platform.

So when i created the project (and still now) the yakindu project is the only project in the category Embedded. The project already provides access to the source code, the public issue tracker, and a user forum (a google group). Since thee is a qouta for the downloads at Eclipse Labs we still have to decide how to handle the downloads of the Yakindu Eclipse Distributions (they are currently still on Sourceforge).  We also will continue to host our continuous build system on the Hudson server at itemis.

I am very curious how Eclipse Labs will develop since it is still in an early phase. Currently there are 318 projects - that means more than 10 projects a day have been registered per day in average. That is promising.

Axel

PS: Some Links...

• http://www.yakindu.com


• http://eclipselabs.org/p/yakindu

Yakindu Statechart Tools 1.1.0

At the beginning of this month we have built the 1.1.0 release of the Yakindu Statechart Tools (SCT). This version is build for Eclipse 3.5 (Galileo). And contains some important improvements like:

• a new simulation engine that applies the java code generator to make sure that simulation and generated java code behave identical


• validation for statechart expressions. The textual elements will be parsed and error markers will be set if an expression is invalid.


• simple editing actions for reordering transition priorities.


• improved Eclipse-UML integration


• a lot of more things.

Some of these features are also contained in the probably last release 1.0.0-M04 for Eclipse 3.4 Ganymede. The new release is available from the Yakindu update site: http://updates.yakindu.com/galileo/release or from the Yakindu download site.

YAKINDU Statechart Tools: M02

After about a month of work the M02 version of the statechart tools is online. This version contains some new features that are very valuable like a Java code generator, a UML2 transformation,  and a common expression language for guard and action expressions. Existing parts like the simulation engine, the C code generator, the Eclipse IDE integration and of course the documentation were improved.

The following diagram gives an overview of the top level tool components.

I like the new version very much and think it is very usable. Nevertheless there are still things to do. The next topics we are currently working on is support for test driven development of state charts. So this will include a test DSL (domain specific language) that allows to specify test cases independently of whether you execute the tests by using the state chart interpreter or the generated C or Java code. We will use a textual test DSL that will be implemented using Xtext. Additionally the next version will also contain a source feature that is not published yet.

Everyone who is interested can download the YAKINDU statechart tools from the download page. Please first take a look at the user guide that is also available there.

YAKINDU Statechart Tools published

Today we (the itemis Yakindu team) published the first version (M01) of the YAKINDU Statechart Tools.

The Yakindu development tools are a tool kit for model based development and the statechart tools are the first module provided by this project. The tools apply the concept of state machines that are well understood and formal enough to describe behaviour unambiguously. The statechart tools support editing, validating, simulating state machines and generating code from state machines. The tools are provided as Eclipse-plugins and integrate tightly into the IDE.

The simulation of a state machine is integrated with the debug perspective of Eclipse and uses the Yakindu Statechart Diagram Editor to visualize the execution of the state machine by highlighting active state and current transition. Additionally, the user can interact with the simulation by sending triggers to or by changing variable values within the simulator to drive the state machine. The screenshot shows a simulation session in action.

This version includes a C-code generator. Generators for other target languages like Java and PLCs will follow in the next version. This will be published end of march.

The statechart tools are built on Eclipse technologies especially from the Eclipse Modeling Project and openArchitectureWare like EMF, GMF, Xpand, Xtend and Check.  

You can download the plugins as well as the user guide from the  Yakindu website. Of course there is also an Eclipse update site where new versions of the tools will be published. Please take a look at the user guide for details on using the tools. We hope that you like the statechart tools and we highly appreciate any feedback.