smacc::ISmaccStateMachine Class Reference

#include <smacc_state_machine.h>

Inheritance diagram for smacc::ISmaccStateMachine:

Collaboration diagram for smacc::ISmaccStateMachine:

Public Member Functions
	ISmaccStateMachine (SignalDetector *signalDetector)
virtual	~ISmaccStateMachine ()
virtual void	reset ()
virtual void	stop ()
virtual void	eStop ()
template<typename TOrthogonal >
TOrthogonal *	getOrthogonal ()
const std::map< std::string, std::shared_ptr< smacc::ISmaccOrthogonal > > &	getOrthogonals () const
template<typename SmaccComponentType >
void	requiresComponent (SmaccComponentType *&storage)
template<typename EventType >
void	postEvent (EventType *ev, EventLifeTime evlifetime=EventLifeTime::ABSOLUTE)
template<typename EventType >
void	postEvent (EventLifeTime evlifetime=EventLifeTime::ABSOLUTE)
void	getTransitionLogHistory ()
template<typename T >
bool	getGlobalSMData (std::string name, T &ret)
template<typename T >
void	setGlobalSMData (std::string name, T value)
template<typename StateField , typename BehaviorType >
void	mapBehavior ()
std::string	getStateMachineName ()
void	state_machine_visualization (const ros::TimerEvent &)
std::shared_ptr< SmaccStateInfo >	getCurrentStateInfo ()
void	publishTransition (const SmaccTransitionInfo &transitionInfo)
virtual void	onInitialize ()
	this function should be implemented by the user to create the orthogonals More...
bool	getTransitionLogHistory (smacc_msgs::SmaccGetTransitionHistory::Request &req, smacc_msgs::SmaccGetTransitionHistory::Response &res)
template<typename TSmaccSignal , typename TMemberFunctionPrototype , typename TSmaccObjectType >
boost::signals2::connection	createSignalConnection (TSmaccSignal &signal, TMemberFunctionPrototype callback, TSmaccObjectType *object)
void	disconnectSmaccSignalObject (void *object)
template<typename StateType >
void	notifyOnStateEntryStart (StateType *state)
template<typename StateType >
void	notifyOnStateEntryEnd (StateType *state)
template<typename StateType >
void	notifyOnRuntimeConfigured (StateType *state)
template<typename StateType >
void	notifyOnStateExitting (StateType *state)
template<typename StateType >
void	notifyOnStateExited (StateType *state)
template<typename StateType >
void	notifyOnRuntimeConfigurationFinished (StateType *state)
uint64_t	getCurrentStateCounter () const
ISmaccState *	getCurrentState () const
const SmaccStateMachineInfo &	getStateMachineInfo ()
template<typename InitialStateType >
void	buildStateMachineInfo ()
ros::NodeHandle	getNode ()

Protected Member Functions
void	checkStateMachineConsistence ()
void	initializeROS (std::string smshortname)
void	onInitialized ()
template<typename TOrthogonal >
void	createOrthogonal ()
template<typename T >
bool	getParam (std::string param_name, T &param_storage)
template<typename T >
void	setParam (std::string param_name, T param_val)
template<typename T >
bool	param (std::string param_name, T &param_val, const T &default_val) const

Protected Attributes
ros::NodeHandle	nh_
ros::NodeHandle	private_nh_
ros::Timer	timer_
ros::Publisher	stateMachinePub_
ros::Publisher	stateMachineStatusPub_
ros::Publisher	transitionLogPub_
ros::ServiceServer	transitionHistoryService_
std::vector< ISmaccState * >	currentState_
std::shared_ptr< SmaccStateInfo >	currentStateInfo_
smacc_msgs::SmaccStatus	status_msg_
std::map< std::string, std::shared_ptr< smacc::ISmaccOrthogonal > >	orthogonals_

Private Member Functions
void	lockStateMachine (std::string msg)
void	unlockStateMachine (std::string msg)
template<typename EventType >
void	propagateEventToStateReactors (ISmaccState *st, EventType *ev)
void	updateStatusMessage ()

Private Attributes
std::recursive_mutex	m_mutex_
std::recursive_mutex	eventQueueMutex_
StateMachineInternalAction	stateMachineCurrentAction
std::map< void *, std::shared_ptr< CallbackCounterSemaphore > >	stateCallbackConnections
std::map< std::string, std::pair< std::function< std::string()>, boost::any > >	globalData_
std::vector< smacc_msgs::SmaccTransitionLogEntry >	transitionLogHistory_
smacc::SMRunMode	runMode_
SignalDetector *	signalDetector_
uint64_t	stateSeqCounter_
std::shared_ptr< SmaccStateMachineInfo >	stateMachineInfo_

Friends
class	ISmaccState
class	SignalDetector

Detailed Description

Definition at line 53 of file smacc_state_machine.h.

Constructor & Destructor Documentation

ISmaccStateMachine()

smacc::ISmaccStateMachine::ISmaccStateMachine

(

SignalDetector *

signalDetector

)

Definition at line 15 of file smacc_state_machine.cpp.

    : private_nh_("~"), stateSeqCounter_(0)
{
    ROS_INFO("Creating State Machine Base");
    signalDetector_ = signalDetector;
    signalDetector_->initialize(this);
 
    std::string runMode;
    if (nh_.getParam("run_mode", runMode))
    {
        if (runMode == "debug")
        {
            runMode_ = SMRunMode::DEBUG;
        }
        else if (runMode == "release")
        {
            runMode_ = SMRunMode::RELEASE;
        }
        else
        {
            ROS_ERROR("Incorrect run_mode value: %s", runMode.c_str());
        }
    }
    else
    {
        runMode_ = SMRunMode::DEBUG;
    }
}

References smacc::DEBUG, smacc::SignalDetector::initialize(), nh_, smacc::RELEASE, runMode_, and signalDetector_.

Here is the call graph for this function:

~ISmaccStateMachine()

smacc::ISmaccStateMachine::~ISmaccStateMachine ( )

virtual

Definition at line 59 of file smacc_state_machine.cpp.

{
    ROS_INFO("Finishing State Machine");
}

Member Function Documentation

buildStateMachineInfo()

template<typename InitialStateType >

void smacc::ISmaccStateMachine::buildStateMachineInfo

Definition at line 656 of file smacc_state_machine_impl.h.

  {
    this->stateMachineInfo_ = std::make_shared<SmaccStateMachineInfo>();
    this->stateMachineInfo_->buildStateMachineInfo<InitialStateType>();
    this->stateMachineInfo_->assembleSMStructureMessage(this);
    this->checkStateMachineConsistence();
  }

References checkStateMachineConsistence(), and stateMachineInfo_.

Here is the call graph for this function:

checkStateMachineConsistence()

void smacc::ISmaccStateMachine::checkStateMachineConsistence ( )

protected

Definition at line 184 of file smacc_state_machine.cpp.

{
    // transition from an orthogonal that doesn’t exist.
    // transition from a source that doesn’t exist.
 
    // std::stringstream errorbuffer;
    // bool errorFound = false;
 
    // for (auto &stentry : this->stateMachineInfo_->states)
    // {
    //     auto stinfo = stentry.second;
 
    //     for (auto &transition : stinfo->transitions_)
    //     {
    //         auto evinfo = transition.eventInfo;
    //         bool found = false;
    //         for (auto &orthogonal : orthogonals_)
    //         {
    //             if (orthogonal.first == evinfo->getOrthogonalName())
    //             {
    //                 found = true;
    //                 break;
    //             }
    //         }
 
    //         if (!found)
    //         {
    //             errorbuffer << "---------" << std::endl
    //                         << "[Consistency Checking] Transition event refers not existing orthogonal." << std::endl
    //                         << "State: " << demangleType(*stinfo->tid_) << std::endl
    //                         << "Transition: " << transition.transitionTypeInfo->getFullName() << std::endl
    //                         << "Orthogonal: " << evinfo->getOrthogonalName() << std::endl
    //                         << "---------" << std::endl;
 
    //             errorFound = true;
    //         }
    //         //std::string getEventSourceName();
    //         //std::string getOrthogonalName();
    //     }
    // }
 
    // if (errorFound)
    // {
    //     ROS_WARN_STREAM("== STATE MACHINE CONSISTENCY CHECK: ==" << std::endl
    //                                                              << errorbuffer.str() << std::endl
    //                                                              << "=================");
    // }
    // cb from a client that doesn’t exist – don’t worry about making clients dynamically.
}

Referenced by buildStateMachineInfo().

Here is the caller graph for this function:

createOrthogonal()

template<typename TOrthogonal >

void smacc::ISmaccStateMachine::createOrthogonal

protected

Definition at line 63 of file smacc_state_machine_impl.h.

  {
    this->lockStateMachine("create orthogonal");
    std::string orthogonalkey = demangledTypeName<TOrthogonal>();
 
    if (orthogonals_.count(orthogonalkey) == 0)
    {
      auto ret = std::make_shared<TOrthogonal>();
      orthogonals_[orthogonalkey] = dynamic_pointer_cast<smacc::ISmaccOrthogonal>(ret);
 
      ret->setStateMachine(this);
 
      ROS_INFO("%s Orthogonal is created", orthogonalkey.c_str());
    }
    else
    {
      ROS_WARN_STREAM("There were already one existing orthogonal of type "
                      << orthogonalkey.c_str() << ". Skipping creation orthogonal request. ");
      std::stringstream ss;
      ss << "The existing orthogonals are the following: " << std::endl;
      for (auto &orthogonal : orthogonals_)
      {
        ss << " - " << orthogonal.first << std::endl;
      }
      ROS_WARN_STREAM(ss.str());
    }
    this->unlockStateMachine("create orthogonal");
  }

References lockStateMachine(), orthogonals_, and unlockStateMachine().

Here is the call graph for this function:

createSignalConnection()

template<typename TSmaccSignal , typename TMemberFunctionPrototype , typename TSmaccObjectType >

boost::signals2::connection smacc::ISmaccStateMachine::createSignalConnection	(	TSmaccSignal &	signal,
		TMemberFunctionPrototype	callback,
		TSmaccObjectType *	object
	)

Definition at line 345 of file smacc_state_machine_impl.h.

  {
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
    static_assert(std::is_base_of<ISmaccState, TSmaccObjectType>::value ||
                      std::is_base_of<ISmaccClient, TSmaccObjectType>::value ||
                      std::is_base_of<ISmaccClientBehavior, TSmaccObjectType>::value ||
                      std::is_base_of<StateReactor, TSmaccObjectType>::value ||
                      std::is_base_of<ISmaccComponent, TSmaccObjectType>::value,
                  "Only are accepted smacc types as subscribers for smacc signals");
 
    typedef decltype(callback) ft;
    Bind<boost::function_types::function_arity<ft>::value> binder;
 
    boost::signals2::connection connection;
 
    // long life-time objects
    if (std::is_base_of<ISmaccComponent, TSmaccObjectType>::value ||
        std::is_base_of<ISmaccClient, TSmaccObjectType>::value ||
        std::is_base_of<ISmaccOrthogonal, TSmaccObjectType>::value ||
        std::is_base_of<ISmaccStateMachine, TSmaccObjectType>::value)
    {
      connection = binder.bindaux(signal, callback, object, nullptr);
    }
    else if (std::is_base_of<ISmaccState, TSmaccObjectType>::value ||
             std::is_base_of<StateReactor, TSmaccObjectType>::value ||
             std::is_base_of<ISmaccClientBehavior, TSmaccObjectType>::value)
    {
      ROS_INFO("[StateMachine] life-time constrained smacc signal subscription created. Subscriber is %s",
               demangledTypeName<TSmaccObjectType>().c_str());
 
      std::shared_ptr<CallbackCounterSemaphore> callbackCounterSemaphore;
      if(stateCallbackConnections.count(object))
      {
        callbackCounterSemaphore = stateCallbackConnections[object];
      }
      else
      {
          callbackCounterSemaphore =  std::make_shared<CallbackCounterSemaphore>(demangledTypeName<TSmaccObjectType>().c_str());
          stateCallbackConnections[object] = callbackCounterSemaphore;
      }
 
      connection = binder.bindaux(signal, callback, object, callbackCounterSemaphore);
      callbackCounterSemaphore->addConnection(connection);
 
    }
    else // state life-time objects
    {
      ROS_WARN("[StateMachine] connecting signal to an unknown object with life-time unknown behavior. It might provoke "
               "an exception if the object is destroyed during the execution.");
 
      connection = binder.bindaux(signal, callback, object, nullptr);
    }
 
    return connection;
  }

References smacc::utils::Bind< arity >::bindaux(), m_mutex_, and stateCallbackConnections.

Referenced by smacc::ISmaccClient::connectSignal(), smacc::client_bases::SmaccActionClientBase< ActionType >::onAborted(), smacc::SmaccAsyncClientBehavior::onFailure(), smacc::SmaccAsyncClientBehavior::onFinished(), smacc::client_bases::SmaccSubscriberClient< MessageType >::onFirstMessageReceived(), cl_keyboard::ClKeyboard::OnKeyPress(), smacc::client_bases::SmaccSubscriberClient< MessageType >::onMessageReceived(), cl_multirole_sensor::ClMultiroleSensor< MessageType >::onMessageTimeout(), cl_move_group_interface::ClMoveGroup::onMotionExecutionFailed(), cl_move_group_interface::ClMoveGroup::onMotionExecutionSuccedded(), smacc::client_bases::SmaccActionClientBase< ActionType >::onPreempted(), smacc::client_bases::SmaccActionClientBase< ActionType >::onRejected(), smacc::client_bases::SmaccServiceServerClient< TService >::onServiceRequestReceived(), smacc::client_bases::SmaccActionClientBase< ActionType >::onSucceeded(), smacc::SmaccAsyncClientBehavior::onSuccess(), cl_ros_timer::ClRosTimer::onTimerTick(), cl_ros_timer::CbTimerCountdownLoop::onTimerTick(), and cl_ros_timer::CbTimerCountdownOnce::onTimerTick().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnectSmaccSignalObject()

void smacc::ISmaccStateMachine::disconnectSmaccSignalObject

(

void *

object

)

Definition at line 44 of file smacc_state_machine.cpp.

{
    ROS_INFO("[SmaccSignals] object signal disconnecting %ld", (long)object_ptr);
    if(stateCallbackConnections.count(object_ptr) > 0)
    {
        auto callbackSemaphore = stateCallbackConnections[object_ptr];
        callbackSemaphore->finalize();
        stateCallbackConnections.erase(object_ptr);
    }
    else
    {
        ROS_INFO("[SmaccSignals] no signals found %ld", (long)object_ptr);
    }
}

References stateCallbackConnections.

Referenced by notifyOnStateExited(), and smacc::ISmaccOrthogonal::onDispose().

Here is the caller graph for this function:

eStop()

void smacc::ISmaccStateMachine::eStop ( )

virtual

Reimplemented in smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >.

Definition at line 72 of file smacc_state_machine.cpp.

{
}

Referenced by smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::eStop().

Here is the caller graph for this function:

getCurrentState()

ISmaccState * smacc::ISmaccStateMachine::getCurrentState ( ) const

inline

Definition at line 669 of file smacc_state_machine_impl.h.

  {
    return this->currentState_.back();
  }

References currentState_.

getCurrentStateCounter()

uint64_t smacc::ISmaccStateMachine::getCurrentStateCounter ( ) const

inline

Definition at line 664 of file smacc_state_machine_impl.h.

  {
    return this->stateSeqCounter_;
  }

References stateSeqCounter_.

getCurrentStateInfo()

std::shared_ptr< SmaccStateInfo > smacc::ISmaccStateMachine::getCurrentStateInfo ( )

inline

Definition at line 95 of file smacc_state_machine.h.

{ return currentStateInfo_; }

References currentStateInfo_.

getGlobalSMData()

template<typename T >

bool smacc::ISmaccStateMachine::getGlobalSMData	(	std::string	name,
		T &	ret
	)

Definition at line 173 of file smacc_state_machine_impl.h.

  {
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
    // ROS_WARN("get SM Data lock acquire");
    bool success = false;
 
    if (!globalData_.count(name))
    {
      // ROS_WARN("get SM Data - data do not exist");
      success = false;
    }
    else
    {
      // ROS_WARN("get SM DAta -data exist. accessing");
      try
      {
        auto &v = globalData_[name];
 
        // ROS_WARN("get SM DAta -data exist. any cast");
        ret = boost::any_cast<T>(v.second);
        success = true;
        // ROS_WARN("get SM DAta -data exist. success");
      }
      catch (boost::bad_any_cast &ex)
      {
        ROS_ERROR("bad any cast: %s", ex.what());
        success = false;
      }
    }
 
    // ROS_WARN("get SM Data lock release");
    return success;
  }

References globalData_, and m_mutex_.

Referenced by smacc::ISmaccOrthogonal::getGlobalSMData(), smacc::ISmaccState::getGlobalSMData(), and mapBehavior().

Here is the caller graph for this function:

getNode()

ros::NodeHandle smacc::ISmaccStateMachine::getNode ( )

inline

Definition at line 136 of file smacc_state_machine.h.

                                  {
        return nh_;
    };

References nh_.

Referenced by smacc::ISmaccClientBehavior::getNode().

Here is the caller graph for this function:

getOrthogonal()

template<typename TOrthogonal >

TOrthogonal * smacc::ISmaccStateMachine::getOrthogonal

Definition at line 30 of file smacc_state_machine_impl.h.

  {
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
    std::string orthogonalkey = demangledTypeName<TOrthogonal>();
    TOrthogonal *ret;
 
    auto it = orthogonals_.find(orthogonalkey);
 
    if (it != orthogonals_.end())
    {
      ROS_DEBUG("Orthogonal %s resource is being required from some state, client or component. Found resource in cache.", orthogonalkey.c_str());
      ret = dynamic_cast<TOrthogonal *>(it->second.get());
      return ret;
    }
    else
    {
      std::stringstream ss;
      ss << "Orthogonal not found " << orthogonalkey.c_str() << std::endl;
      ss << "The existing orthogonals are the following: " << std::endl;
      for (auto &orthogonal : orthogonals_)
      {
        ss << " - " << orthogonal.first << std::endl;
      }
 
      ROS_WARN_STREAM(ss.str());
 
      return nullptr;
    }
  }

References m_mutex_, and orthogonals_.

Referenced by smacc::ISmaccState::getOrthogonal().

Here is the caller graph for this function:

getOrthogonals()

const std::map< std::string, std::shared_ptr< smacc::ISmaccOrthogonal > > & smacc::ISmaccStateMachine::getOrthogonals

(

)

const

Definition at line 76 of file smacc_state_machine.cpp.

{
    return this->orthogonals_;
}

References orthogonals_.

Referenced by smacc::introspection::SmaccStateMachineInfo::assembleSMStructureMessage(), smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::entryStateInternal(), smacc::SignalDetector::findUpdatableClients(), smacc::SignalDetector::findUpdatableStateElements(), and smacc::ISmaccState::requiresClient().

Here is the caller graph for this function:

getParam()

template<typename T >

bool smacc::ISmaccStateMachine::getParam ( std::string  param_name, T &  param_storage  )

protected

Definition at line 405 of file smacc_state_machine_impl.h.

  {
    return nh_.getParam(param_name, param_storage);
  }

References nh_.

getStateMachineInfo()

const smacc::introspection::SmaccStateMachineInfo & smacc::ISmaccStateMachine::getStateMachineInfo ( )

inline

Definition at line 674 of file smacc_state_machine_impl.h.

  {
    return *this->stateMachineInfo_;
  }

References stateMachineInfo_.

Referenced by smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::getStateInfo().

Here is the caller graph for this function:

getStateMachineName()

std::string smacc::ISmaccStateMachine::getStateMachineName

(

)

Definition at line 179 of file smacc_state_machine.cpp.

{
    return demangleSymbol(typeid(*this).name());
}

References smacc::introspection::demangleSymbol().

Here is the call graph for this function:

getTransitionLogHistory() [1/2]

void smacc::ISmaccStateMachine::getTransitionLogHistory

(

)

Referenced by initializeROS().

Here is the caller graph for this function:

getTransitionLogHistory() [2/2]

bool smacc::ISmaccStateMachine::getTransitionLogHistory	(	smacc_msgs::SmaccGetTransitionHistory::Request &	req,
		smacc_msgs::SmaccGetTransitionHistory::Response &	res
	)

Definition at line 148 of file smacc_state_machine.cpp.

{
    ROS_WARN("Requesting Transition Log History, current size: %ld", this->transitionLogHistory_.size());
    res.history = this->transitionLogHistory_;
    return true;
}

References transitionLogHistory_.

initializeROS()

void smacc::ISmaccStateMachine::initializeROS ( std::string  smshortname )

protected

Definition at line 136 of file smacc_state_machine.cpp.

{
    ROS_WARN_STREAM("State machine base creation:" << shortname);
    // STATE MACHINE TOPICS
    stateMachinePub_ = nh_.advertise<smacc_msgs::SmaccStateMachine>(shortname + "/smacc/state_machine_description", 1);
    stateMachineStatusPub_ = nh_.advertise<smacc_msgs::SmaccStatus>(shortname + "/smacc/status", 1);
    transitionLogPub_ = nh_.advertise<smacc_msgs::SmaccTransitionLogEntry>(shortname + "/smacc/transition_log", 1);
 
    // STATE MACHINE SERVICES
    transitionHistoryService_ = nh_.advertiseService(shortname + "/smacc/transition_log_history", &ISmaccStateMachine::getTransitionLogHistory, this);
}

References getTransitionLogHistory(), nh_, stateMachinePub_, stateMachineStatusPub_, transitionHistoryService_, and transitionLogPub_.

Referenced by smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

lockStateMachine()

void smacc::ISmaccStateMachine::lockStateMachine ( std::string  msg )

private

Definition at line 167 of file smacc_state_machine.cpp.

{
    ROS_DEBUG("locking state machine: %s", msg.c_str());
    m_mutex_.lock();
}

References m_mutex_.

Referenced by createOrthogonal(), notifyOnStateExited(), and smacc::SignalDetector::pollOnce().

Here is the caller graph for this function:

mapBehavior()

template<typename StateField , typename BehaviorType >

void smacc::ISmaccStateMachine::mapBehavior

Definition at line 227 of file smacc_state_machine_impl.h.

  {
    std::string stateFieldName = demangleSymbol(typeid(StateField).name());
    std::string behaviorType = demangleSymbol(typeid(BehaviorType).name());
    ROS_INFO("Mapping state field '%s' to stateReactor '%s'", stateFieldName.c_str(), behaviorType.c_str());
    SmaccClientBehavior *globalreference;
    if (!this->getGlobalSMData(stateFieldName, globalreference))
    {
      // Using the requires component approach, we force a unique existence
      // of this component
      BehaviorType *behavior;
      this->requiresComponent(behavior);
      globalreference = dynamic_cast<ISmaccClientBehavior *>(behavior);
 
      this->setGlobalSMData(stateFieldName, globalreference);
    }
  }

References smacc::introspection::demangleSymbol(), getGlobalSMData(), requiresComponent(), and setGlobalSMData().

Here is the call graph for this function:

notifyOnRuntimeConfigurationFinished()

template<typename StateType >

void smacc::ISmaccStateMachine::notifyOnRuntimeConfigurationFinished

(

StateType *

state

)

Definition at line 495 of file smacc_state_machine_impl.h.

  {
    for (auto pair : this->orthogonals_)
    {
      //ROS_INFO("ortho onruntime configure: %s", pair.second->getName().c_str());
      auto &orthogonal = pair.second;
      orthogonal->runtimeConfigure();
    }
 
    {
      std::lock_guard<std::recursive_mutex> lock(m_mutex_);
      this->updateStatusMessage();
      this->signalDetector_->notifyStateConfigured(this->currentState_.back());
 
      stateMachineCurrentAction = StateMachineInternalAction::STATE_ENTERING;
    }
  }

References currentState_, m_mutex_, smacc::SignalDetector::notifyStateConfigured(), orthogonals_, signalDetector_, smacc::STATE_ENTERING, stateMachineCurrentAction, and updateStatusMessage().

Referenced by smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::entryStateInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

notifyOnRuntimeConfigured()

template<typename StateType >

void smacc::ISmaccStateMachine::notifyOnRuntimeConfigured

(

StateType *

state

)

Definition at line 514 of file smacc_state_machine_impl.h.

  {
    stateMachineCurrentAction = StateMachineInternalAction::STATE_CONFIGURING;
  }

References smacc::STATE_CONFIGURING, and stateMachineCurrentAction.

Referenced by smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::entryStateInternal().

Here is the caller graph for this function:

notifyOnStateEntryEnd()

template<typename StateType >

void smacc::ISmaccStateMachine::notifyOnStateEntryEnd

(

StateType *

state

)

Definition at line 437 of file smacc_state_machine_impl.h.

  {
    ROS_INFO("[%s] State OnEntry code finished", demangleSymbol(typeid(StateType).name()).c_str());
 
    auto currentState = this->currentState_.back();
    for (auto pair : this->orthogonals_)
    {
      //ROS_INFO("ortho onentry: %s", pair.second->getName().c_str());
      auto &orthogonal = pair.second;
      try
      {
        orthogonal->onEntry();
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[Orthogonal %s] Exception on Entry - continuing with next orthogonal. Exception info: %s",
                  pair.second->getName().c_str(), e.what());
      }
    }
 
    for (auto &sr : currentState->getStateReactors())
    {
      auto srname = smacc::demangleSymbol(typeid(*sr).name()).c_str();
      ROS_INFO("state reactor onEntry: %s", srname);
      try
      {
        sr->onEntry();
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[State Reactor %s] Exception on Entry - continuing with next state reactor. Exception info: %s",
                  srname, e.what());
      }
    }
 
    for (auto &eg : currentState->getEventGenerators())
    {
      auto egname = smacc::demangleSymbol(typeid(*eg).name()).c_str();
      ROS_INFO("state reactor onEntry: %s", egname);
      try
      {
        eg->onEntry();
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[Event generator %s] Exception on Entry - continuing with next state reactor. Exception info: %s",
                  egname, e.what());
      }
    }
 
    {
      std::lock_guard<std::recursive_mutex> lock(m_mutex_);
      this->updateStatusMessage();
      stateMachineCurrentAction = StateMachineInternalAction::STATE_STEADY;
    }
  }

References currentState_, smacc::introspection::demangleSymbol(), m_mutex_, orthogonals_, smacc::STATE_STEADY, stateMachineCurrentAction, and updateStatusMessage().

Referenced by smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::entryStateInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

notifyOnStateEntryStart()

template<typename StateType >

void smacc::ISmaccStateMachine::notifyOnStateEntryStart

(

StateType *

state

)

Definition at line 425 of file smacc_state_machine_impl.h.

  {
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
    ROS_DEBUG("[State Machne] Initializating a new state '%s' and updating current state. Getting state meta-information. number of orthogonals: %ld", demangleSymbol(typeid(StateType).name()).c_str(), this->orthogonals_.size());
 
    stateSeqCounter_++;
    currentState_.push_back(state);
    currentStateInfo_ = stateMachineInfo_->getState<StateType>();
  }

References currentState_, currentStateInfo_, smacc::introspection::demangleSymbol(), m_mutex_, orthogonals_, stateMachineInfo_, and stateSeqCounter_.

Referenced by smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::entryStateInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

notifyOnStateExited()

template<typename StateType >

void smacc::ISmaccStateMachine::notifyOnStateExited

(

StateType *

state

)

Definition at line 575 of file smacc_state_machine_impl.h.

  {
    this->lockStateMachine("state exit");
 
    signalDetector_->notifyStateExited(state);
 
    auto fullname = demangleSymbol(typeid(StateType).name());
    ROS_WARN_STREAM("exiting state: " << fullname);
 
    ROS_INFO_STREAM("Notification State Disposing: leaving state" << state);
    for (auto pair : this->orthogonals_)
    {
      auto &orthogonal = pair.second;
      try
      {
        orthogonal->onDispose();
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[Orthogonal %s] Exception onDispose - continuing with next orthogonal. Exception info: %s",
                  pair.second->getName().c_str(), e.what());
      }
    }
 
    for (auto &sr : state->getStateReactors())
    {
      auto srname = smacc::demangleSymbol(typeid(*sr).name()).c_str();
      ROS_INFO("state reactor disposing: %s", srname);
      try
      {
        this->disconnectSmaccSignalObject(sr.get());
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[State Reactor %s] Exception on OnDispose - continuing with next state reactor. Exception info: %s",
                  srname, e.what());
      }
    }
 
    for (auto &eg : state->getEventGenerators())
    {
      auto egname = smacc::demangleSymbol(typeid(*eg).name()).c_str();
      ROS_INFO("state reactor disposing: %s", egname);
      try
      {
        this->disconnectSmaccSignalObject(eg.get());
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[State Reactor %s] Exception on OnDispose - continuing with next state reactor. Exception info: %s",
                  egname, e.what());
      }
    }
 
    this->stateCallbackConnections.clear();
    currentState_.pop_back();
 
    // then call exit state
    ROS_WARN_STREAM("state exit: " << fullname);
 
    stateMachineCurrentAction = StateMachineInternalAction::TRANSITIONING;
    this->unlockStateMachine("state exit");
  }

References currentState_, smacc::introspection::demangleSymbol(), disconnectSmaccSignalObject(), lockStateMachine(), smacc::SignalDetector::notifyStateExited(), orthogonals_, signalDetector_, stateCallbackConnections, stateMachineCurrentAction, smacc::TRANSITIONING, and unlockStateMachine().

Referenced by smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::exit().

Here is the call graph for this function:

Here is the caller graph for this function:

notifyOnStateExitting()

template<typename StateType >

void smacc::ISmaccStateMachine::notifyOnStateExitting

(

StateType *

state

)

Definition at line 520 of file smacc_state_machine_impl.h.

  {
    stateMachineCurrentAction = StateMachineInternalAction::STATE_EXITING;
 
    auto fullname = demangleSymbol(typeid(StateType).name());
    ROS_WARN_STREAM("exiting state: " << fullname);
    //this->setParam("destroyed", true);
 
    ROS_INFO_STREAM("Notification State Exit: leaving state" << state);
    for (auto pair : this->orthogonals_)
    {
      auto &orthogonal = pair.second;
      try
      {
        orthogonal->onExit();
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[Orthogonal %s] Exception onExit - continuing with next orthogonal. Exception info: %s",
                  pair.second->getName().c_str(), e.what());
      }
    }
 
    for (auto &sr : state->getStateReactors())
    {
      auto srname = smacc::demangleSymbol(typeid(*sr).name()).c_str();
      ROS_INFO("state reactor OnExit: %s", srname);
      try
      {
        sr->onExit();
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[State Reactor %s] Exception on OnExit - continuing with next state reactor. Exception info: %s",
                  srname, e.what());
      }
    }
 
    for (auto &eg : state->getEventGenerators())
    {
      auto egname = smacc::demangleSymbol(typeid(*eg).name()).c_str();
      ROS_INFO("state reactor OnExit: %s", egname);
      try
      {
        eg->onExit();
      }
      catch (const std::exception &e)
      {
        ROS_ERROR("[State Reactor %s] Exception on OnExit - continuing with next state reactor. Exception info: %s",
                  egname, e.what());
      }
    }
  }

References smacc::introspection::demangleSymbol(), orthogonals_, smacc::STATE_EXITING, and stateMachineCurrentAction.

Referenced by smacc::SmaccState< MostDerived, Context, InnerInitial, historyMode >::exit().

Here is the call graph for this function:

Here is the caller graph for this function:

onInitialize()

void smacc::ISmaccStateMachine::onInitialize ( )

virtual

this function should be implemented by the user to create the orthogonals

Definition at line 127 of file smacc_state_machine.cpp.

{
}

Referenced by smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl().

Here is the caller graph for this function:

onInitialized()

void smacc::ISmaccStateMachine::onInitialized ( )

protected

Definition at line 131 of file smacc_state_machine.cpp.

{
    timer_ = nh_.createTimer(ros::Duration(0.5), &ISmaccStateMachine::state_machine_visualization, this);
}

References nh_, state_machine_visualization(), and timer_.

Referenced by smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

param()

template<typename T >

bool smacc::ISmaccStateMachine::param ( std::string  param_name, T &  param_val, const T &  default_val  ) const

protected

Definition at line 419 of file smacc_state_machine_impl.h.

  {
    return nh_.param(param_name, param_val, default_val);
  }

References nh_.

postEvent() [1/2]

template<typename EventType >

void smacc::ISmaccStateMachine::postEvent

(

EventLifeTime

evlifetime = EventLifeTime::ABSOLUTE

)

Definition at line 166 of file smacc_state_machine_impl.h.

  {
    auto *ev = new EventType();
    this->postEvent(ev, evlifetime);
  }

References postEvent().

Here is the call graph for this function:

postEvent() [2/2]

template<typename EventType >

void smacc::ISmaccStateMachine::postEvent	(	EventType *	ev,
		EventLifeTime	evlifetime = EventLifeTime::ABSOLUTE
	)

Definition at line 138 of file smacc_state_machine_impl.h.

  {
    std::lock_guard<std::recursive_mutex> guard(eventQueueMutex_);
    if (evlifetime == EventLifeTime::CURRENT_STATE && (stateMachineCurrentAction == StateMachineInternalAction::STATE_EXITING ||
                                                       stateMachineCurrentAction == StateMachineInternalAction::TRANSITIONING))
    {
      ROS_WARN_STREAM("CURRENT STATE SCOPED EVENT SKIPPED, state is exiting/transitioning " << demangleSymbol<EventType>());
      return;
      // in this case we may lose/skip events, if this is not right for some cases we should create a queue
      // to lock the events during the transitions. This issues appeared when a client asyncbehavior was posting an event
      // meanwhile we were doing the transition, but the main thread was waiting for its correct finalization (with thread.join)
    }
 
    // when a postting event is requested by any component, client, or client behavior
    // we reach this place. Now, we propagate the events to all the state state reactors to generate
    // some more events
 
    ROS_DEBUG_STREAM("[PostEvent entry point] " << demangleSymbol<EventType>());
 
    for (auto currentState : currentState_)
    {
      propagateEventToStateReactors(currentState, ev);
    }
 
    this->signalDetector_->postEvent(ev);
  }

References smacc::CURRENT_STATE, currentState_, eventQueueMutex_, smacc::SignalDetector::postEvent(), propagateEventToStateReactors(), signalDetector_, smacc::STATE_EXITING, stateMachineCurrentAction, and smacc::TRANSITIONING.

Referenced by smacc::ISmaccComponent::postEvent(), smacc::ISmaccClient::postEvent(), smacc::ISmaccClientBehavior::postEvent(), smacc::ISmaccState::postEvent(), postEvent(), and smacc::StateReactor::setOutputEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

propagateEventToStateReactors()

template<typename EventType >

void smacc::ISmaccStateMachine::propagateEventToStateReactors ( ISmaccState *  st, EventType *  ev  )

private

Definition at line 640 of file smacc_state_machine_impl.h.

  {
    ROS_DEBUG("PROPAGATING EVENT [%s] TO LUs [%s]: ", demangleSymbol<EventType>().c_str(), st->getClassName().c_str());
    for (auto &sb : st->getStateReactors())
    {
      sb->notifyEvent(ev);
    }
 
    auto *pst = st->getParentState();
    if (pst != nullptr)
    {
      propagateEventToStateReactors(pst, ev);
    }
  }

References smacc::ISmaccState::getClassName(), smacc::ISmaccState::getParentState(), smacc::ISmaccState::getStateReactors(), and propagateEventToStateReactors().

Referenced by postEvent(), and propagateEventToStateReactors().

Here is the call graph for this function:

Here is the caller graph for this function:

publishTransition()

void smacc::ISmaccStateMachine::publishTransition

(

const SmaccTransitionInfo &

transitionInfo

)

Definition at line 117 of file smacc_state_machine.cpp.

{
    smacc_msgs::SmaccTransitionLogEntry transitionLogEntry;
    transitionLogEntry.timestamp = ros::Time::now();
    transitionInfoToMsg(transitionInfo, transitionLogEntry.transition);
    this->transitionLogHistory_.push_back(transitionLogEntry);
 
    transitionLogPub_.publish(transitionLogEntry);
}

References smacc::introspection::transitionInfoToMsg(), transitionLogHistory_, and transitionLogPub_.

Referenced by smacc::ISmaccState::notifyTransitionFromTransitionTypeInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

requiresComponent()

template<typename SmaccComponentType >

void smacc::ISmaccStateMachine::requiresComponent

(

SmaccComponentType *&

storage

)

Definition at line 94 of file smacc_state_machine_impl.h.

  {
    ROS_DEBUG("component %s is required", demangleSymbol(typeid(SmaccComponentType).name()).c_str());
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
    for (auto ortho : this->orthogonals_)
    {
      for (auto &client : ortho.second->clients_)
      {
 
        storage = client->getComponent<SmaccComponentType>();
        if (storage != nullptr)
        {
          return;
        }
      }
    }
 
    ROS_WARN("component %s is required but it was not found in any orthogonal", demangleSymbol(typeid(SmaccComponentType).name()).c_str());
 
    // std::string componentkey = demangledTypeName<SmaccComponentType>();
    // SmaccComponentType *ret;
 
    // auto it = components_.find(componentkey);
 
    // if (it == components_.end())
    // {
    //     ROS_DEBUG("%s smacc component is required. Creating a new instance.", componentkey.c_str());
 
    //     ret = new SmaccComponentType();
    //     ret->setStateMachine(this);
    //     components_[componentkey] = static_cast<smacc::ISmaccComponent *>(ret);
    //     ROS_DEBUG("%s resource is required. Done.", componentkey.c_str());
    // }
    // else
    // {
    //     ROS_DEBUG("%s resource is required. Found resource in cache.", componentkey.c_str());
    //     ret = dynamic_cast<SmaccComponentType *>(it->second);
    // }
 
    // storage = ret;
  }

References smacc::introspection::demangleSymbol(), m_mutex_, and orthogonals_.

Referenced by mapBehavior(), smacc::ISmaccClientBehavior::requiresComponent(), smacc::ISmaccOrthogonal::requiresComponent(), and smacc::ISmaccState::requiresComponent().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void smacc::ISmaccStateMachine::reset ( )

virtual

Reimplemented in smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >.

Definition at line 64 of file smacc_state_machine.cpp.

{
}

Referenced by smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::reset().

Here is the caller graph for this function:

setGlobalSMData()

template<typename T >

void smacc::ISmaccStateMachine::setGlobalSMData	(	std::string	name,
		T	value
	)

Definition at line 208 of file smacc_state_machine_impl.h.

  {
    {
      std::lock_guard<std::recursive_mutex> lock(m_mutex_);
      // ROS_WARN("set SM Data lock acquire");
 
      globalData_[name] = {[this, name]() {
                             std::stringstream ss;
                             auto val = any_cast<T>(globalData_[name].second);
                             ss << val;
                             return ss.str();
                           },
                           value};
    }
 
    this->updateStatusMessage();
  }

References globalData_, m_mutex_, and updateStatusMessage().

Referenced by cl_move_base_z::CbNavigateGlobalPosition::execute(), mapBehavior(), smacc::ISmaccOrthogonal::setGlobalSMData(), and smacc::ISmaccState::setGlobalSMData().

Here is the call graph for this function:

Here is the caller graph for this function:

setParam()

template<typename T >

void smacc::ISmaccStateMachine::setParam ( std::string  param_name, T  param_val  )

protected

Definition at line 412 of file smacc_state_machine_impl.h.

  {
    return nh_.setParam(param_name, param_val);
  }

References nh_.

state_machine_visualization()

void smacc::ISmaccStateMachine::state_machine_visualization

(

const ros::TimerEvent &

)

Definition at line 155 of file smacc_state_machine.cpp.

{
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
    smacc_msgs::SmaccStateMachine state_machine_msg;
    state_machine_msg.states = stateMachineInfo_->stateMsgs;
    this->stateMachinePub_.publish(state_machine_msg);
 
    status_msg_.header.stamp = ros::Time::now();
    this->stateMachineStatusPub_.publish(status_msg_);
}

References m_mutex_, stateMachineInfo_, stateMachinePub_, stateMachineStatusPub_, and status_msg_.

Referenced by onInitialized().

Here is the caller graph for this function:

stop()

void smacc::ISmaccStateMachine::stop ( )

virtual

Reimplemented in smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >.

Definition at line 68 of file smacc_state_machine.cpp.

{
}

Referenced by smacc::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::stop().

Here is the caller graph for this function:

unlockStateMachine()

void smacc::ISmaccStateMachine::unlockStateMachine ( std::string  msg )

private

Definition at line 173 of file smacc_state_machine.cpp.

{
    ROS_DEBUG("unlocking state machine: %s", msg.c_str());
    m_mutex_.unlock();
}

References m_mutex_.

Referenced by createOrthogonal(), notifyOnStateExited(), and smacc::SignalDetector::pollOnce().

Here is the caller graph for this function:

updateStatusMessage()

void smacc::ISmaccStateMachine::updateStatusMessage ( )

private

Definition at line 81 of file smacc_state_machine.cpp.

{
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
    if (currentStateInfo_ != nullptr)
    {
        ROS_WARN_STREAM("[StateMachine] setting state active "
                        << ": " << currentStateInfo_->getFullPath());
 
        if (this->runMode_ == SMRunMode::DEBUG)
        {
            status_msg_.current_states.clear();
            std::list<const SmaccStateInfo *> ancestorList;
            currentStateInfo_->getAncestors(ancestorList);
 
            for (auto &ancestor : ancestorList)
            {
                status_msg_.current_states.push_back(ancestor->toShortName());
            }
 
            status_msg_.global_variable_names.clear();
            status_msg_.global_variable_values.clear();
 
            for (auto entry : this->globalData_)
            {
                status_msg_.global_variable_names.push_back(entry.first);
                status_msg_.global_variable_values.push_back(entry.second.first()); // <- invoke to_string()
            }
 
            status_msg_.header.stamp = ros::Time::now();
            status_msg_.header.frame_id = "odom";
            this->stateMachineStatusPub_.publish(status_msg_);
        }
    }
}

References currentStateInfo_, smacc::DEBUG, globalData_, m_mutex_, runMode_, stateMachineStatusPub_, and status_msg_.

Referenced by notifyOnRuntimeConfigurationFinished(), notifyOnStateEntryEnd(), and setGlobalSMData().

Here is the caller graph for this function:

Friends And Related Function Documentation

ISmaccState

friend class ISmaccState

friend

Definition at line 215 of file smacc_state_machine.h.

SignalDetector

friend class SignalDetector

friend

Definition at line 216 of file smacc_state_machine.h.

Member Data Documentation

currentState_

std::vector<ISmaccState*> smacc::ISmaccStateMachine::currentState_

protected

Definition at line 175 of file smacc_state_machine.h.

Referenced by getCurrentState(), notifyOnRuntimeConfigurationFinished(), notifyOnStateEntryEnd(), notifyOnStateEntryStart(), notifyOnStateExited(), and postEvent().

currentStateInfo_

std::shared_ptr<SmaccStateInfo> smacc::ISmaccStateMachine::currentStateInfo_

protected

Definition at line 177 of file smacc_state_machine.h.

Referenced by getCurrentStateInfo(), notifyOnStateEntryStart(), and updateStatusMessage().

eventQueueMutex_

std::recursive_mutex smacc::ISmaccStateMachine::eventQueueMutex_

private

Definition at line 186 of file smacc_state_machine.h.

Referenced by postEvent().

globalData_

std::map<std::string, std::pair<std::function<std::string()>, boost::any> > smacc::ISmaccStateMachine::globalData_

private

Definition at line 193 of file smacc_state_machine.h.

Referenced by getGlobalSMData(), setGlobalSMData(), and updateStatusMessage().

m_mutex_

std::recursive_mutex smacc::ISmaccStateMachine::m_mutex_

private

Definition at line 185 of file smacc_state_machine.h.

Referenced by createSignalConnection(), getGlobalSMData(), getOrthogonal(), lockStateMachine(), notifyOnRuntimeConfigurationFinished(), notifyOnStateEntryEnd(), notifyOnStateEntryStart(), requiresComponent(), setGlobalSMData(), state_machine_visualization(), unlockStateMachine(), and updateStatusMessage().

nh_

ros::NodeHandle smacc::ISmaccStateMachine::nh_

protected

Definition at line 164 of file smacc_state_machine.h.

Referenced by getNode(), getParam(), initializeROS(), ISmaccStateMachine(), onInitialized(), param(), and setParam().

orthogonals_

std::map<std::string, std::shared_ptr<smacc::ISmaccOrthogonal> > smacc::ISmaccStateMachine::orthogonals_

protected

Definition at line 182 of file smacc_state_machine.h.

Referenced by createOrthogonal(), getOrthogonal(), getOrthogonals(), notifyOnRuntimeConfigurationFinished(), notifyOnStateEntryEnd(), notifyOnStateEntryStart(), notifyOnStateExited(), notifyOnStateExitting(), and requiresComponent().

private_nh_

ros::NodeHandle smacc::ISmaccStateMachine::private_nh_

protected

Definition at line 165 of file smacc_state_machine.h.

runMode_

smacc::SMRunMode smacc::ISmaccStateMachine::runMode_

private

Definition at line 197 of file smacc_state_machine.h.

Referenced by ISmaccStateMachine(), and updateStatusMessage().

signalDetector_

SignalDetector* smacc::ISmaccStateMachine::signalDetector_

private

Definition at line 200 of file smacc_state_machine.h.

Referenced by ISmaccStateMachine(), notifyOnRuntimeConfigurationFinished(), notifyOnStateExited(), and postEvent().

stateCallbackConnections

std::map<void*, std::shared_ptr<CallbackCounterSemaphore> > smacc::ISmaccStateMachine::stateCallbackConnections

private

Definition at line 190 of file smacc_state_machine.h.

Referenced by createSignalConnection(), disconnectSmaccSignalObject(), and notifyOnStateExited().

stateMachineCurrentAction

StateMachineInternalAction smacc::ISmaccStateMachine::stateMachineCurrentAction

private

Definition at line 188 of file smacc_state_machine.h.

Referenced by notifyOnRuntimeConfigurationFinished(), notifyOnRuntimeConfigured(), notifyOnStateEntryEnd(), notifyOnStateExited(), notifyOnStateExitting(), smacc::SignalDetector::pollOnce(), and postEvent().

stateMachineInfo_

std::shared_ptr<SmaccStateMachineInfo> smacc::ISmaccStateMachine::stateMachineInfo_

private

Definition at line 211 of file smacc_state_machine.h.

Referenced by buildStateMachineInfo(), getStateMachineInfo(), notifyOnStateEntryStart(), and state_machine_visualization().

stateMachinePub_

ros::Publisher smacc::ISmaccStateMachine::stateMachinePub_

protected

Definition at line 168 of file smacc_state_machine.h.

Referenced by initializeROS(), and state_machine_visualization().

stateMachineStatusPub_

ros::Publisher smacc::ISmaccStateMachine::stateMachineStatusPub_

protected

Definition at line 169 of file smacc_state_machine.h.

Referenced by initializeROS(), state_machine_visualization(), and updateStatusMessage().

stateSeqCounter_

uint64_t smacc::ISmaccStateMachine::stateSeqCounter_

private

Definition at line 202 of file smacc_state_machine.h.

Referenced by getCurrentStateCounter(), and notifyOnStateEntryStart().

status_msg_

smacc_msgs::SmaccStatus smacc::ISmaccStateMachine::status_msg_

protected

Definition at line 179 of file smacc_state_machine.h.

Referenced by state_machine_visualization(), and updateStatusMessage().

timer_

ros::Timer smacc::ISmaccStateMachine::timer_

protected

Definition at line 167 of file smacc_state_machine.h.

Referenced by onInitialized().

transitionHistoryService_

ros::ServiceServer smacc::ISmaccStateMachine::transitionHistoryService_

protected

Definition at line 171 of file smacc_state_machine.h.

Referenced by initializeROS().

transitionLogHistory_

std::vector<smacc_msgs::SmaccTransitionLogEntry> smacc::ISmaccStateMachine::transitionLogHistory_

private

Definition at line 195 of file smacc_state_machine.h.

Referenced by getTransitionLogHistory(), and publishTransition().

transitionLogPub_

ros::Publisher smacc::ISmaccStateMachine::transitionLogPub_

protected

Definition at line 170 of file smacc_state_machine.h.

Referenced by initializeROS(), and publishTransition().

---

The documentation for this class was generated from the following files:

• smacc/include/smacc/smacc_state_machine.h
• smacc/include/smacc/impl/smacc_state_machine_impl.h
• smacc/src/smacc/smacc_state_machine.cpp