SinelaboreRT - wiki:howto

Astah* Howto

anonymous@undisclosed.example.com (Anonymous) — Thu, 21 May 2020 15:22:28 +0000

Astah* Howto

See “The code generator has problems to find Astah models” in the Java FAQ

How to use state machines generated by Sinelabore with the CubeMX tool from STM

anonymous@undisclosed.example.com (Anonymous) — Wed, 11 Oct 2023 19:11:58 +0000

How to use state machines generated by Sinelabore with the CubeMX tool from STM

This example shows how easy it is to add statemachines to STM32 CubeMX projects.

The example was created for the STM32F103C8T, for which very cheap eval boards are available.

The graphic shows the typical development flow for a CubeMX project and where the Sinelabore State Machine Generator comes into play.

In the example, CMSIS RTOS API is used with 2 tasks, a message queue and a timer. The state machine runs in Task02 and receives its events from the timer callback function cyclicTimer0Callback. And also from the default task. The state machine is kept simple and generates a blinking pattern that is terminated after some time by a FailSafe event.

The Statemachine was created with the integrated Statediagram Editor. To modify the machine, start the editor, load the model and regenerate the code after your changes.

Follow the steps below to create the example itself. It is assumed that you have installed the GNU Arm compiler tools and a debug interface. Links to the tools you need can be found below.

Download the demo project zip and unzip it
Create a project folder
Copy the project file to your project folder and load the project with the CubeMX programme.
Generate the complete project code from it into the project folder.
Replace the generated Makefile with the modified Makefile provided in the demo project folder. The modified Makefile contains the state machine C/H path.
Finally replace main.c in the Core/Src folder with the demo version. It contains the application from two tasks.

Now you can call make and flash the created elf file into the board with the debugger.

In one console run the debug stub;

/opt/homebrew/bin/st-util

In another console run the debugger:

/Applications/ARM/bin/arm-none-eabi-gdb
target remote 192.168.6.191:4242
load build/example.elf
file build/example.elf
c

The ARM Tools and CubeMX make it super easy to get started with the STM uC family and the Sinelabore Statemachine Generator completes the toolschain perfectly.

Enterprise Architect HowTo

anonymous@undisclosed.example.com (Anonymous) — Sun, 04 Aug 2024 12:12:51 +0000

Enterprise Architect HowTo

Below some tips and tricks are listed that simplify the state-chart creation using Enterprise Architect. If you have further hints let us know and we add them here. For a short intro on on how to use EA with the codegen go on reading here.

Where to put the events to:

States should be put “below” the class containing the state diagram. See next figure.

How to define the path to the state machine:

Since version 9.0 of Enterprise architect it looks like that always a view package is required. This package must appear in the path you specify on the codegen command line. In the figure above the path to the state machine is -t “Model:test:testclass”

I always get the error message ‘Can't find path element ….’. But I’m sure the path is correct:

Most probably you have not selected to root element (e.g. Model in the figure above) before exporting the XMI file. Select the root model element and then export to XMI.

How to specify multiple lines entry/exit/do action code:

So far there were two ways. The codegen took the name of the action as code. To specify multiple lines it was necessary to specify several actions. The other option was to attach a comment to a state and define the code there.

Now with EA 9.2 it is possible to specify multiple lines of action code in the behavior field. The name of the action is not used anymore as code line if code is found in the behavior field. The strange thing is that EA allows to define initial code which is unfortunately not exported in the normal XMI state tree. So it can't be used right now. In the example below two lines of entry code were added to S1.

Where do I find the “export to XMI” dialog?

In recent versions of EA the export to XMI is available under Publish → Export XMI

EA updates the model file when loading with the new EA17Beta. Notes that were previously linked to the class are incorrectly linked to the state diagram.

Link the Notes again with the class in which the state diagram is contained.

Java problems

anonymous@undisclosed.example.com (Anonymous) — Sat, 05 Dec 2020 16:11:22 +0000

Java problems

Java does not find the codegen or other jar files:

Newer Java version only accept the class path syntax. This means you have to update your Makefile or built scrips. The class path must be adjusted according your installation of course.

On Linux/Unix/Mac use the following format:
-cp ../../bin/*:../* codegen.Main

On Windows use this format (even displayed differently here use normal quotation marks):
-cp “..\..\bin\*;..\*” codegen.Main

The code generator has problems to find Astah models

The code generator uses the public API to access the Astah models. Therefore the Java class path must contain the path to the Astah Java API. The following class path shows how to do this. Take care to consider class path differences under Windows and Unix like systems.

-cp “..\..\bin\*;..\*;C:\Program Files\astah-professional\*” codegen.Main

Also make sure the file extension is according to the Astah rules. Otherwise Astah does not accept the files as input model:
For Astah Professional: .asta
For Astah SysML: .asml

Magic Draw

anonymous@undisclosed.example.com (Anonymous) — Mon, 24 Jan 2022 18:36:45 +0000

Magic Draw

I don't see the on-entry/on-exit/do code in my state diagram

Since MD version 19 (at least recognised it there) it is necessary to copy your code to the body text. See example below:

Is it necessary to specify an action name for on-entry/on-exit/do code?

If there is text in the name fieled (as shown above) it will be considered for code generation. If the name field is left empty the body part is used for code generation. The body text can be longer than one line. An example is shown below.

Modelio

anonymous@undisclosed.example.com (Anonymous) — Mon, 30 Sep 2013 18:11:31 +0000

Modelio

What options should I use for exporting a XMI file in Modelio 3

Select the following options:

How to use state machines with a real-time operating system

anonymous@undisclosed.example.com (Anonymous) — Sun, 12 Mar 2023 17:18:44 +0000

How to use state machines with a real-time operating system

State machines can be used in various places of your system. In this example you will learn how to use a state machine in the context of a RTOS (real-time operating system). For this exercise it does not really matter which RTOS you have in place. Because the general approach is always the same. Let's use FreeRTOS here.

FreeRTOS is a market-leading real-time operating system (RTOS) for microcontrollers and small microprocessors.

There is a Windows port layer which allows to quickly test how to use the state machine code generated by the SinelaboreRT code generator on your computer.

In this design pattern state machines run in the context of an own task. The principle design is shown in the following figure.

Each task executes a state machine (often called active object) in an endless while loop. The tasks wait for new events to be processed from the state machine. In case no event is present the task is set in idle mode from the RTOS. In case one or more new events are available the RTOS wakes up the task. The used RTOS mechanism for event signaling can be different. But often a message queue is used. Events might be stored in the event queue from various sources. E.g. from within another task or from inside an interrupt service routine from a timer which is shown in the code below. This design can be realised with every real-time operating system. Mainly the exact syntax differs from OS to OS.

Simple State Machine

The simple state machine below reacts on a cyclic timer. It just toggles between the two states SA and SB. It prints some text as demo when enter or leaving a state and when the transition takes place. In more complex systems more than one timer might be needed. If different timers are needed different timeout events and timers can be setup easily. See below.

Setup the system

This simple main code creates a task a queue and a timer and then starts the RTOS scheduler.

int main( void ){
    prvInitialiseHeap();
    vTraceEnable( TRC_START );
 
    xTaskCreate(tA, "TA", 1000 /*Bytes stack*/, NULL /* no parameters */,
        tskIDLE_PRIORITY + 1, NULL);
 
 
    /* Create the queue. */
    queueHandle = xQueueCreate(32, sizeof(USER_EVENT_T));
 
    timerHandle = xTimerCreate("Timer",	/* name for debugging */
        1000,                           /* ticks -> 1s */
        true,                           /* true = repetitive */
        NULL,                           /* The timer's ID is not used. */
        timerCallback);                 /* The function executed when the timer expires. */
 
    xTimerStart(timerHandle, 0);        /* The scheduler has not started so use a block time of 0. */
 
    vTaskStartScheduler();
}

TA task

The tasks waits blocking for elements to appear in the queue. If data is present in the queue we dequeue it and call the state machine.

static void tA(void* xTimerHandle){
    /* Avoid compiler warnings resulting from the unused parameter. */
    (void)xTimerHandle;
    USER_EVENT_T data = { SM_NO_MSG , 0 };
 
    while(true){
        printf("TA task.\r\n");
 
        /* Wait until something arrives in the queue - this task will block
        indefinitely. */
 
        // call once to init
        sm(&instDataSM, &data);
 
        while (true) {
            xQueueReceive(queueHandle, &data, portMAX_DELAY);        
            sm(&instDataSM, &data);
        }
    }
}

Timer

Each timer has a callback function called from the RTOS in case of a timeout happened. In the timer handler we simply enqueue a message with a timeout event (here evTimeout). We decided to sent some data in addition to the event. Therefore we defined an own data type (USER_EVENT_T) that is sent to the state machine. Otherwise it would be possible to just sent the event itself.

For clearness it is good to use some kind of guideline how events should be named. Here we call it evTimeout. If you have multiple timers call them e.g. according to their purpose.

/* This is the software timer callback function. This
    callback function will execute if the timer expires */
void timerCallback(TimerHandle_t xTimerHandle){
    static uint8_t cnt = 0;
    cnt++;
 
    USER_EVENT_T data = {evTimeout, cnt}; // evTimeout is used in the state diagram
 
    xQueueSend(queueHandle, &data, 0U);
}

Wrap-up

We showed how to use state machines in the context of FreeRTOS. This pattern can be universally used with any other RTOS too. Using this pattern allows a very flexibly system design and allows to design robust easy to understand real-time embedded systems. The relevant files are available here: freertos-code.zip

FreeRTOS, RTOS, Pattern]

Static Code Checkers

anonymous@undisclosed.example.com (Anonymous) — Thu, 09 Jun 2022 18:06:06 +0000

Static Code Checkers

Static program analysis is the analysis of computer software performed without executing any programs. Often the use of static code checkers is required in critical applications of different sort. Generally speaking the source code generated by sinelabore should create no or little issues. But some points should be considered (see below).

One of the well known tools in this category is PC-lint from Gimpel Soft (https://www.gimpel.com). Another free one is cppcheck. Generated C/C++ code is regularly tested with cppcheck and its misra checker. Details about cppcheck can be found here: https://cppcheck.sourceforge.io/manual.pdf

C-Code

For C-code the following parameter settings are suggested in the codegen.cfg file:

#It is recommended to set the following parameters to include the standard types.
#Additional include in the validate h file to provide data types
AdditionalValidateIncludes=#include <stdint.h>\n#include <stdbool.h>
#
# Include file which can be used to define the simple data types
AdditionalMachineInclude=#include <stdint.h>\n#include <stdbool.h>
#Setting the used types to avoid problems with boolean comparisons ...

UINT8 = uint8_t
UINT16 = uint16_t
BOOL=bool
BOOL_TRUE=true
BOOL_FALSE=false


#Avoid issues about not used variable
ReturnEventProcessed=yes

UseUnderlineForIncludeProtection=no

C++ Code

It is recommended to use the newer features of C++11.

#Avoid issues about not used variable
ReturnEventProcessed=yes

#Avoid issues of not initialised variables in the ctor
CallInitializeInCtor = yes

#This enables the uses of array ...
UseEnumBaseTypes = YES

EnumBaseTypeForEvents = std::uint16_t
EnumBaseTypeForStates = std::uint32_t

ReturnAndProcessEventTypeOfStateMachine = std::uint16_t
InitializedFlagTypeOfStateMachine = std::uint16_t

UseUnderlineForIncludeProtection=no

How to use state machines with VxWorks

anonymous@undisclosed.example.com (Anonymous) — Wed, 08 Mar 2023 18:32:44 +0000

How to use state machines with VxWorks

State machines can be used in various places of your system. In this example you will learn how to use a state machine in the context of VxWorks. VxWorks is a market-leading real-time operating system (RTOS) used in many different applications since many years. You can follow this tutorial by using the VxWorks Software Development Kit on of of the supported platforms. We use QEMU (x86-64) running on a Debian host.

In the most typical design, each state machine runs in the context of an own task. The design of the fully running example is shown in the following figure and available for download at the end of the article.

Each task executes a state machine (often called active object) in an endless while loop. The tasks wait for new events to be processed from the state machine. In case no event is present the task is set in idle mode from VxWorks. In case one or more new events are available the VxWorks wakes up the task. The used VxWorks mechanism for event signaling can be different. But often a message queue is used. Events might be stored in the event queue from various sources. E.g. from within another task or from inside an interrupt service routine from a timer. This design can be realised with every real-time operating system. Mainly the exact syntax differs from OS to OS.

Simple state machine used for evaluation

This state machine is a representative of a simplified control task. The state machine was designed with the built-in state machine editor. And the state machine code was completely generated.

Setting up the system

This simple main code creates two tasks, a message queue, the timeout timer and the state machine.

#include <stdio.h>
#include <stdint.h>
#include <vxWorks.h>
#include <taskLib.h>
#include <msgQLib.h>
#include <time.h>
#include "state_machine_ext.h"
#include "state_machine.h"
 
TASK_ID tid1,tid2,tidLowPrio;
MSG_Q_ID qid;
timer_t timerID;
struct itimerspec value, ovalue;
STATE_MACHINE_INSTANCEDATA_T smInstance = STATE_MACHINE_INSTANCEDATA_INIT;
 
// Helper to start timer from state machine.
// In practise you might use a more sophisticated routine considering multiple timers ...
void startTimer(void){
    printf("Start timer!\n");
    timer_settime (timerID, TIMER_RELTIME, &value, &ovalue);
}
 
// helper to stop timer
void stopTimer(void){
    printf("Stop timer!\n");
    timer_cancel(timerID);
}
 
int main(void)
{
 
    qid = msgQCreate(20, 1 /* msg len in byte */,MSG_Q_FIFO);
 
    // create a cyclic timer for demo purposes used in the state machine
    timer_create (CLOCK_REALTIME, NULL, &timerID);
    timer_connect (timerID, (VOIDFUNCPTR)timerhandler, NULL);
    value.it_value.tv_nsec = 1; 
    value.it_value.tv_sec = 0; 
    value.it_interval.tv_nsec = 500*1000*1000; // 500ms
    value.it_interval.tv_sec = 0;
 
    // init state var once
    state_machine(&smInstance, STATE_MACHINE_NO_MSG );
 
    tid1 = taskSpawn("/task1" , 107 , VX_NO_STACK_FILL , 2000 , (FUNCPTR)task1, 0,0,0,0,0,0,0,0,0,0);
    tid2 = taskSpawn("/task2" , 106 , VX_NO_STACK_FILL , 2000 , (FUNCPTR)task2, 0,0,0,0,0,0,0,0,0,0);
    tidLowPrio = taskSpawn("/taskidle" , 255 , VX_NO_STACK_FILL , 2000 , (FUNCPTR)lowPriTask, 0,0,0,0,0,0,0,0,0,0);
 
 
    printf("init finished!\n");
 
    while(1){
        taskDelay (CLOCKS_PER_SEC);
    }  
 
    taskSuspend (0);
 
    return 0;
}

VxWorks Task 1

The task1 waits blocking for elements to appear in the queue. If data is present in the queue we dequeue it and call the state machine.

void task1() { 
    #define BUF_LEN 5
    char buf[BUF_LEN];
 
    printf("task 1 started!\n");
    while(1) {
        msgQReceive(qid, buf,1,WAIT_FOREVER);
        state_machine(&smInstance, *buf );
    }
}

VxWorks Task 2

For simplicity task2 sends events to task1 via the created message queue. In practise also from timers or interrupt service routines events might be sent.

char msgs[]= {evStart,STATE_MACHINE_NO_MSG, STATE_MACHINE_NO_MSG,STATE_MACHINE_NO_MSG,STATE_MACHINE_NO_MSG,
    STATE_MACHINE_NO_MSG,STATE_MACHINE_NO_MSG,STATE_MACHINE_NO_MSG,evStop,evStart,evStop,evShutdown,
    STATE_MACHINE_NO_MSG,STATE_MACHINE_NO_MSG};
 
void task2() { 
    printf("task 2 started!\n");
    for(uint8_t i=0; i<sizeof(msgs); i++) {
        msgQSend(qid, &msgs[i],1,WAIT_FOREVER,MSG_PRI_NORMAL);
        taskDelay(CLOCKS_PER_SEC);
    }
}

Generated output on the qemu console

The following output is generated from the above code. Note that a hierarchical state machine with history is used.

[vxWorks *]# example.vxe
Launching process 'example.vxe' ...
Process 'example.vxe' (process Id = 0xffff800000312010) launched.
Enter STOP
In STOP
task 1 started!
task 2 started!
In STOP
Exit STOP
Start timer!
Enter RUN
Enter Slow
init finished!
In RUN
Exit Slow
Enter Fast
In RUN
Exit Fast
Enter Slow
In RUN
In RUN
Exit Slow
Enter Fast
...
In RUN
Exit Slow
Exit RUN
Stop timer!
Enter STOP
In STOP
Exit STOP
Start timer!
Enter RUN
Enter Slow
In RUN
Exit Slow
Enter Fast
In RUN
Exit Fast
Enter Slow
In RUN
Exit Slow
Exit RUN
Stop timer!
Enter STOP
In STOP
Exit STOP
Entering Final

Wrap-up

We showed how to use state machines in the context of VxWorks. This pattern can be universally used with any other RTOS too. Using this pattern allows a very flexibly system design and allows to design robust and easy to understand real-time embedded systems. The relevant files are available here.

VxWorks, RTOS, Pattern]