Tidy FSM state initialisation

[rblilja]

Hello!

Looking at the FSM example found here, I'm looking for a recommendation on how to wrap up the state initialisation in a bit more tidier way.

The example uses in its main:

`Fsm fsm;

State1 state1;
State2 state2;

// The list of states.
etl::ifsm_state* state_list[] = { &state1, &state2 };

...

// Set up the FSM
fsm.set_states(state_list, 2);`

As I understand; the state objects cannot be a part of the Fsm class, as the state classes needs to know about the Fsm. Somewhat of a circular dependency.

What I basically want is to hide away the above code from the user. Perhaps write a new class and inherit the Fsm class and do the setup in the new class? Suggestions are welcomed :)

Edit: As well, is there an equivalent to the on_event function but that is not dependent on a message i.e. something that can be executed whenever the Fsm is poked from a timer or alike (but without the need to send a message)?

[jwellbelove]

I've just tried modifying the example and it is entirely possible to have the states as internal classes to the user's FSM.

//*****************************************************************************
// The Finite State Machine.
//*****************************************************************************
class Fsm : public etl::fsm
{
public:

  //***************************************************************************
  // Constructor.
  //***************************************************************************
  Fsm()
    : fsm(1)
  {
    set_states(state_list, 2);
  }

  //***************************************************************************
  // The overridden virtual receive function.
  //***************************************************************************
  void receive(const etl::imessage& msg_) override
  {
    if (accepts(msg_))
    {
      // Place in queue.
      queue.emplace(msg_);

      std::cout << "Queueing message " << int(msg_.get_message_id()) << std::endl;
    }
    else
    {
      std::cout << "Ignoring message " << int(msg_.get_message_id()) << std::endl;
    }
  }

  //***************************************************************************
  // The method to call to handle any queued messages.
  //***************************************************************************
  void process_queue()
  {
    while (!queue.empty())
    {
      message_packet& packet = queue.front();
      etl::imessage& msg = packet.get();
      std::cout << "Processing message " << int(msg.get_message_id()) << std::endl;

      // Call the base class's receive function.
      // This will route it to the correct 'on_event' handler.
      etl::fsm::receive(msg);

      queue.pop();
    }
  }

  //*****************************************************************************
  // State 1.
  //*****************************************************************************
  class State1 : public etl::fsm_state<Fsm, State1, STATE1, Message1, Message2, Message3>
  {
  public:

    //***************************************************************************
    // When we enter this state.
    //***************************************************************************
    etl::fsm_state_id_t on_enter_state() override
    {
      std::cout << "  S1 : Enter state" << std::endl;
      return STATE1;
    }

    //***************************************************************************
    void on_exit_state() override
    {
      std::cout << "  S1 : Exit state" << std::endl;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event(const Message1& msg)
    {
      std::cout << "  S1 : Received message " << int(msg.get_message_id()) << " : '" << msg.i << "'" << std::endl;
      std::cout.flush();
      return STATE1;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event(const Message2& msg)
    {
      std::cout << "  S1 : Received message " << int(msg.get_message_id()) << " : '" << msg.d << "'" << std::endl;
      std::cout.flush();
      return STATE1;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event(const Message3& msg)
    {
      std::cout << "  S1 : Received message " << int(msg.get_message_id()) << " : '" << msg.s << "'" << std::endl;
      std::cout.flush();
      return STATE1;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event_unknown(const etl::imessage& msg)
    {
      std::cout << "  S1 : Received unknown message " << int(msg.get_message_id()) << std::endl;
      std::cout.flush();
      return STATE2;
    }
  };

  //*****************************************************************************
  // State 2.
  //*****************************************************************************
  class State2 : public etl::fsm_state<Fsm, State2, STATE2, Message1, Message2, Message3>
  {
  public:

    //***************************************************************************
    etl::fsm_state_id_t on_enter_state() override
    {
      std::cout << "  S2 : Enter state" << std::endl;
      return STATE2;
    }

    //***************************************************************************
    // When we enter this state.
    //***************************************************************************
    void on_exit_state() override
    {
      std::cout << "  S2 : Exit state" << std::endl;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event(const Message1& msg)
    {
      std::cout << "  S2 : Received message " << int(msg.get_message_id()) << " : '" << msg.i << "'" << std::endl;
      return STATE2;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event(const Message2& msg)
    {
      std::cout << "  S2 : Received message " << int(msg.get_message_id()) << " : '" << msg.d << "'" << std::endl;
      return STATE2;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event(const Message3& msg)
    {
      std::cout << "  S2 : Received message " << int(msg.get_message_id()) << " : '" << msg.s << "'" << std::endl;
      return STATE2;
    }

    //***************************************************************************
    etl::fsm_state_id_t on_event_unknown(const etl::imessage& msg)
    {
      std::cout << "  S2 : Received unknown message " << int(msg.get_message_id()) << std::endl;
      return STATE1;
    }
  };

private:

  typedef etl::message_packet< Message1, Message2, Message3, Message4> message_packet;

  State1 state1;
  State2 state2;

  // The list of states.
  etl::ifsm_state* state_list[2] = { &state1, &state2 };

  // The queue of message items.
  etl::queue<message_packet, 10> queue;
};

[rblilja]

Great solution! I did not think of embedding the state classes within the Fsm class. Thank you!

[jwellbelove]

As well, is there an equivalent to the on_event function but that is not dependent on a message i.e. something that can be executed whenever the Fsm is poked from a timer or alike (but without the need to send a message)?

An event message can be defined as a simple empty class. Passing this to the FSM would be very low cost.

[rblilja]

Sounds as a fair solution. Thanks again!

[ttftw]

Edit: As well, is there an equivalent to the on_event function but that is not dependent on a message i.e. something that can be executed whenever the Fsm is poked from a timer or alike (but without the need to send a message)?

I'm curious, what would happen during this poke? Are there actions you want to take during this poke, like maybe checking conditions to see if you need to change state or what did you have in mind?