Model driven Software Development for Embedded Systems

Yakindu is an open-source-toolkit for the model-driven development of embedded systems. Through the systematic use of models, it aims at an integrated development process as well as an increase in quality and maintainability.

Yakindu M14 new and noteworthy

May 3, 2012 | Andreas Muelder | Tags: , ,
Posted in Statechart Tools | No Comments »

We published a new preview (called M14) of the upcoming Statechart Tools (SCT) 2.0 today!

In this release, we implemented the following major features:

  • integrated user guide in code completion hover
  • example wizard for the java traffic light example
  • enhanced sgen editing captabilities
  • support for string literals
  • entry and exit actions for statecharts
  • and of course a lot of Bug Fixes and Test Case

Integrated user guide

All available features of the statechart expression language are documented in the user guide.  When selecting a keyword, the relevant  piece of information is displayed as text hover besides the proposal window.

 

Enhanced editing captabilities

The generator model (sgen) now provides proposal templates and quick fixes that makes creating a generator model very easy. Forall available generator features, the user documentation is integrated as tooltip hovers.

Example wizards

We ship the traffic light examples as example wizard.  Select Nnew /Examples / Yakindu Examples / Trafficlight example to create a new project containing the traffic light model, genmodel and a swt based UI that shows the integration of the generated java source code in detail.

Installation & Update

It is available via our milestones update site: http://updates.yakindu.com/indigo/milestones . Use this Eclipse update site link to install the statechart tools into your existing Eclipse Indigo (3.7.2). For a new installation choose Eclipse  menu Help/Install New Software … and  Help/Check for Updates if you have already installed a preview version of SCT

Yakindu M13 new and noteworthy

March 29, 2012 | Andreas Muelder | Tags: , ,
Posted in General, Statechart Tools | No Comments »

We published a new preview (called M13) of the upcoming Statechart Tools (SCT) 2.0 today!

The focus of this version was definitely on rounding the existing features off. So a lot of work was spent in Bug Fixing, writing Test Cases, as well as polishing  meta models and APIs. Nevertheless  the major feature in this release is the User Guide.

Of course it is integrated into the Eclipse help.

Installation & Update

It is available via our milestones update site: http://updates.yakindu.com/indigo/milestones . Use this Eclipse update site link to install the statechart tools into your existing Eclipse Indigo (3.7.2). For a new installation choose Eclipse  menu Help/Install New Software … and  Help/Check for Updates if you have already installed a preview version of SCT

Yakindu M11 new and noteworthy

January 31, 2012 | Andreas Muelder | Tags: , ,
Posted in General, Statechart Tools | 2 Comments »

We published a new preview (called M11) of the upcoming Statechart Tools 2.0 today!

In this release, we implemented the following major features:

  • the simulation uses a Virtual Time
  • advanced Run Configurations
  • new dynamic Simulation Highlighting
  • History and Deep History States
  • enhanced User Guide / Documentation
  • and of course a lot of Bug Fixes and Test Case

Virtual Time

In the current release we implemented a Virtual Time for the Simulator. The user can provide a time scaling factor , that is multiplied with the real time, in the SimulationView. This is especially useful during debugging, if the statechart model contains very tight or long running time triggers.

Run Configuration

It is now possible to select between two different execution types (cycle-based or event-driven) for the simulator. If the cycle based execution type is selected, the cycle period can be specified in milli seconds.

Simulation Highlighting
The simulation highlighting has been improved. Not only the currently active states are visualized but also the last transition including the previous states and the transition path to the current state configuration. As shown in the screenshot above the transition is outlined with orange color. The highlighting colors can also be changed using the eclipse preferences.
History and Deep History States
the History as well as the Deep History States are now fully supported during Simulation and Code Generation (Java and C). In this context the intermediate transformation that creates an sexec model from the statechart model was refactored and now provides a basis for a public API that will be published with the release of SCT.
Installation & Update

It is available via our milestones update site: http://updates.yakindu.com/indigo/milestones . Use this Eclipse update site link to install the statechart tools into your existing Eclipse Indigo (3.7.1). For a new installation choose Eclipse  menu Help/Install New Software … and  Help/Check for Updates if you have already installed a preview version of SCT

Yakindu M10 new and noteworthy

January 12, 2012 | Andreas Muelder | Posted in General | No Comments »

We published a new preview (called M10) of the upcoming Statechart Tools 2.0 today!

In this release, we implemented the following major features:

  • implemented a intermediate Execution Model
  • migrated the Simulation Engine to the new execution model
  • improved Simulation UI 
  • Extended Property Pages
  • improved the Statechart Language
  • Type Analyser added to statechart expressions
  • added YAKINDU Nature with Automatic Builder
  • improved Code Generators
  • … and of course a heap (32) of  major Bug Fixes
Installation & Update
It is available via our milestones update site: http://updates.yakindu.com/indigo/milestones . Use this Eclipse update site link to install the statechart tools into your existing Eclipse Indigo (3.7.1). For a new installation choose Eclipse  menu Help/Install New Software … and  Help/Check for Updates if you have already installed a preview version of SCT .

Execution Model

This intermediate model is used behind the scenes as a foundation for the code generators and the simulation engine. This guarantees that the simulation behaves in the same way as the generated Statechart implementations. It captures the execution behavior and may also serve as the basis of custom code generators.

Simulation UI

We created a new Declarations View which groups the Events and Variables by their Scopes and has a more compact layout. Events can be raised by single click. Additionally not only the active state is highlighted, but also the transition path from the previous state (see the green transition).

Property Pages & Type Analyser

The Property Pages  do support the ordering of outgoing transitions and top level regions now in order to specify a deterministic execution order.

Additionally a static type analyser checks complex expressions for validity during editing.

Constraints

Some of the statechart features that are supported by the editor can currently not be used within simulation and code generation. This are histories, entry & exit points, synchronizations (fork and join) and linking substatemachines. These features will be available in the upcoming release scheduled for end of january.

 

New Milestone Release Available

November 21, 2011 | Andreas Muelder | Posted in Statechart Tools | 3 Comments »

The Yakindu Team published a new preview of the upcoming Statechart Tools 2.0 today! It is available via our milestones update site: http://updates.yakindu.com/indigo/milestones

If you have already installed a preview version, you can get the new release via Eclipse help / Check for updates.

In this release, we implemented the following major features:

Code Generators for Java and C

The release contains code generators for cycle based statemachines. This first version supports code generation of following statechart elements:

  • interface and local declarations

  • states (entry / exit)

  • entries

  • timing (after, every clauses)

  • expressions

The generated code contains a statemachine class which can be simply integrated in your custom code. Input and outputs can be set through the interfaces defined in the statechart diagram interface declaration. For the Java Code Generator there is already a working example  ‘org.yakindu.sct.generator.java.trafficlight’  in the examples folder in the repository.

Generator Model

All generators can be customized with a generator model. This is a textual model file where generator features, like i.e. the outlet path, can be specified. The following screenshot shows an example configuration for the java code generator. In future releases, we will add generator features for the execution type (event or cycle based), interface styles (static or generic) and much more.

To get started with the generator model, we included a new Eclipse wizard that creates a basic configuration file with default values.

To execute the Generator Model, select “Generate Model” from the context menu of the resource in the “Project Explorer”.

We hope you enjoy this new version and please provide us some feedback!

 

Damos in detail …

September 22, 2011 | Axel Terfloth | Posted in Damos, General | No Comments »

Andreas wrote a bunch of interesting blog posts on Damos. If you are looking for an open source tool for data flow oriented modeling – and eventually an Eclipse based open source alternative to Simulink – then it is definitely worth to take a closer look…

First of all the overview describes some important and from our point of view outstanding modeling features like system fragment that amend subsystems and interfaces as a structural feature to handle complex models, support for SI units, and Mscript a math oriented scripting language.

Some more recent modeling features provide support for conditional and iteration constructs and finally the simulation engine now provides a set of different solvers like Runge-Kutta or Dormand-Prince in addition to the simple Euler solver that was used so far.

Statechart Tools 2.0 Milestone 5 preview release

September 15, 2011 | Andreas Muelder | Posted in General, Statechart Tools | 4 Comments »

We published a new preview of the upcoming Statechart Tools 2.0 today! It is available via our milestones update site: http://updates.yakindu.com/indigo/milestones
Apart from several bug fixes and some art work (thanks to our designer Carsten for the really cool icon set!)
we implemented the following major features in this milestone:

Submachine States

A submachine state is semantically equivalent to a composite state but it adds the mechanism to be reused in different contexts.
 In the YAKINDU Statechart Tools, submachine states can be created directly via the diagram palette. This opens a dialog where the Statemachine can be selected, that should be included as a submachine. Submachine states are displayed with a small pictogram at the bottom right. A click on the pictogram opens the submachine diagram in a new editor.

Simulation 
The simulation of a state machines is integrated into the state machine diagram editor and provides visual highlighting of the active state and the current transitions. 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 Debug View does also support multiple runtime instances (launches) of the same statechart. The Declarations View on the right and the diagram editor are aware of the selected lauch.
If a statechart with submachine states is executed, the Debug View shows the active states of the submachine ordered by the active regions. A selection of an active state opens the submachine in a new editor and highlights the active states.

Property Pages
Another major improvement are the form based property pages. For each selectable element in the statechart diagram, a custom property page is shown with rich controls like i.e. the Xtext StyledText widget.

The property pages also integrate tightly in the Eclipse help infrastructure and display context sensitive informations in the Dynamic Help View. In the future, we will add detailed information especially for the complex expression languages.

Code Generator for C++
the new preview also consists of a first implementation of a C++ code generator. The generator can be invoked via the context menu in the project explorer by selecting “Generate C++ code”.
The code g enerator for C++ code creates the class “<Name>Statemachine” to be used by the programmer. The interface is defined in Statemachine.h and DataRepository.h. The interface mainly consists of a method to raise an event (queueEvent()) and to run one statemachine cycle (runCycle()). Additionally the class offers access to the variables via getter and setter methods. If there is a variable named “myVar” it is read by get_myVar() and can be written by set_myVar(value).
The statemachine implementation follows the event driven paradigm, therefore events can be fired at will and one cycle pops the oldest event and dispaches it. The method eventWaiting() indicates queued events ready to handle by a runCycle() call. To firstly initialize the statemachine, use the init() method.

Miscellaneous enhancements

  • Perspectives (Simulation / Modeling)
  • Hot Model Replacement (Edit the model during simulation)
  • Common Navigator Framework implementation for a tree based view of the semantic model
  • Launch Shortcuts
  • Several Validation rules added
  • Named entry and exit points
  • ….

I hope you enjoy this new version and please provide us some feedback!

YAKINDU slides are online

August 13, 2011 | Axel Terfloth | Tags: , , ,
Posted in Damos, General, Statechart Tools | No Comments »

The slides from the recent YAKINDU talks are online now. Download them from our slides page.

Upcoming YAKINDU talks in july

June 29, 2011 | Axel Terfloth | Tags: , , ,
Posted in General | No Comments »

In July Andreas and i will have two talks about the YAKINDU toolkit – both in Germany.

1. On july 6th Andreas and i will have a two hour workshop at the “Design & Elektronik Entwicklerforum Embedded-System-Entwicklungon”. We will talk about the YAKINDU Statechart Tools, Damos, and how to use them together with textual models. Here is the link:  http://www.embedded-entwicklerforum.de

2. On july 12th i will have a short talk about the Yakindu workbench at the “BAIKEM-Netzwerktreffen Embedded Systems”  (http://bayern-innovativ.de/embedded2011)

 

YAKINDU Statechart Tools 2.0 preview online!

June 27, 2011 | Andreas Muelder | Tags: , , ,
Posted in Statechart Tools | 7 Comments »

For everyone who is curious about what is going on with YAKINDU SCT (Statechart Tools) we have published a preview of the upcoming version 2 (SCT2).

YAKINDU SCT 1.x has been around for quite a while and finally got into maintenance state. Meanwhile we collected a lot of requirements and ideas about the future development of the statechart tools. The main goals are to improve the usability of the modeling and simulation tools, extend the statechart modeling features, wider support for testing and finally allowing domain specific extensions of statecharts. Since this is a big bunch of stuff we decided to go for a new major version of the YAKINDU SCT and not to care about backwards compatibility. So we have the option to continue parts that fit well but also are able to drop things that don’t fit.

After roughly a half year of development some functionality is ready for a public preview. Some key features are still missing in this preview, i.e. the simulation engine and the code generators, but the meta model and the diagram editor is stable.

We implemented the following major improvements in this current preview:

new statechart editor
Version 1.0 of the statechart editor was created with GMF tooling. While GMF tooling is great for developing run-of-the-mill graphical editors in a couple of minutes, there are some major drawbacks when developing high-grade customized editors like the statechart tools. Thus, we decided to start version 2.0 as a complete redevelopment against the GMF runtime. The result is a graphical editor with 100% handwritten code that is well structured and easily maintainable.

usability & visual polishing
Some effort was spent in improving the usability by reworking the handling and visual design of statechart elements. This also included things like changing layouts, additional editing actions etc. Also the coloring in version 1.0 were always a matter of taste ;-) In SCT2 we use more decent coloring and font styles. These are just the first steps towards a very cool statechart editor.

advanced textual editing support
The most striking features is the wider use of textual parts on transitions, states, and statechart level. Since there was no good editor support in SCT 1.x (even though we used Xtext for parsing). We use Xtext-based in-diagram editors to provide code completion, syntax highlighting, validation, cross referencing etc. to support the user creating complex statements. Give it a try – it is really cool. Those who are interested in the technical details can read this post.

extended modeling capabilities
We defined a new version of the statechart meta model that consists of elements that have graphical notation and others with textual notations. This meta model comes with a bunch a new modeling features like structured interfaces, events with values, local reactions (aka internal transitions), operations, derived events, clocks etc.. You can just play around with the code completion in the textual parts in order to explore the features.

The current plan is to provide a version of YAKINDU SCT2 that roughly covers the same functionality as the 1.x version has in respect to code generation and simulation features by end of september 2011. Everyone who wants to take a closer look may load the statechart tools from the update site:

Yakindu – http://updates.yakindu.com/indigo/milestones

« Older Entries