state_machine.h

Go to the documentation of this file.

 
#pragma once
 
#include "src/system/platform/time.h"
#include <cstdint>
 
namespace lampda {
namespace utils {
 
template<typename State> class StateMachine
{
public:
  StateMachine(const State s) :
    current(s),
    lastState(s),
    stateSetTime(platform::time_ms()),
    timeout_ms(0),
    afterTimeoutState(s),
    changedWithTimeout(false)
  {
  }
  StateMachine(const State s, const uint32_t timeout, const State stateOnTimeout) :
    current(s),
    lastState(s),
    stateSetTime(platform::time_ms()),
    timeout_ms(0),
    afterTimeoutState(s),
    changedWithTimeout(false)
  {
    set_state(s, timeout, stateOnTimeout);
  }
 
  void run()
  {
    // there is a timeout set for this state
    if (isTimeoutSet and platform::time_ms() >= timeout_ms)
    {
      // timeout reached
      set_state(afterTimeoutState);
      changedWithTimeout = true;
    }
  }
 
  bool set_state(const State s, bool forceUpdate = false)
  {
    if (not forceUpdate and s == current)
    {
      // ignore a set state with same value
      return false;
    }
    // update the state
    lastState = current;
    current = s;
    // reset the timeout time
    isTimeoutSet = false;
    timeout_ms = 0;
    stateSetTime = platform::time_ms();
 
    changedWithTimeout = false;
    didStateJustChanged = true;
    return true;
  }
 
  bool set_state(const State s, const uint32_t timeout, const State stateOnTimeout)
  {
    // set the new state if
    // - no timeout is active
    // - new state changes
    // - timeout state changes
    if (not isTimeoutSet or (s != current or afterTimeoutState != stateOnTimeout))
    {
      // force update state
      set_state(s, true);
      // set a timeout
      isTimeoutSet = true;
      // set after timeout state & timeout
      update_timeout(timeout);
      afterTimeoutState = stateOnTimeout;
      return true;
    }
    return false;
  }
 
  void update_timeout(const uint32_t timeout)
  {
    if (isTimeoutSet)
    {
      // potential clock overflow, be careful
      timeout_ms = platform::time_ms() + timeout;
    }
  }
 
  bool state_just_changed()
  {
    const bool temp = didStateJustChanged;
    didStateJustChanged = false;
    return temp;
  }
 
  bool state_changed_with_timeout() { return changedWithTimeout; }
 
  State get_state() const { return current; }
 
  State get_last_state() const { return lastState; }
 
  void skip_timeout()
  {
    if (isTimeoutSet)
    {
      set_state(afterTimeoutState);
    }
  }
 
  uint32_t get_state_raised_time() const { return stateSetTime; }
 
private:
  State current;
  State lastState;
 
  // The time this state was raised
  uint32_t stateSetTime;
  // prevent some errors with clock value wrap
  bool isTimeoutSet;
  uint32_t timeout_ms;
  // The state to go after a timout
  State afterTimeoutState;
 
  bool didStateJustChanged;
  // indicates that this state was reched with a timeout
  bool changedWithTimeout;
};
 
} // namespace utils
} // namespace lampda