The following example describes an electric window lift as it can be found in most modern cars today. The example is based on a requirement specification that is provided from Fraunhofer IESE and can be downloaded here. In the document it is stated that the specification has a similar complexity and level of detail as it can be found in real specifications written by car manufactures. But it does not describe a real existing system.

The specification describes a complete door controller. One small part of it - the window lift unit - is modelled here. In fact only the opening of the pane was realized. The closing part is very similar and was left out to make it easier to follow the example.

Unfortunately the specification is available in German language only. Therefore the window lift related parts are presented below in English.

Besides showing how the requirements are transfered into a state machine it also shows how to integrate a state machine into a real-time operating system. In this example the Windows emulation of embos from Segger (www.segger.com) was used.

Electric Window Lift Specification

The movement of the pane is controlled through keys in the car doors. Pane movement continues as long as the stimulus is present or the pane has reached its end-position (either open or close). While closing the pane it is controlled if a barrier disturbes the movement. If yes, the closing operation is stopped and the pane is opened totally (clamping protection).

In reality the number and kind of stimuli depends a lot on the car type. Here the implementation of just one type is shown.

Opening a pane

When receiving an opening command the opening starts if the battery voltage is above 10V. Below this level a "LowBatt" message is sent to the central control unit.

The following cases needs to be considered for moving:

If the command is "pane down manually" the pane will be moved downwards. Downwards movement will be stopped under the following conditions:

1. •  the down command is not anymore present
   

2. •  the pane is totally open
   

3. •  there is a new command
   

4. •the movement sensor detects no movement anymore
   although the window is not totally open and the motor was
   switched on (an error message is sent in this case)
   

5. •The total traveling time is longer than 3 sec but the pane is
   not totally open (an error message is sent in this case)
   

When receiving the command "pane down automatically" the pane will be moved downwards until it is completely open. Downwards movement will be stopped under the following conditions:

1. •the pane is totally open
   

2. •there is a new command
   

3. •the movement sensor detects no movement anymore
   although the window is not totally open and the motor
   was switched on (an error message is sent in this case)
   

4. •The total traveling time is longer than 3 sec but the pane
   is not totally open (an error message is sent in this case)
   

5. •It is not necessary that the "pane down" command is pending
   

6. •during the complete traveling time.
   

Mechanically it is not possible to move the electric window lift command key directly from "pane down auto" into the "not pressed" state. Therefore the command "pane down manual" is ignored up to 0.5sec if the previous position was "pane down auto". If the command key is present longer than 0.5 sec the mode will be changed to manual moving mode. Releasing the command key afterwards stopps the movement immediately.

The Sample Solution

The figure below shows the state chart of the window lift. The generated state machine is executed in an embos task. Therefore it blocks until an event was recieved. Embos provides several mechanisms for inter task communication. In the example events were used to signal timeouts, pane movement and new key commands. The event selection code is specified in an 'action:' note (see image at the top). The action code is executed at the very beginning of the generated state machine function.

/* action code */

evt = OS_WaitEvent(0xff); // wait blocking

if(evt==1) msg=evTimeoutLongMove;

else if(evt==2) msg=evTimeoutMoving;

else if(evt==4) msg=evTimeoutInter;

else if(evt==8) msg=evMotion;

else msg=keybMsg;

Important! SinelaboreRT does not restrict you in any way on how to send events to a state machine.

The motor is simulated in a second task (see motor.c / motor.h). If the motor is switched 'on' the task sends  evMotion events every 20ms. As long as the motor is 'off' the task is suspended and does not send events.

For the supervision timers (long move, moving, inter) embos software timers were used. In their callback functions they simply send the according timeout event to the state machine task.

// Timer handler for the long move timer.

// On timeout send the message to the statechart

void TimerLongMoveFct(void) {

  OS_SignalEvent(0x1,&statemachineTaskTcb);

}

A third task realizes a small test bed by sending commands like (manual down, auto down, ...) to the state machine. Several test cases are realized to test the machine. For example entering the manual mode from the auto mode. Another test case tests the 'long movement' requirement.

// This tasks sends simulates user commands.

void SimulatorTask(void){

  extern TUSIGN8 pos;

  while(1){

    OS_Delay(1000);

    Trace("\n\nFirst test. Must result in long move error.");

    keybMsg=evManDown;

    Trace("evManDown");

    OS_SignalEvent(0x80,&statemachineTaskTcb);

    OS_Delay(1000);

   ...

Running the Example

The example comes pre-built. The executable 'start.exe' can just be started. If started it does not display any output but writes its output to 'trace.txt' which is located under c:\. After execution all test cases (takes about 30s) the program finishes automatically.

File main.c contains the simulation - and the state machine task as well as the code to initialize all tasks, timers etc. In files motor.* the simple motor simulation was realized. All files starting with window_lift.c/h were automatically generated from the state-chart window_lift.cdd. In folder embos the Visual C++ project as well as the embos library can be found.

To rebuilt the state machine files execute 'java -jar codegen.jar -p CADIFRA -o window_lift  window_lift.cdd'. To rebuilt the exe file you have to install Microsoft C++ 2005 Express Edition which you can download from Microsoft.

Thanks to the people from Segger allowing us to use the windows evaluation version of embos in this example.

The complete example can be downloaded here.