SinelaboreRT - wiki:backends

Generating C code

anonymous@undisclosed.example.com (Anonymous) — Fri, 03 May 2024 20:41:46 +0000

Generating C code

Sinelabore creates compact and clearly readable C code from UML state charts. There are a number of different ways in which the generated code can be fine-tuned through the setting of configuration parameters. This allows generation to follow known patterns, which are illustrated with examples below.

Object pattern: Instance related data is always grouped in a struct. All state machine related functions operate on this data struct. The advantage is that the data flow is easy to follow, the code is re-entrant because there is no global manipulated state, and multiple instances are easy to realise.
Opaque object pattern: This is similar to the object pattern, but hides the implementation from the outside of the generating state machine code. This further reduces dependencies between the state machine implementation and other code. See also https://en.wikipedia.org/wiki/Opaque_pointer
Single instance pattern: Typically there is only one instance and no instance pointer is needed. For example, implementing an IRQ handler as a state machine, or using a hardware module in the state machine that exists only once.

In the generated code, state hierarchies are mapped to nested switch/case code. Event handling code is mapped to if/else-if/else structures. The various configuration parameters allow you to generate code that is optimal for your system. See section 2.2 of the PDF manual for a list of all available options. To generate C code call the code generator with the command line flag ’-l cx’. To generate a configuration file with all parameters related to the C code generation call the code generator as follows once: java −cp path_to_bin_folder/∗ codegen.Main −l cx −gencfg > codegen.cfg

There are various configuration options to adjust the generated code:

usage as interrupt handler without any parameters (e.g. #pragma vector=UART0TX_VECTOR __interrupt void irq_handler(void));
having only the event as parameter of the handler
having an instance pointer and event as parameter (for running multiple instances of the same machine e.g. void testcase(TESTCASE_INSTANCEDATA_T *instanceVar, TESTCASE_EVENT_T msg ))
having an own defined parameter containing the event which allow to easily send data with the event (e.g. void testcase(TESTCASE_INSTANCEDATA_T *instanceVar, USER_EVENT_T *userData)
Support for externally defined events (i.e. outside the UML diagram) to better support reuse of legacy code
Support for conditional events (i.e. boolean expressions)
the C backend has features for high-availability applications where it is desirable to detect serious errors happening outside the state machine code but effecting the correct execution of the state machine. Such errors might come from a runaway pointer overwriting key variables, power brownout corrupting a bit or a bad ram cell losing a bit to name a few. To detect and handle such situations is an overall system design task. But the code generator can help you to detect inconsistencies of the state machine offering different mechanisms described in the manual.

The code generator supports code generation from models with regions. A region is an orthogonal part of a state. Regions allow to express parallelism within a state. A state can have two or more regions. Region contains states and transitions.

An example state diagram with regions is shown below. Imagine how much effort it would be to manually write the code for this machine. And even worse how difficult it would be to maintain it over time when new states/events are added.

All this allows to generate code that is optimal for your system. See the manual for a list of all available options. To generate C code call the code generator with the command line flag -l cx.

This results in the following files:

C-file with the state machine implementation
H-file of the state machine
H-file with the events that can be sent to the machine
A file with some code that supports debugging

Example code generated from the oven example in the handbook:

#include "oven_ext.h"
#include "oven_hlp.h"
#include "oven.h"
#include <stdio.h>
 
extern unsigned char msg;
extern T_PWR pwr;
 
void  oven(OVEN_INSTANCEDATA_T *instanceVar){
 
	OVEN_EV_CONSUMED_FLAG_T evConsumed = 0U;
 
	/* Create a copy of the instance data.
	   Changes during the machine execution are done on the copy 
	   while tests (e.g. isIn) must use the unmodified instance data */
	OVEN_INSTANCEDATA_T instanceVarCopy = *instanceVar;
 
 
	switch (instanceVar->stateVar) {
 
		case Active:
			/* calling region code */
			evConsumed |= ovenLight(instanceVar, &instanceVarCopy, msg);
			evConsumed |= ovenPower(instanceVar, &instanceVarCopy, msg);
			evConsumed |= ovenRadioator(instanceVar, &instanceVarCopy, msg);
 
			/* Check if event was already processed  */
			if(evConsumed==0U){
 
				if(msg==(OVEN_EVENT_T)evDec){
					/* Transition from Active to Active */
 
					/* Exit code for regions in state Active */
 
					/* Action code for transition  */
					timer_dec();
 
 
 
					/* Entry code for regions in state Active */
					/* entry chain  */
					/* entry chain  */
					/* entry chain  */
 
 
					/* adjust state variables  */
					(&instanceVarCopy)->stateVar = Active;
				}else if(msg==(OVEN_EVENT_T)evInc){
					/* Transition from Active to Active */
 
					/* Exit code for regions in state Active */
 
					/* Action code for transition  */
					timer_inc();
 
 
 
					/* Entry code for regions in state Active */
					/* entry chain  */
					/* entry chain  */
					/* entry chain  */
 
 
					/* adjust state variables  */
					(&instanceVarCopy)->stateVar = Active;
				}else{
					/* Intentionally left blank */
				} /*end of event selection */
			}
		break; /* end of case Active  */
 
		case Inactive:
			if(1){
				/* Transition from Inactive to Active */
 
 
				/* Entry code for regions in state Active */
				/* entry chain  */
				/* entry chain  */
				/* entry chain  */
 
 
				/* adjust state variables  */
				(&instanceVarCopy)->stateVar = Active;
			}else{
				/* Intentionally left blank */
			} /*end of event selection */
		break; /* end of case Inactive  */
 
		default:
			/* Intentionally left blank */
		break;
	} /* end switch stateVar_root */
 
	/* Save the modified instance data */
	*instanceVar = instanceVarCopy;
}

Beside the state machine a UML class can also contain additional attributes and operations. Attributes are mapped as member variables of the state machine instance data. Operations are mapped to C-functions. The following example shows a class with an attribute and operation. Operations can be used beneficially to model entry/exit code or other helper functions. Attributes might represent internal variables of the stateful class.

For more details read section “Generating C Code” of the manual.

~~DISCUSSION|Leave your comments~~

Generating C++ Code

anonymous@undisclosed.example.com (Anonymous) — Fri, 02 May 2025 14:25:20 +0000

Generating C++ Code

Sinelabore supports C++ code generation. By default, the code generator uses only a subset of C++ to account for resource-constrained systems. In fact, only classes, public/protected/private member variables and methods are used. For more powerful systems, code generation using features of C++11 is supported if enabled (--std=c++11 for g++ or clang++). The various parameters allow you to customise the generated code to suit your needs. The quality of the generated code has been proven in practice by my many demanding customers using various lint-like tools without any problems.

To generate c++ code call the code generator with the command line flag ’-l cppx’.

The generated code does not follow the state pattern as you might expect (if you are familiar with common design patterns). The reason is that the machine code is completely generated and no hand-coding is involved. The following class diagram shows the structure of the generated classes.

The code generator supports code generation from models with regions and all other relevant state machine features. An example of a simplified microwave oven model is shown below. Regions allow the expression of parallelism within a state. A state may have two or more regions. A region contains states and transitions. Imagine how much effort it would be to write the code for this machine by hand. And even worse, how difficult it would be to maintain it over time as new states/events are added.

The signature of the event handler can be adapted to the own needs in a flexible way:

Basic signature:

int processEvent(const TESTCASE_EVENT_T msg);

Using a template parameter that allows elegant and flexible parameter handover:

template <typename T> 
int processEvent(const TESTCASE_EVENT_T msg, const T& userdata);

Without any parameter:
```
int processEvent(void);
```
Command line parameter -Trace enables trace code generation
…

All details about the C++ backend are available in section “Generating C++ Code” of the manual.

Model Example and Generated Code

Assume that c++11 features are to be used to generate the code for the oven example shown. The following parameters have been set in the configuration file according to your needs.

UseEnumBaseTypes = YES
EnumBaseTypeForEvents = std::uint16_t
EnumBaseTypeForStates = std::uint32_t
ReturnAndProcessEventTypeOfStateMachine = std::uint16_t
InitializedFlagTypeOfStateMachine = std::uint16_t
VisibilityInitializedVar = private:
VisibilityStateVars = private:
CallInitializeInCtor = yes
NotUseRedundantVoidArgument=YES
EnableTrailingReturnType=YES
UseStdLibrary = YES

An excerpt of the generated code is listed here:

oven::oven()
{
  m_initialized=static_cast<std::uint16_t>(0U);
  initialize();
}
 
/* State names */
const std::array<std::string, 9> stateNames = { \
  "Inactive","Active","LightOn","LightOff","HighPower","LowPower","CookingPause","Cooking","RadiatorOff"};
 
/* Event names */
const std::array<std::string, 8> eventNames = { \
  "evPwrLow","evTimeout","evDec","evDoorOpen","evDoorClosed","evPwrHigh","evInc","NO_MSG"};
 
auto oven::getNameByState(const States state) const -> std::string {
  return (static_cast<const std::string>(stateNames[static_cast<std::uint32_t>(state)]));
}
 
auto oven::getNameByEvent(const OVEN_EVENT_T evt) const -> std::string {
  return (static_cast<const std::string>(eventNames[static_cast<std::uint16_t>(evt)]));
}
 
// Initialize method. Must be called once to init the machine
void oven::initialize(){
  //call on entry code of default states
  if(m_initialized==static_cast<std::uint16_t>(0U)){
    m_initialized=static_cast<std::uint16_t>(1U);
 
    //Create copy of statevar
    stateVarsCopy = stateVars;
 
    // Set state vars to default states
 
    stateVarsCopy.stateVar = States::Inactive; /* set init state of top state */
    stateVarsCopy.stateVarLight = States::LightOn; /* set init state of Light */
    stateVarsCopy.stateVarPower = States::LowPower; /* set init state of Power */
    stateVarsCopy.stateVarRadioator = States::RadiatorOff; /* set init state of Radioator */
 
    timer.create(OVEN_EVENT_T::evTimeout);
    uint8_t testResult = hardwareTest();
    if(testResult==0){
      stateVarsCopy.stateVar = States::Active;
    }else{
      stateVarsCopy.stateVar = States::Inactive;
    }
 
    // Copy state variables back
    stateVars = stateVarsCopy;
 
  }
 
}
 
 
// State machine event handler
auto oven::processEvent(const OVEN_EVENT_T msg) -> std::uint16_t {
 
  auto evConsumed = static_cast<std::uint16_t>(0U);
 
  //Create copy of statevar
  stateVarsCopy = stateVars;
 
 
  switch (stateVars.stateVar) {
 
    case States::Active:
      /* calling region code */
      evConsumed |= ovenLight(msg);
      evConsumed |= ovenPower(msg);
      evConsumed |= ovenRadioator(msg);
 
      /* Check if event was already processed  */
      if(evConsumed==static_cast<std::uint16_t>(0)){
 
        if(msg==OVEN_EVENT_T::evDec){
          /* Transition from Active to Active */
          validationHandler(States::Active, States::Active);
 
          /* Action code for transition  */
          timer.dec();
 
          /* adjust state variables  */
          stateVarsCopy.stateVar = States::Active;
        }else if(msg==OVEN_EVENT_T::evInc){
          /* Transition from Active to Active */
          validationHandler(States::Active, States::Active);
 
          /* Action code for transition  */
          timer.inc();
 
          /* adjust state variables  */
          stateVarsCopy.stateVar = States::Active;
        }else{
          /* Intentionally left blank */
        } /*end of event selection */
      }
    break; /* end of case Active  */
 
    case States::Inactive:
    break; /* end of case Inactive  */
 
    default:
      /* Intentionally left blank */
    break;
  } /* end switch stateVar_root */
 
  // Copy state variables back
  stateVars = stateVarsCopy;
 
  return (evConsumed);
} // end processEvent
 
/* Region code for state Light */
 
std::uint16_t oven::ovenLight(OVEN_EVENT_T msg){
 
  std::uint16_t evConsumed = 0U;
 
  switch (stateVars.stateVarLight) {
 
    case States::LightOff:
      if(msg==OVEN_EVENT_T::evDoorClosed){
        if(timer.preset()>0){
          /* Transition from LightOff to LightOn */
          validationHandler(States::LightOff, States::LightOn);
          evConsumed=static_cast<std::uint16_t>(1U);
 
          /* Action code for transition  */
          switchLight(T_LIGHT::L_ON);
 
 
          /* adjust state variables  */
          stateVarsCopy.stateVarLight = States::LightOn;
        }else{
          /* Intentionally left blank */
        } /*end of event selection */
      }else{
        /* Intentionally left blank */
      } /*end of event selection */
    break; /* end of case LightOff  */
 
    case States::LightOn:
      if(msg==OVEN_EVENT_T::evDoorOpen){
        if(timer.preset()==0){
          /* Transition from LightOn to LightOff */
          validationHandler(States::LightOn, States::LightOff);
          evConsumed=static_cast<std::uint16_t>(1U);
 
          /* Action code for transition  */
          switchLight(T_LIGHT::L_OFF);
 
 
          /* adjust state variables  */
          stateVarsCopy.stateVarLight = States::LightOff;
        }else{
          /* Intentionally left blank */
        } /*end of event selection */
      }else{
        /* Intentionally left blank */
      } /*end of event selection */
    break; /* end of case LightOn  */
 
    default:
      /* Intentionally left blank */
    break;
  } /* end switch stateVar_root */
 
  return evConsumed;
}

The complete code is available in the examples folder of the code generator download.

The generated code does not rely on a library. It can be easily integrated into different system designs. An example is shown below. In this case, the state machine runs in a separate thread and receives events via an event queue. This is a typical usage pattern in embedded real-time systems.

std::thread eventHandlerThread() {
  my_oven* machine = new my_oven();
  machine->initialize();
  while (true) {
    OVEN_EVENT_T msg;
    q.waitAndPop(msg);
    machine->processEvent(msg);
  }
}

Summary

The C++ backend has proven itself with many users and guarantees the always consistent code quality through the generator. You can fully concentrate on the respective application. Download the demo and tryout the microwave_ea9_using_regions_cpp11 example.

Generating Java Code

anonymous@undisclosed.example.com (Anonymous) — Fri, 03 May 2024 20:42:03 +0000

Generating Java Code

To generate Java code call the code generator with the command line flag ’-l java’. The generator generates just one Java class which implements the complete state machine. This has the benefit that your Java project does not become bloated with all kinds of helper classes. If required an optional base class can be specified in the config file. Also the package (Namespace=…) can be defined there. The events that can be sent to the machine are defined in a public enumeration.

The following example shows how to use the generated code together with a GUI class based on a simple SWING application. Each time a button is pressed an event is sent to the state machine. Which then writes entry/exit code of the current state to the text window.

Class SMBase.java serves as bridge between the java GUI code and the generated state machine code.

The state machine that realises the behaviour of the button presses looks as follows:

The complete project file for Apache Netbeans can be downloaded here.

More information is available in the manual in section “Generating Java Code”.

Generating JavaScript code from UML state machine models

anonymous@undisclosed.example.com (Anonymous) — Fri, 03 May 2024 20:43:09 +0000

Generating JavaScript code from UML state machine models

Sinelabore creates compact and clearly readable JavaScript code from UML state machine diagrams. It has zero dependencies, and is useful for frontend and backend application logic.

Sinelabore enables event-driven programming to handle complex logic in predictable, robust, and visual ways.

To generate JavaScript code, call the code generator with the command line flag -l js or -l mjs depending on the file extension wanted. The content of the generated file is the same in both cases.

Example command to generate the oven machine code from a model file called oven.xml:

java -cp “../../*” codegen.Main -l js -p ssc -o oven oven.xml

By supporting JS code generation, Sinelabore users can now design state machines in UML and generate JS code from them. Which is undoubtedly a great advantage when thinking about the development of protocols between IoT devices and servers, for example. Or the development of device prototypes where a functioning GUI user interface based on HTML/JS can be emulated very easily.

How can You benefit from JS code generation?

Creating business logic

Create your business logic as state machines on either the client or server side. Create state machine diagrams without manual coding, allowing rapid prototyping or requirements gathering without worrying about the details of state machine implementation. The built-in model checker ensures that your state machine is always correct. Simulate your design to test and iterate using the built-in simulator. Or create a rapid prototype (see below) to get early feedback from your team and customers on how things should work.

Creating HMI prototypes for IoT or embedded devices

Prototypes are often needed to get quick feedback on design approaches or unclear requirements. This is where JS can play an important role. Thanks to its integration into HTML pages and its simple syntax, it enables the rapid development of functional prototypes. Users can then “play” with them and give direct feedback. This is shown here for a microwave oven. The oven can be controlled via a simple HTML page (the state machine is shown below).

Microwave oven GUI simulation based on a website

The event hander of the generated state machine is called at the appropriate points in the HTML page e.g. to forward the key presses to the generated event handler the following code used:

<script type="module">
         import { oven } from './oven.mjs';
         import { TimerManager } from './TimerManager.mjs';
 
         let myOven; // Declare my Oven in the outer scope
         const userData={
         };
 
         window.buttonDecClicked= function() {
             myOven.processEvent(myOven.events.evDec,userData)
         }
 
         window.buttonIncClicked=function() {
             myOven.processEvent(myOven.events.evInc,userData)
         }
 
         window.buttonOpenDoorClicked= function() {
             myOven.processEvent(myOven.events.evDoorOpen,userData)
         }
 
         window.buttonCloseDoorClicked=function() {
             myOven.processEvent(myOven.events.evDoorClosed,userData)
         }
      ...
}

The machine below realizes the behaviour of the oven. It uses hierarchical states with deep history and actions in various places. Two JS helper classes are used to interact with the GUI and to have timers available.

The machine realizes this behaviour:

The light and the oven will only become active when a time has been set and the door is closed
If the door is opened in between, the oven will be switched off and the time will stop. After closing the door, the oven continues to run at the old time.
The time can be changed at any time
…

A customer can work with this machine and interactively test whether the device really works as intended. For example, should the light stay on after the cooking time has elapsed even though the oven has not yet been opened? Such things can only be determined if you can “play” with your model.

The Sinelabore Code Generator provides all the functions necessary to work with the machine. In addition to the event handler, these are auxiliary functions, for example to find out what state (or states) the machine is in and much more. The complete code is available below:

Features of the JavaScript State Machine Code Generator

The code generator supports the following features:

Code generation from flat or hierarchical state machine models with or without regions. A region is an orthogonal part of a state. Regions allow to express parallelism within a state. A state can have two or more regions. Region contains states and transitions.
States and sub-states
Deep – and flat hierarchy
Entry, Exit and Action code of states
Choice pseudo-states
Transitions with event, guard and action
Final states
Trace code generation with command line parameter -Trace
UserData field for user defined variables to be used in the machine

As in the other backends too, code at the beginning of the generated JavaScript file can be specified with the header linked to the class in a UML diagram. Use this to define your imports or other local code. It is also possible to define pre- and post-action code of the generated state handler (see section 'Introduction' in the manual).

The generated code looks as follows for the oven state machine. The complete example is available on the sinelabore github site.

Generated JavaScript code from the Oven State Machine

/*
 * (c) Sinelabore Software Tools GmbH, 2008 - 2024
 *
 * All rights reserved. Reproduction, modification,
 * use or disclosure to third parties without express
 * authority is forbidden.
 */
 
/* Command line options: -l mjs -p ssc -o oven oven.xml  */
/* This file is generated from oven.xml - do not edit manually */
/* Generated on: Wed Jan 17 19:50:24 CET 2024 / Version 6.2.1B13753*/
 
 
 
import { TimerManager } from './TimerManager.mjs';
import { DisplayInterface } from './DisplayInterface.mjs';
 
 
export function oven() {
 
  this.init =  false;
  this.instId = 0;
  // State machine state data
  this.stateVars = {
    stateVar: null,
    stateVarMainRegion : null,
    stateVarCookingRegion : null,
  };
 
  // States of the state machine 
  this.states = Object.freeze({
      none: 0,
      Super: 1,
      Completed: 2,
      Cooking: 3,
      CookingPause: 4,
      Idle: 5,
      TimeNotShown: 6,
      TimeShown: 7,
    })
 
  // Events the state machine can process
  this.events = Object.freeze({
      none: 0,
      evTimeout: 1,
      evDec: 2,
      evDoorOpen: 3,
      evDoorClosed: 4,
      evInc: 5,
      evPwr: 6,
      evBlink: 7,
    })
 
 
  // Initialize state machine
  this.initialize = function(){
    this.init = true;
    // Set state vars to default states
    this.stateVars.stateVar = this.states.Super /* set init state of top state */
    this.stateVars.stateVarMainRegion = this.states.Idle; /* set init state of MainRegion */
    this.stateVars.stateVarCookingRegion = this.states.TimeShown; /* set init state of CookingRegion */
 
    this.tid = document.timerMgr.createTimer(0, this.events.evTimeout);
    this.tidBlink = document.timerMgr.createTimer(500, this.events.evBlink);
    this.display = new DisplayInterface();
    console.log("Oven Off");
 
 
  }
 
  this.isInSuper = function() { return (this.stateVars.stateVar === this.states.Super);}
  this.isInTimeNotShown = function() { return (this.stateVars.stateVarCookingRegion === this.states.TimeNotShown) && this.isInCooking();}
  this.isInTimeShown = function() { return (this.stateVars.stateVarCookingRegion === this.states.TimeShown) && this.isInCooking();}
  this.isInCompleted = function() { return (this.stateVars.stateVarMainRegion === this.states.Completed) && this.isInSuper();}
  this.isInCooking = function() { return (this.stateVars.stateVarMainRegion === this.states.Cooking) && this.isInSuper();}
  this.isInCookingPause = function() { return (this.stateVars.stateVarMainRegion === this.states.CookingPause) && this.isInSuper();}
  this.isInIdle = function() { return (this.stateVars.stateVarMainRegion === this.states.Idle) && this.isInSuper();}
 
  //Return the state name string based on the state value
  this.stateToString = function(stateValue) {
    const value = Object.keys(this.states).find(key => this.states[key] === stateValue);
    return value || `UnknownState(${stateValue})`;
  }
 
  //Return the event name string based on the event value
  this.eventToString = function(eventValue) {
    const value = Object.keys(this.events).find(key => this.events[key] === eventValue);
    return value || `UnknownEvent(${eventValue})`;
  }
 
 
  // Return of a map with the states in which the state machine is currently in
  this.innermostActiveStates = function() {
    var statesMap = new Map();
    if ( this.isInCompleted() ) {statesMap.set(this.states.Completed,"Completed");}
    if ( this.isInTimeShown() ) {statesMap.set(this.states.TimeShown,"TimeShown");}
    if ( this.isInTimeNotShown() ) {statesMap.set(this.states.TimeNotShown,"TimeNotShown");}
    if ( this.isInCookingPause() ) {statesMap.set(this.states.CookingPause,"CookingPause");}
    if ( this.isInIdle() ) {statesMap.set(this.states.Idle,"Idle");}
    return statesMap;
  }
 
 
  // State machine event handler
  this.processEvent = function(msg, userData) {
    var evConsumed=0;
    if (this.init === false) {
      this.initialize()
    }
 
    // Copy stateVar to ensure regions have same view on machine
    this.stateVarsCopy = Object.assign({}, this.stateVars);		
      // Action code 
      /* Action - sample */
      console.log(this.eventToString(msg));
 
 
 
    switch (this.stateVars.stateVar) {
 
      case this.states.Super:
        /* calling region code */
        evConsumed |= this.processEventMainRegion(msg, userData);
 
        /* Check if event was already processed */
        if(evConsumed===0){
 
          if (msg === this.events.evDec) {
            /* Transition from Super to Super*/
 
            /* Exit code for regions in state Super*/
 
            if(this.stateVars.stateVarMainRegion == this.states.Cooking){
 
            }else {
              /* Intentionally left blank */
            };
 
 
            /* Action code for transition */
            document.timerMgr.decTimer(this.tid);
            this.display.setTT(document.timerMgr.getPreset(this.tid));
 
 
            /* Entry code for regions in state Super*/
            console.log("Oven Off");
            /* Default in entry chain */
            this.stateVarsCopy.stateVarMainRegion = this.states.Idle;/* Default in entry chain */
 
 
            /* adjust state variables */
            this.stateVarsCopy.stateVar = this.states.Super;
          } else if (msg === this.events.evInc) {
            /* Transition from Super to Super*/
 
            /* Exit code for regions in state Super*/
 
            if(this.stateVars.stateVarMainRegion == this.states.Cooking){
 
            }else {
              /* Intentionally left blank */
            };
 
 
            /* Action code for transition */
            document.timerMgr.incTimer(this.tid);
            this.display.setTT(document.timerMgr.getPreset(this.tid));
 
 
            /* Entry code for regions in state Super*/
            console.log("Oven Off");
            /* Default in entry chain */
            this.stateVarsCopy.stateVarMainRegion = this.states.Idle;/* Default in entry chain */
 
 
            /* adjust state variables */
            this.stateVarsCopy.stateVar = this.states.Super;
          } else if (msg === this.events.evPwr) {
            /* Transition from Super to Super*/
 
            /* Exit code for regions in state Super*/
 
            if(this.stateVars.stateVarMainRegion == this.states.Cooking){
 
            }else {
              /* Intentionally left blank */
            };
 
 
            /* Action code for transition */
            console.log("Set Power");
 
 
            /* Entry code for regions in state Super*/
            console.log("Oven Off");
            /* Default in entry chain */
            this.stateVarsCopy.stateVarMainRegion = this.states.Idle;/* Default in entry chain */
 
 
            /* adjust state variables */
            this.stateVarsCopy.stateVar = this.states.Super;
          } else {
            /* Intentionally left blank*/
          } /*end of event selection*/
        }
      break; /* end of case Super */
 
      default:
        /* Intentionally left blank*/
      break;
    } /* end switch stateVar_root*/
 
  // Post Action Code
    /* Post-Action - sample */
 
 
    this.stateVars = Object.assign({}, this.stateVarsCopy);		
    return evConsumed
  }
 
 
 
  // Region code for region CookingRegion
  this.processEventCookingRegion = function(msg, userData) {
    var evConsumed = 0;
 
 
    switch (this.stateVars.stateVarCookingRegion) {
 
      case this.states.TimeShown:
        if (msg === this.events.evBlink) {
          /* Transition from TimeShown to TimeNotShown*/
          evConsumed=1;
 
          /* Action code for transition */
          this.display.setTT("");
 
 
          /* adjust state variables */
          this.stateVarsCopy.stateVarCookingRegion = this.states.TimeNotShown;
        } else {
          /* Intentionally left blank*/
        } /*end of event selection*/
      break; /* end of case TimeShown */
 
      case this.states.TimeNotShown:
        if (msg === this.events.evBlink) {
          /* Transition from TimeNotShown to TimeShown*/
          evConsumed=1;
 
          /* Action code for transition */
          this.display.setTT(document.timerMgr.getPreset(this.tid));
 
 
          /* adjust state variables */
          this.stateVarsCopy.stateVarCookingRegion = this.states.TimeShown;
        } else {
          /* Intentionally left blank*/
        } /*end of event selection*/
      break; /* end of case TimeNotShown */
 
      default:
        /* Intentionally left blank*/
      break;
    } /* end switch stateVar_root*/
 
    return evConsumed;
  }
 
 
 
  // Region code for region MainRegion
  this.processEventMainRegion = function(msg, userData) {
    var evConsumed = 0;
  var eventConsumedCookingRegion = 0
 
 
    switch (this.stateVars.stateVarMainRegion) {
 
      case this.states.Completed:
        if (msg === this.events.evDoorOpen) {
          /* Transition from Completed to Idle*/
          evConsumed=1;
 
          /* Action code for transition */
          document.getElementById("myImage").src = "images/oven_open_off.png";
 
          /* OnEntry code of state Idle*/
          console.log("Oven Off");
 
          /* adjust state variables */
          this.stateVarsCopy.stateVarMainRegion = this.states.Idle;
        } else {
          /* Intentionally left blank*/
        } /*end of event selection*/
      break; /* end of case Completed */
 
      case this.states.Cooking:
        /* calling region code */
        evConsumed |= this.processEventCookingRegion(msg, userData);
 
        /* Check if event was already processed */
        if(evConsumed===0){
 
          if (msg === this.events.evDoorOpen) {
            /* Transition from Cooking to CookingPause*/
            evConsumed=1;
 
            /* Exit code for regions in state Cooking*/
 
            /* Action code for transition */
            console.log("Oven Off");
            document.timerMgr.pauseTimer(this.tid);
            this.display.updateImage("images/oven_open_off.png");
 
 
            /* adjust state variables */
            this.stateVarsCopy.stateVarMainRegion = this.states.CookingPause;
          } else if (msg === this.events.evTimeout) {
            /* Transition from Cooking to Completed*/
            evConsumed=1;
 
            /* Exit code for regions in state Cooking*/
 
            /* Action code for transition */
            console.log("Oven Off");
            document.timerMgr.stopTimer(this.tid);
            document.timerMgr.stopTimer(this.tidBlink);
            this.display.updateImage("images/oven_closed_off.png");
 
 
            /* adjust state variables */
            this.stateVarsCopy.stateVarMainRegion = this.states.Completed;
          } else {
            /* Intentionally left blank*/
          } /*end of event selection*/
        }
      break; /* end of case Cooking */
 
      case this.states.CookingPause:
        if (msg === this.events.evDoorClosed) {
          /* Transition from CookingPause to Cooking*/
          evConsumed=1;
 
          /* Action code for transition */
          document.timerMgr.continueTimer(this.tid);
          this.display.updateImage("images/oven_closed_on.png");
 
 
          /* Entry code for regions in state Cooking*/
          /* Default in entry chain */
          this.stateVarsCopy.stateVarCookingRegion = this.states.TimeShown;/* Default in entry chain */
 
 
          /* adjust state variables */
          this.stateVarsCopy.stateVarMainRegion = this.states.Cooking;
        } else {
          /* Intentionally left blank*/
        } /*end of event selection*/
      break; /* end of case CookingPause */
 
      case this.states.Idle:
        if (msg === this.events.evDoorClosed) {
          if (document.timerMgr.getPreset(this.tid)) {
            /* Transition from Idle to Cooking*/
            evConsumed=1;
 
            /* Action code for transition */
            document.timerMgr.startTimer(this.tid,false);
            document.timerMgr.startTimer(this.tidBlink,true);
            this.display.updateImage("images/oven_closed_on.png");
 
 
            /* Entry code for regions in state Cooking*/
            /* Default in entry chain */
            this.stateVarsCopy.stateVarCookingRegion = this.states.TimeShown;/* Default in entry chain */
 
 
            /* adjust state variables */
            this.stateVarsCopy.stateVarMainRegion = this.states.Cooking;
          } else {
            /* Transition from Idle to Idle*/
            evConsumed=1;
 
            /* Action code for transition */
            this.display.updateImage("images/oven_closed_off.png");
 
            /* OnEntry code of state Idle*/
            console.log("Oven Off");
 
            /* adjust state variables */
            this.stateVarsCopy.stateVarMainRegion = this.states.Idle;
          } /*end of event selection*/
        } else if (msg === this.events.evDoorOpen) {
          /* Transition from Idle to Idle*/
          evConsumed=1;
 
          /* Action code for transition */
          this.display.updateImage("images/oven_open_off.png");
 
          /* OnEntry code of state Idle*/
          console.log("Oven Off");
 
          /* adjust state variables */
          this.stateVarsCopy.stateVarMainRegion = this.states.Idle;
        } else {
          /* Intentionally left blank*/
        } /*end of event selection*/
      break; /* end of case Idle */
 
      default:
        /* Intentionally left blank*/
      break;
    } /* end switch stateVar_root*/
 
    return evConsumed;
  }
 
 
}

Generating Python Code

anonymous@undisclosed.example.com (Anonymous) — Sat, 15 Jun 2024 18:08:13 +0000

Generating Python Code

To generate Python code call the code generator with the command line flag ’-l python’.

The generator generates just a Python class which implements the complete state machine. This has the benefit that your Python project does not become bloated with all kinds of helper classes. If required an optional base class can be specified in the configuration file. To get started the microwave oven project from the introduction section is is available on GitHub. It is a fully running example. A GUI realized with Tkinker allows you to send events to the state machine and observe the state machine reaction.

Example Code:

''' Command line options: -l PYTHON -p ssc -o oven oven.xml  '''
''' This file is generated from oven.xml - do not edit manually '''
''' Generated on: Tue Jan 01 19:08:22 CET 2019 / version 3.7.3'''
 
 
from oven_base import *
 
class oven(oven_base):
 
	def __init__(self, errorhandler=None):
 
		''' Set state vars to default states '''
		self.stateVar = "Super" # set init state of top state 
		self.stateVarSuper = "Idle" # set init state of Super
 
 
		''' call on entry code of default states '''
		self.radiator.ovenOff();
 
 
 
		self.events = {
			'evPwrLow',
			'evTimeout',
			'evDec',
			'evDoorOpen',
			'evDoorClosed',
			'evPwrHigh',
			'evInc',
			'OVEN_NO_MSG'
		}
 
		self.eventConsumed=False
 
		if errorhandler is None:
			self.ehlr=self.errorhandler
		else:
			self.ehlr=errorhandler
 
 
	def errorhandler(self, msg):
		print ("Error:"  + msg)
 
 
	def processEvent(self,  event):
 
		self.eventConsumed=False
 
 
 
		# action code
		# just a comment
 
 
 
 
		if self.stateVar == "Super":
 
 
 
			if self.stateVarSuper == "Completed":
				if event=="evDoorOpen":
					''' Transition from Completed to Idle'''
					self.eventConsumed=True
 
					''' OnEntry code of state Idle'''
					self.radiator.ovenOff();
 
					''' adjust state variables '''
					self.stateVarSuper = "Idle";
				else:
					pass  #Intentionally left blank
 
 
 
			elif self.stateVarSuper == "Cooking":
				if event=="evDoorOpen":
					''' Transition from Cooking to CookingPause'''
					self.eventConsumed=True
 
					''' Action code for transition '''
					self.radiator.ovenOff();
					self.tm.pause();
 
 
					''' adjust state variables '''
					self.stateVarSuper = "CookingPause";
				elif event=="evTimeout":
					''' Transition from Cooking to Completed'''
					self.eventConsumed=True
 
					''' Action code for transition '''
					self.radiator.ovenOff();
					self.tm.clear();
 
 
					''' adjust state variables '''
					self.stateVarSuper = "Completed";
				else:
					pass  #Intentionally left blank
 
 
 
			elif self.stateVarSuper == "CookingPause":
				if event=="evDoorClosed":
					''' Transition from CookingPause to Cooking'''
					self.eventConsumed=True
 
					''' Action code for transition '''
					self.tm.cont();
 
					''' OnEntry code of state Cooking'''
					self.radiator.ovenOn();
 
					''' adjust state variables '''
					self.stateVarSuper = "Cooking";
				else:
					pass  #Intentionally left blank
 
 
 
			elif self.stateVarSuper == "Idle":
				if event=="evDoorClosed":
					if self.tm.preset()>0:
						''' Transition from Idle to Cooking'''
						self.eventConsumed=True
 
						''' Action code for transition '''
						self.tm.start();
 
						''' OnEntry code of state Cooking'''
						self.radiator.ovenOn();
 
						''' adjust state variables '''
						self.stateVarSuper = "Cooking";
					else:
						pass  #Intentionally left blank
 
				else:
					pass  #Intentionally left blank
 
 
 
 
 
			''' Check if event was already processed '''
			if self.eventConsumed !=True:
 
				if event=="evDec":
					''' Transition from Super to Super'''
					self.eventConsumed=True
 
					''' Action code for transition '''
					self.tm.dec();
 
					self.stateVar = "Super";''' entry chain '''
					if self.stateVarSuper== "Cooking":
						self.radiator.ovenOn();
 
					elif self.stateVarSuper== "Idle":
						self.radiator.ovenOff();
 
					###
 
				elif event=="evInc":
					''' Transition from Super to Super'''
					self.eventConsumed=True
 
					''' Action code for transition '''
					self.tm.inc();
 
					self.stateVar = "Super";''' entry chain '''
					if self.stateVarSuper== "Cooking":
						self.radiator.ovenOn();
 
					elif self.stateVarSuper== "Idle":
						self.radiator.ovenOff();
 
					###
 
				elif event=="evPwrHigh":
					''' Transition from Super to Super'''
					self.eventConsumed=True
 
					''' Action code for transition '''
					self.radiator.ovenSetPwrHigh();
 
					self.stateVar = "Super";''' entry chain '''
					if self.stateVarSuper== "Cooking":
						self.radiator.ovenOn();
 
					elif self.stateVarSuper== "Idle":
						self.radiator.ovenOff();
 
					###
 
				elif event=="evPwrLow":
					''' Transition from Super to Super'''
					self.eventConsumed=True
 
					''' Action code for transition '''
					self.radiator.ovenSetPwrLow();
 
					self.stateVar = "Super";''' entry chain '''
					if self.stateVarSuper== "Cooking":
						self.radiator.ovenOn();
 
					elif self.stateVarSuper== "Idle":
						self.radiator.ovenOff();
 
					###
 
				else:
					pass  #Intentionally left blank
 
 
 
 
 
		return self.eventConsumed

Generating Rust Code

anonymous@undisclosed.example.com (Anonymous) — Fri, 03 May 2024 20:42:50 +0000

Generating Rust Code

Rust a is a relatively new programming language aiming to guarantee memory-safety and thread-safety. Rust is fast and memory-efficient with no runtime or garbage collector. More information about Rust is available at https://www.rust-lang.org To generate Rust code call the code generator with the following commandline flag −l Rust. The generated code is using basic Rust features like match, if/then/else and can easily be understood.

The output name -o test defines the generated state machine file name (Note the lower case ’t’ to follow Rust convention), the name of the state machine type and the prefix for the event and state enums.

The following image shows a simple microwave oven in the integrated state machine editor.

Code generation works as follows:

java -cp "path to installation/bin/*" codegen.Main -l rust -p ssc -o oven oven.xml

The fully generated Rust code from the oven state machine looks as follows:

/* Command line options: -Trace -l rust -p ssc -o oven oven.xml   */
/* This file is generated from oven.xml - do not edit manually  */
/* Generated on: Mon Nov 28 17:57:40 CET 2022 / Version 5.5.5.5 */
 
 
use std::fmt;
 
 
/// States in which the state machine can be
#[derive(Debug,PartialEq,Copy,Clone)]
pub enum OvenStates{
	Super,
	Completed,
	Cooking,
	CookingPause,
	Idle,
}
 
impl fmt::Display for OvenStates {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match *self {
			OvenStates::Super => write!(f, "Super"),
			OvenStates::Completed => write!(f, "Completed"),
			OvenStates::Cooking => write!(f, "Cooking"),
			OvenStates::CookingPause => write!(f, "CookingPause"),
			OvenStates::Idle => write!(f, "Idle"),
		}
	}
}
 
 
/// Events that can be sent to the state machine
#[derive(Debug,PartialEq,Copy,Clone)]
pub enum OvenEvents {
	EvDec,
	EvTimeout,
	EvDoorClosed,
	EvDoorOpen,
	EvPowerLow,
	EvPowerHigh,
	EvInc,
	OvenNoMsg,
}
 
 
impl fmt::Display for OvenEvents {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match *self {
			OvenEvents::EvDec => write!(f, "EvDec"),
			OvenEvents::EvTimeout => write!(f, "EvTimeout"),
			OvenEvents::EvDoorClosed => write!(f, "EvDoorClosed"),
			OvenEvents::EvDoorOpen => write!(f, "EvDoorOpen"),
			OvenEvents::EvPowerLow => write!(f, "EvPowerLow"),
			OvenEvents::EvPowerHigh => write!(f, "EvPowerHigh"),
			OvenEvents::EvInc => write!(f, "EvInc"),
			OvenEvents::OvenNoMsg => write!(f, "OvenNoMsg"),
		}
	}
}
 
 
#[macro_export]
macro_rules! def_fsm{
	($data_t:ty , $timer_service_t:ty $(,$element:ident: $ty:ty = $ex:expr)*) => {
 
	/* State machine struct
	 * is_init flag indicates whether the machine event handler was called the first time 
	 * state_var is the top level state variable 
	 * StateXXX are the state variables for hierachical or regions 
	 */
	#[derive(Debug,Copy,Clone)]
	pub struct Oven {
		pub is_init: bool,
		pub state_var: OvenStates,
		pub state_varmain_region: OvenStates,
		/* Start of user defined attributes */
		$($element: $ty),*
		/* End of user defined attributes */
	}
 
	impl Default for Oven {
		fn default() -> Self{
			Oven {
				is_init : false,
				state_var : OvenStates::Super, /* Set init for top level state */
				state_varmain_region : OvenStates::Idle, /* set init state of main_region */
 
				/* Start of user defined attributes */
				 $($element: $ex),*
				/* End of user defined attributes */
			}
		}
	}
 
	impl Oven{
		pub fn handle_event(&mut self, ev: OvenEvents,
			data:$data_t, timer_service:$timer_service_t
			) -> usize {
 
 
			let ev_consumed : usize;
 
			// Create copy of statevar
			let mut fsm_clone : Oven = self.clone();
 
			if self.is_init == false {
				fsm_clone.is_init = true;
				fsm_clone.initialize(data, timer_service);
			}
 
			// Action code
			/* just a comment */
 
			ev_consumed = fsm_clone.oven_main_machine(ev, data, timer_service);
 
			// Copy state variables back
			*self = fsm_clone;
 
			return ev_consumed;
		}
 
 
 
 
		/* Region code for state main_region */
 
		fn oven_main_region(&mut self, ev: OvenEvents,
			data:$data_t, timer_service:$timer_service_t) -> usize {
 
			let mut ev_consumed : usize = 0;
 
			match self.state_varmain_region {
 
				OvenStates::Completed => {
					if ev == OvenEvents::EvDoorOpen {
						/* Transition from Completed to Idle */
						ev_consumed=1;
 
						/* OnEntry code of state Idle */
						data.oven_off();
 
						/* adjust state variables  */
						self.state_varmain_region = OvenStates::Idle;
						data.log("Completed".to_string(), "Idle".to_string(), "EvDoorOpen".to_string());
					} else {
						/* Intentionally left blank */
					} /* End of event selection */
				} /* end of match Completed  */
 
				OvenStates::Cooking => {
					if ev == OvenEvents::EvDoorOpen {
						/* Transition from Cooking to CookingPause */
						ev_consumed=1;
 
						/* Action code for transition  */
						data.oven_off();
						timer_service.pause(self.timer_id);
 
 
						/* adjust state variables  */
						self.state_varmain_region = OvenStates::CookingPause;
						data.log("Cooking".to_string(), "CookingPause".to_string(), "EvDoorOpen".to_string());
					} else if ev == OvenEvents::EvTimeout {
						/* Transition from Cooking to Completed */
						ev_consumed=1;
 
						/* Action code for transition  */
						data.oven_off();
						timer_service.stop(self.timer_id);
 
						/* OnEntry code of state Completed */
						self.time=0;
 
						/* adjust state variables  */
						self.state_varmain_region = OvenStates::Completed;
						data.log("Cooking".to_string(), "Completed".to_string(), "EvTimeout".to_string());
					} else {
						/* Intentionally left blank */
					} /* End of event selection */
				} /* end of match Cooking  */
 
				OvenStates::CookingPause => {
					if ev == OvenEvents::EvDoorClosed {
						/* Transition from CookingPause to Cooking */
						ev_consumed=1;
 
						/* Action code for transition  */
						timer_service.cont(self.timer_id);
 
						/* OnEntry code of state Cooking */
						data.oven_on();
 
						/* adjust state variables  */
						self.state_varmain_region = OvenStates::Cooking;
						data.log("CookingPause".to_string(), "Cooking".to_string(), "EvDoorClosed".to_string());
					} else {
						/* Intentionally left blank */
					} /* End of event selection */
				} /* end of match CookingPause  */
 
				OvenStates::Idle => {
					if ev == OvenEvents::EvDoorClosed {
						if self.time > 0 {
							/* Transition from Idle to Cooking */
							ev_consumed=1;
 
							/* Action code for transition  */
							timer_service.start(self.timer_id, self.time);
 
							/* OnEntry code of state Cooking */
							data.oven_on();
 
							/* adjust state variables  */
							self.state_varmain_region = OvenStates::Cooking;
							data.log("Idle".to_string(), "Cooking".to_string(), "EvDoorClosed[self.time > 0]".to_string());
						} else {
							/* Intentionally left blank */
						} /* End of event selection */
					} else {
						/* Intentionally left blank */
					} /* End of event selection */
				} /* end of match Idle  */
 
				_ => {
					/* Intentionally left blank */
				 }
			 } /* End match stateVar_root */
 
			return ev_consumed;
		}
 
 
		pub fn initialize(&mut self, data:$data_t, timer_service:$timer_service_t){
			self.is_init = true;
 
 
			self.timer_id = timer_service.create(TimerType::SingleShot,OvenEvents::EvTimeout);
			data.oven_off();
 
 
		}
 
 
		fn oven_main_machine(&mut self, ev: OvenEvents,
			data:$data_t, timer_service:$timer_service_t) -> usize {
 
 
			let mut ev_consumed : usize = 0;
 
 
			match self.state_var {
 
				OvenStates::Super => {
					/* calling region code */
					ev_consumed |= self.oven_main_region(ev, data, timer_service);
 
					/* Check if event was already processed  */
					if ev_consumed==0{
 
						if ev == OvenEvents::EvDec {
							/* Transition from Super to Super */
 
							/* Exit code for regions in state Super */
 
							/* Action code for transition  */
							if self.time >= 1000{self.time += 1000;}
 
 
 
							/* Entry code for regions in state Super */
							data.oven_off();
							/* Default in entry chain  */
							self.state_varmain_region = OvenStates::Idle;/* Default in entry chain  */
 
 
							/* adjust state variables  */
							self.state_var = OvenStates::Super;
							data.log("Super".to_string(), "Super".to_string(), "EvDec".to_string());
						} else if ev == OvenEvents::EvInc {
							/* Transition from Super to Super */
 
							/* Exit code for regions in state Super */
 
							/* Action code for transition  */
							self.time += 1000;
 
 
							/* Entry code for regions in state Super */
							data.oven_off();
							/* Default in entry chain  */
							self.state_varmain_region = OvenStates::Idle;/* Default in entry chain  */
 
 
							/* adjust state variables  */
							self.state_var = OvenStates::Super;
							data.log("Super".to_string(), "Super".to_string(), "EvInc".to_string());
						} else if ev == OvenEvents::EvPowerHigh {
							/* Transition from Super to Super */
 
							/* Exit code for regions in state Super */
 
							/* Action code for transition  */
							data.oven_set_pwr(2000);
 
 
							/* Entry code for regions in state Super */
							data.oven_off();
							/* Default in entry chain  */
							self.state_varmain_region = OvenStates::Idle;/* Default in entry chain  */
 
 
							/* adjust state variables  */
							self.state_var = OvenStates::Super;
							data.log("Super".to_string(), "Super".to_string(), "EvPowerHigh".to_string());
						} else if ev == OvenEvents::EvPowerLow {
							/* Transition from Super to Super */
 
							/* Exit code for regions in state Super */
 
							/* Action code for transition  */
							data.oven_set_pwr(400);
 
 
							/* Entry code for regions in state Super */
							data.oven_off();
							/* Default in entry chain  */
							self.state_varmain_region = OvenStates::Idle;/* Default in entry chain  */
 
 
							/* adjust state variables  */
							self.state_var = OvenStates::Super;
							data.log("Super".to_string(), "Super".to_string(), "EvPowerLow".to_string());
						} else {
							/* Intentionally left blank */
						} /* End of event selection */
					}
				} /* end of match Super  */
 
				_ => {
					/* Intentionally left blank */
				 }
			 } /* End match stateVar_root */
			return ev_consumed;
		}
 
 
	}
};
}

The generator uses the macro features of Rust. A concrete type of a machine must be defined by using a def_fsm call before the machine can be used.

// define state machine
def_fsm!(&mut UserData, &mut crate::Timers<OvenEvents>, timer_id:usize=99,time:u32=0);
let mut timers = Timers::new();
let mut myfsm : Oven = Default::default();
let mut msg = OvenEvents::EvInc;
myfsm.handle_event(msg, &mut data, &mut timers);
...

The first macro parameter is a user defined type used as a parameter of the state machine handler. It is available inside the event handler with variable name data and type UserData.

The intended purpose is to provide a way for the user to hand over any kind of data to the state machine handler function which can then be used in the state machine. A simple use case is to hand over variables that acts as guards in state transitions.

The other intended purpose is that the UserData type must provide a logger function of a predefined signature in case the state machine was generated with the trace command line parameter -Trace. This allows to trace the state transitions and event flow.

The second macro parameter allows to hand over another user defined type intended to realize a timer service. Whether the state machine needs and uses a timer service and how it is implemented is totally in the user's hand. A microwave oven example is provided in the samples folder. It implemets a basic timer service for realizing the timeout for the cooking time.

Note: presently there is no possibliy to avoid the handover of the UserData and Timer struct. This might change in later versions.

All further parameters are optional and simply added to the state machine struct. In the code above an example with parameters x and y is shown.

The complete example is available here. Built it with cargo build and then run it with cargo run. In the src folder you will find command line examples how to model the state machine and build the Rust code. If you run the code type in events and send them to the state machine handler by pressing return.

You should see this output on the command line:

cargo run
...
Oven demo program written in Rust
Type in one or more commands and then press return to send them to the state machine
Supported commands:
   o to open the door
   c to close the door
   + to increase the cooking time
   - to decrease the door
   P set oven power to high
   p set oven power to low

How to go on from here:

Download the codegen which includes all the examples
Modify the state machine model file and re-generate the Rust code again and explore your changes.
Read the manual about all the functions the code generator provides

Please note that the Rust back-end is work-in-progress. Your feedback is highly welcome!