State Machine design handling data input

Question

Im working on a real time machine control system, which performs a series of tasks, and should react to a large number of inputs. I've decided to implement this system using a state machine.

Ive used simple switch/case based state machines in the past and would like to transition to a more maintainable solution. At the moment I'm a little confused as to how to handle input and transitions.

For example I have an AnalogInput class which provides me with measurement values which i should monitor. Say I have a state WaitForThreshold, which should read a AnalogInput and then transition if the threshold is reached.

Do I a) a pass a reference of the AnalogInput class to the WaitForThreshold class and allow it to monitor the input itself, signaling to the StateMachine class that it wishes to transition.

b) create dedicated events, LaserMeasurementAtThreshold and a state transition map: StateMachine.addTransition(State A, Event e, State B)

c)create more generic events AnalogInputChanged and implement event handlers for each of the events, which again signal to the StateMachine that a transition is desired

option a is essentially the larger version of a simple switch/case state machine, which could get messy with time, but offers great flexibility and b/c seems more structured and clean but seems like i may have to jump through alot of hoops to implement relatively simple tasks because the number of events can be very large.

Can someone offer some insight on the design of state machines where a large number of inputs sources and types must be monitored, and events are largely state-specific(Most event pertain only to a single state)?

Are there possibly other alternatives to state machine design to control a system where a sequence of steps must be implemented (non linear, looping and branchig must be possible)

Language: C++

Thanks

You probably want to read about the [_State Pattern_](https://sourcemaking.com/design_patterns/state). — πάντα ῥεῖ, Dec 15 '18 at 18:08
Do you know UML ? You can model your state machine through an UML modeler and generate corresponding C++ source code — bruno, Dec 15 '18 at 18:10
There are existing frameworks that do what you want. Maybe you should check some of them out before reinventing the wheel: https://stackoverflow.com/questions/3750177/which-state-machine-execution-frameworks-for-c-implement-uml-semantics/37928148#37928148 Reading about UML State Machines might be useful, too. — DrP3pp3r, Dec 15 '18 at 18:44
IMHO, use a table driven state machine. The table can consist of columns for present state, next state and a pointer to a transition function. Tables are usually easier to maintain than `switch` statements. Also, the code for accessing the table only needs to be tested once; the table size will change, but not the code for accessing the table. — Thomas Matthews, Dec 15 '18 at 19:09
If you're willing to use a framework based on the mentioned _State Pattern_, you can also try my [STTCL](http://makulik.github.io/sttcl/). — πάντα ῥεῖ, Dec 15 '18 at 19:46

score 0 · Answer 1 · answered Dec 15 '18 at 19:19

I believe this would be clearer to implement as a table of transitions:

typedef (void)((*Pointer_To_Transition_Function)());
struct Table_Entry
{
  Input_Type input_value;
  Pointer_To_Transisiton_Function p_trans_function;
};

static const Table_Entry Transition_Table[] = 
{
  {4, Read_Sensor},
};
static const size_t transition_quantity =  
    sizeof(Transition_Table) / sizeof(Transition_Table[0]);

//...
for (size_t index = 0; index < transition_quantity; ++index)
{
  if (input_value = Transition_Table[index].input_value)
  {
    Pointer_To_Transition_Function p_function = Transition_Table[index].p_trans_function;
    // Call the function:
    p_function();
    break;
  }
}

You could use std::map, but the std::map has to be initialized during run-time. The table (array) is static and constant, thus it can be placed into a read-only memory segment (convenient for embedded systems); and doesn't use dynamic memory allocation.

Edit 1: ASCII drawing of the table

+-------------+--------------------------------+  
| Input value | Pointer to transition function |  
+-------------+--------------------------------+  
|     4       |   Read sensor                  |
+-------------+--------------------------------+  
|     2       |   Start motor                  |
+-------------+--------------------------------+

I've implemented state/transition tables for an embedded Medical device. We can change the data in the table without having to revalidate the access function (engine); since the code didn't change (only the data changed). — Thomas Matthews, Dec 15 '18 at 19:20

State Machine design handling data input

1 Answers1