cepsdev/machines4ceps

Workflow/State Machine Engine written in modern C++. Offers a comprehensive DSL (Domain Specific Language) for UML state machines. Comes with a runtime to run, trace and visualize your state machines.

machines4ceps's Issues

The binary op(...) operator

Introduce a left associative operator op(...) with precedence higher than the comment operator #, where ... stands for a non empty character sequence.

Examples: op(in), op(+++), op(select all *)

An expression of the form A op(xyz) B would be parsed as (S-expression)

 (xyz A B)

Use case: with the --pr option set, the right hand side of the comment operator '#' gets evaluated which allows for a more user friendly print version of an expression. In this context user defined operators for documentation purposes would be nice.

Example:

ComplexGuard = in_state(A.B.C.abc) || in_state(X.C.D.F.j) && Predicate1(...) # (States op(are in) A op(and) P)

would evaluate to (in --pr mode):

States are in A and P

with additional formatting.

Markdown Output

In addition to the format option ansi (in combination with the options --pr [print raw] / --pe [print evaluated] / --ppe [print post evaluation] ) diverse markdown styles (Jira/Github/Asciidoc etc.) should be supported.

Console Output (Options --pe,--ppe): Wrong transitions

kind Event;
kind Guard;
kind Systemstate;

Guard CP_StateA;
Guard CP_StateB;
Guard CP_StateC;
Guard CP_StateD;

Guard CP_OutOfBounds_StateB;
Guard CP_OutOfBounds_StateC;
Guard CP_OutOfBounds_StateD;
Guard CPVoltageInBoundsForCurrentState;
Guard TooManyPeaksInARow;
Guard PeakdelayIntervalElapsed;
Guard NoPeakDetected;
Guard PeakDetected;

Event ReadValuesFromChargingBus; 
Event PeakDetectionCompleted;

Systemstate current_cp_voltage;
Systemstate peak_counter;
Systemstate max_peaks_in_a_row;
Systemstate peakdelay_interval;


current_cp_voltage = 0.0;
peak_counter = 0;


max_peaks_in_a_row = 8;
peakdelay_interval = 10;

sm{
    evse;
    sm{
        secc;
        sm{
            secc_serial;
            sm{
                peak_detect;
                states{Initial;CheckPeakCondition;NoPeak;Peak;Plateau;};
                t{Initial;CheckPeakCondition;};

                t{CheckPeakCondition;Peak;CP_OutOfBounds_StateB;};
                t{CheckPeakCondition;Peak;CP_OutOfBounds_StateC;};
                t{CheckPeakCondition;Peak;CP_OutOfBounds_StateD;};
                t{CheckPeakCondition;NoPeak;CPVoltageInBoundsForCurrentState;};

                t{Peak;CheckPeakCondition;ReadValuesFromChargingBus;};
                t{NoPeak;CheckPeakCondition;ReadValuesFromChargingBus;};

                t{Peak;Plateau;TooManyPeaksInARow;};
                t{Plateau;CheckPeakCondition;ReadValuesFromChargingBus;PeakdelayIntervalElapsed;};
            };
            sm{
                analyzePhysicalValues;
                states{Initial;
                 WaitForNewValuesFromChargingBus;
                 WaitForPeakDetection;
                 DoComputationsBasedOnCPVoltage;
                 AnalyzeBCPToggle;};
                
                t{Initial;WaitForNewValuesFromChargingBus;};
                t{WaitForNewValuesFromChargingBus;WaitForPeakDetection;ReadValuesFromChargingBus;};
                t{WaitForPeakDetection;DoComputationsBasedOnCPVoltage;PeakDetectionCompleted;NoPeakDetected;};
                t{WaitForPeakDetection;AnalyzeBCPToggle;PeakDetectionCompleted;PeakDetected;};
                t{DoComputationsBasedOnCPVoltage;AnalyzeBCPToggle;};
                t{AnalyzeBCPToggle;WaitForNewValuesFromChargingBus;};
            };
            states{Initial;};
            t{Initial;peak_detect;};
            t{Initial;analyzePhysicalValues;};

        };
        states{Initial;};
        t{Initial;secc_serial;};        
    };
    sm{
        low_level_charging_bus;
        states{Initial;};
        sm{
            ControlPilot;
            states{Initial;A;B;C;D;};
            t{Initial;A;};

        };
        sm{
            ProximityPilot;
            states{Initial;Connected;Disconnected;};
        };

        t{Initial;ControlPilot;};
        t{Initial;ProximityPilot;};
    };
    states{Initial;};
    t{Initial;low_level_charging_bus;};
    t{Initial;secc;};
};

Produces the output:

State Machine evse:
 States:
  Initial
 Transitions:
  Initial --▶ low_level_charging_bus
  Initial --▶ secc

 State Machine secc:
  States:
   Initial
  Transitions:
   A --▶ 

  State Machine secc_serial:
   States:
    Initial
   Transitions:
    Plateau --▶ 
    CheckPeakCondition --▶ 

   State Machine peak_detect:
    States:
     Initial, CheckPeakCondition, NoPeak, Peak, Plateau
    Transitions:
      --▶ Initial
     Peak -[PeakDetectionCompleted]-▶ analyzePhysicalValues
     Initial -[ReadValuesFromChargingBus]-▶ WaitForNewValuesFromChargingBus
     DoComputationsBasedOnCPVoltage -[CP_OutOfBounds_StateB]-▶ CheckPeakCondition
      -[CP_OutOfBounds_StateC]-▶ Plateau
     Initial -CP_OutOfBounds_StateD-▶ CheckPeakCondition
      -CPVoltageInBoundsForCurrentState-▶ 
     CheckPeakCondition -[ReadValuesFromChargingBus]-▶ Peak
     CheckPeakCondition -PeakDetectionCompleted[NoPeakDetected]-▶ Peak
   

   State Machine analyzePhysicalValues:
    States:
     Initial, WaitForNewValuesFromChargingBus, WaitForPeakDetection, DoComputationsBasedOnCPVoltage, AnalyzeBCPToggle
    Transitions:
      --▶ NoPeak
     Peak -ReadValuesFromChargingBus-▶ 
     Peak -CPVoltageInBoundsForCurrentState[CP_OutOfBounds_StateD]-▶ 
      -CP_OutOfBounds_StateC[CP_OutOfBounds_StateB]-▶ Plateau
     Initial --▶ CheckPeakCondition
     CheckPeakCondition --▶ Peak
   
  
 

 State Machine low_level_charging_bus:
  States:
   Initial
  Transitions:
   Initial --▶ ControlPilot
   Initial --▶ ProximityPilot

  State Machine ControlPilot:
   States:
    Initial, A, B, C, D
   Transitions:
     --▶ Initial
  

  State Machine ProximityPilot:
   States:
    Initial, Connected, Disconnected

Almost all transitions are wrong

Docgen: Markdown github style

in_state(...) in guards causes segmentation fault.

Visualization of state machines on a terminal using ANSI Escape Sequences.

Projects which appear useful:

• https://github.com/p-ranav/tabulate.

Events are ignored in actions.

The following doesn't work - E is never fired.

Event E;
sm{
 S;
 on_enter{
   E;
 };
 states{Initial;};
};
Simulation{
 Start{S;};
};

But putting E into a scope works:

...
 on_enter{
   {E;}
 };
...

Docgen: Introduce mechanism to define verbosity of output

We need a general mechanism to control the verbosity of the output written by document modules. e.g. console output triggered by the --pr option.

An interesting approach would be to introduce doc-templates.

Example:

Consider the following state machine definition.

sm{
S;
states{A;B;C;};
t{A;B;};
};

A user might be interested only in the name of the states and not the specific transitions. i.e. he would like a summary in the form:

State Machine S
States:
A, B, C

To achieve this, the user could define a docgen-template:

kind docgen_template; docgen_template DT;
template{
DT;
sm{
states;
};
};

Meaning: Of all top level elements print only sm - elements, and of sm -elements print only states.

Console Output of State Machine Definition doesn't merge definitions

Consider following definition:

sm{
EVCC_Application_Layer;
states{Initial;A;B;Final;};
t{Initial;A;};
};

sm{
EVCC_Application_Layer;
t{A;B;};
};

this is correctly interpreted as

sm{
EVCC_Application_Layer;
states{Initial;A;B;Final;};
t{Initial;A;};
t{A;B;};
};

but printed as two different state machines (e.g. using --pe --format ansi)

State Machine EVCC_Application_Layer:
States:
Initial, A, B, Final
Transitions:
Initial --▶ A

State Machine EVCC_Application_Layer:
Transitions:
A --▶ B

Should be:

State Machine EVCC_Application_Layer:
States:
Initial, A, B, Final
Transitions:
Initial --▶ A
A --▶ B

as_int(Expr) returns 0 if Expr contains a Systemstate as subexpression

kind Systemstate;
Systemstate A,B;
A = 2.0; B= 1.0;
print(as_int(A/B));

outputs 0 instead of 2.