#include <smacc_state_machine.hpp>

Inheritance diagram for smacc2::ISmaccStateMachine:

Collaboration diagram for smacc2::ISmaccStateMachine:

Public Member Functions
	ISmaccStateMachine (std::string stateMachineName, SignalDetector *signalDetector, rclcpp::NodeOptions nodeOptions=rclcpp::NodeOptions())

virtual	~ISmaccStateMachine ()

virtual void	reset ()

virtual void	stop ()

virtual void	eStop ()

template<typename TOrthogonal >
TOrthogonal *	getOrthogonal ()

template<typename TOrthogonal , typename TClientBehavior >
TClientBehavior *	getClientBehavior (int index=0)

const std::map< std::string, std::shared_ptr< smacc2::ISmaccOrthogonal > > &	getOrthogonals () const

template<typename SmaccComponentType >
void	requiresComponent (SmaccComponentType *&storage, bool throwsExceptionIfNotExist=false)

template<typename EventType >
void	postEvent (EventType *ev, EventLifeTime evlifetime=EventLifeTime::ABSOLUTE)

template<typename EventType >
void	postEvent (EventLifeTime evlifetime=EventLifeTime::ABSOLUTE)

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 ()

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

void	getTransitionLogHistory (const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< smacc2_msgs::srv::SmaccGetTransitionHistory::Request > req, std::shared_ptr< smacc2_msgs::srv::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)

int64_t	getCurrentStateCounter () const

ISmaccState *	getCurrentState () const

const SmaccStateMachineInfo &	getStateMachineInfo ()

template<typename InitialStateType >
void	buildStateMachineInfo ()

rclcpp::Node::SharedPtr	getNode ()

rclcpp::Logger	getLogger ()

std::recursive_mutex &	getMutex ()

Protected Member Functions
void	checkStateMachineConsistence ()

void	initializeROS (std::string smshortname)

void	onInitialized ()

template<typename TOrthogonal >
void	createOrthogonal ()

Protected Attributes
rclcpp::Node::SharedPtr	nh_

rclcpp::TimerBase::SharedPtr	timer_

rclcpp::Publisher< smacc2_msgs::msg::SmaccStateMachine >::SharedPtr	stateMachinePub_

rclcpp::Publisher< smacc2_msgs::msg::SmaccStatus >::SharedPtr	stateMachineStatusPub_

rclcpp::Publisher< smacc2_msgs::msg::SmaccTransitionLogEntry >::SharedPtr	transitionLogPub_

rclcpp::Service< smacc2_msgs::srv::SmaccGetTransitionHistory >::SharedPtr	transitionHistoryService_

std::vector< ISmaccState * >	currentState_

std::shared_ptr< SmaccStateInfo >	currentStateInfo_

smacc2_msgs::msg::SmaccStatus	status_msg_

std::map< std::string, std::shared_ptr< smacc2::ISmaccOrthogonal > >	orthogonals_

std::vector< boost::signals2::scoped_connection >	longLivedSignalConnections_

std::shared_ptr< SmaccStateMachineInfo >	stateMachineInfo_

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< smacc2_msgs::msg::SmaccTransitionLogEntry >	transitionLogHistory_

smacc2::SMRunMode	runMode_

SignalDetector *	signalDetector_

int64_t	stateSeqCounter_

Friends
class	ISmaccState

class	SignalDetector

Detailed Description

Definition at line 64 of file smacc_state_machine.hpp.

Constructor & Destructor Documentation

◆ ISmaccStateMachine()

smacc2::ISmaccStateMachine::ISmaccStateMachine	(	std::string	stateMachineName,
		SignalDetector *	signalDetector,
		rclcpp::NodeOptions	nodeOptions = `rclcpp::NodeOptions()`
	)

Definition at line 35 of file smacc_state_machine.cpp.

: nh_(nullptr), stateSeqCounter_(0)
{
  // This enables loading arbitrary parameters
  // However, best practice would be to declare parameters in the corresponding classes
  // and provide descriptions about expected use
  // TODO(henningkayser): remove once all parameters are declared inside the components
  // node_options.automatically_declare_parameters_from_overrides(true);
 
  nh_ = rclcpp::Node::make_shared(stateMachineName, nodeOptions);  //
  RCLCPP_INFO_STREAM(
    nh_->get_logger(), "Creating State Machine Base: " << nh_->get_fully_qualified_name());
 
  signalDetector_ = signalDetector;
  signalDetector_->initialize(this);
 
  std::string runMode;
  if (nh_->get_parameter("run_mode", runMode))
  {
    if (runMode == "debug")
    {
      runMode_ = SMRunMode::DEBUG;
    }
    else if (runMode == "release")
    {
      runMode_ = SMRunMode::RELEASE;
    }
    else
    {
      RCLCPP_ERROR(nh_->get_logger(), "Incorrect run_mode value: %s", runMode.c_str());
    }
  }
  else
  {
    runMode_ = SMRunMode::DEBUG;
  }
}

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

Here is the call graph for this function:

◆ ~ISmaccStateMachine()

smacc2::ISmaccStateMachine::~ISmaccStateMachine ( )

virtual

Definition at line 74 of file smacc_state_machine.cpp.

{
  RCLCPP_INFO(nh_->get_logger(), "Finishing State Machine");
}

References nh_.

Member Function Documentation

◆ buildStateMachineInfo()

template<typename InitialStateType >

void smacc2::ISmaccStateMachine::buildStateMachineInfo ( )

Definition at line 747 of file smacc_state_machine_impl.hpp.

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

References checkStateMachineConsistence(), getNode(), and stateMachineInfo_.

Here is the call graph for this function:

◆ checkStateMachineConsistence()

void smacc2::ISmaccStateMachine::checkStateMachineConsistence ( )

protected

Definition at line 228 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)
  // {
  //     RCLCPP_WARN_STREAM(nh_->get_logger(),"== 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 smacc2::ISmaccStateMachine::createOrthogonal ( )

protected

Definition at line 93 of file smacc_state_machine_impl.hpp.

{
  //this->lockStateMachine("create orthogonal");
  std::lock_guard<std::recursive_mutex> guard(m_mutex_);
 
  std::string orthogonalkey = demangledTypeName<TOrthogonal>();
 
  if (orthogonals_.count(orthogonalkey) == 0)
  {
    auto ret = std::make_shared<TOrthogonal>();
    orthogonals_[orthogonalkey] = dynamic_pointer_cast<smacc2::ISmaccOrthogonal>(ret);
 
    ret->setStateMachine(this);
 
    RCLCPP_INFO(getLogger(), "%s Orthogonal is created", orthogonalkey.c_str());
  }
  else
  {
    RCLCPP_WARN_STREAM(
      getLogger(), "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;
    }
    RCLCPP_WARN_STREAM(getLogger(), ss.str());
  }
  //this->unlockStateMachine("create orthogonal");
}

References getLogger(), m_mutex_, and orthogonals_.

Here is the call graph for this function:

◆ createSignalConnection()

template<typename TSmaccSignal , typename TMemberFunctionPrototype , typename TSmaccObjectType >

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

Definition at line 412 of file smacc_state_machine_impl.hpp.

{
  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)
  {
    RCLCPP_INFO(
      getLogger(),
      "[StateMachine] long life-time smacc signal subscription created. Subscriber is %s. Callback "
      "is: %s",
      demangledTypeName<TSmaccObjectType>().c_str(),
      demangleSymbol(typeid(callback).name()).c_str());
 
    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)
  {
    RCLCPP_INFO(
      getLogger(),
      "[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
  {
    RCLCPP_WARN(
      getLogger(),
      "[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 smacc2::introspection::demangleSymbol(), getLogger(), m_mutex_, and stateCallbackConnections.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnectSmaccSignalObject()

void smacc2::ISmaccStateMachine::disconnectSmaccSignalObject ( void * object )

Definition at line 79 of file smacc_state_machine.cpp.

{
  RCLCPP_INFO(
    nh_->get_logger(), "[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
  {
    RCLCPP_INFO(nh_->get_logger(), "[SmaccSignals] no signals found %ld", (long)object_ptr);
  }
}

References nh_, and stateCallbackConnections.

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

Here is the caller graph for this function:

◆ eStop()

void smacc2::ISmaccStateMachine::eStop ( )

virtual

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

Definition at line 101 of file smacc_state_machine.cpp.

101{}

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

Here is the caller graph for this function:

◆ getClientBehavior()

template<typename TOrthogonal , typename TClientBehavior >

TClientBehavior * smacc2::ISmaccStateMachine::getClientBehavior ( int index = 0 )

inline

Definition at line 85 of file smacc_state_machine.hpp.

  {
    auto orthogonal = this->template getOrthogonal<TOrthogonal>();
 
    return orthogonal->template getClientBehavior<TClientBehavior>(index);
  }

◆ getCurrentState()

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

inline

Definition at line 757 of file smacc_state_machine_impl.hpp.

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

smacc2::ISmaccStateMachine::currentState_

std::vector< ISmaccState * > currentState_

Definition smacc_state_machine.hpp:190

References currentState_.

Referenced by cl_nav2z::CpWaypointNavigator::sendNextGoal().

Here is the caller graph for this function:

◆ getCurrentStateCounter()

int64_t smacc2::ISmaccStateMachine::getCurrentStateCounter ( ) const

inline

Definition at line 755 of file smacc_state_machine_impl.hpp.

755{ return this->stateSeqCounter_; }

References stateSeqCounter_.

◆ getCurrentStateInfo()

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

inline

Definition at line 118 of file smacc_state_machine.hpp.

118{ return currentStateInfo_; }

smacc2::ISmaccStateMachine::currentStateInfo_

std::shared_ptr< SmaccStateInfo > currentStateInfo_

Definition smacc_state_machine.hpp:192

References currentStateInfo_.

◆ getGlobalSMData()

template<typename T >

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

Definition at line 225 of file smacc_state_machine_impl.hpp.

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

References getLogger(), globalData_, and m_mutex_.

Referenced by smacc2::ISmaccOrthogonal::getGlobalSMData(), and mapBehavior().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLogger()

rclcpp::Logger smacc2::ISmaccStateMachine::getLogger ( )

inline

Definition at line 165 of file smacc_state_machine.hpp.

165{ return nh_->get_logger(); }

References nh_.

Referenced by createOrthogonal(), createSignalConnection(), getGlobalSMData(), getOrthogonal(), smacc2::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl(), mapBehavior(), notifyOnStateEntryEnd(), notifyOnStateEntryStart(), notifyOnStateExited(), notifyOnStateExitting(), postEvent(), postEvent(), propagateEventToStateReactors(), and requiresComponent().

Here is the caller graph for this function:

◆ getMutex()

std::recursive_mutex & smacc2::ISmaccStateMachine::getMutex ( )

inline

Definition at line 167 of file smacc_state_machine.hpp.

167{ return this->m_mutex_; }

References m_mutex_.

◆ getNode()

rclcpp::Node::SharedPtr smacc2::ISmaccStateMachine::getNode ( )

Definition at line 95 of file smacc_state_machine.cpp.

95{ return this->nh_; }

References nh_.

Referenced by buildStateMachineInfo(), smacc2::ISmaccClient::getNode(), smacc2::ISmaccOrthogonal::getNode(), smacc2::SignalDetector::getNode(), smacc2::ISmaccClientBehavior::getNode(), smacc2::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl(), and smacc2::SignalDetector::pollOnce().

Here is the caller graph for this function:

◆ getOrthogonal()

template<typename TOrthogonal >

TOrthogonal * smacc2::ISmaccStateMachine::getOrthogonal ( )

Definition at line 55 of file smacc_state_machine_impl.hpp.

{
  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())
  {
    RCLCPP_DEBUG(
      getLogger(),
      "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;
    }
 
    RCLCPP_WARN_STREAM(getLogger(), ss.str());
 
    return nullptr;
  }
}

References getLogger(), m_mutex_, and orthogonals_.

Here is the call graph for this function:

◆ getOrthogonals()

const std::map< std::string, std::shared_ptr< smacc2::ISmaccOrthogonal > > & smacc2::ISmaccStateMachine::getOrthogonals ( ) const

Definition at line 104 of file smacc_state_machine.cpp.

{
  return this->orthogonals_;
}

References orthogonals_.

Referenced by smacc2::introspection::SmaccStateMachineInfo::assembleSMStructureMessage(), smacc2::SignalDetector::findUpdatableClientsAndComponents(), smacc2::SignalDetector::findUpdatableStateElements(), and smacc2::ISmaccOrthogonal::requiresClient().

Here is the caller graph for this function:

◆ getStateMachineInfo()

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

inline

Definition at line 759 of file smacc_state_machine_impl.hpp.

{
  return *this->stateMachineInfo_;
}

References stateMachineInfo_.

◆ getStateMachineName()

std::string smacc2::ISmaccStateMachine::getStateMachineName ( )

Definition at line 223 of file smacc_state_machine.cpp.

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

References smacc2::introspection::demangleSymbol().

Here is the call graph for this function:

◆ getTransitionLogHistory()

void smacc2::ISmaccStateMachine::getTransitionLogHistory	(	const std::shared_ptr< rmw_request_id_t >	request_header,
		const std::shared_ptr< smacc2_msgs::srv::SmaccGetTransitionHistory::Request >	req,
		std::shared_ptr< smacc2_msgs::srv::SmaccGetTransitionHistory::Response >	res
	)

Definition at line 184 of file smacc_state_machine.cpp.

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

References nh_, and transitionLogHistory_.

Referenced by initializeROS().

Here is the caller graph for this function:

◆ initializeROS()

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

protected

Definition at line 165 of file smacc_state_machine.cpp.

{
  RCLCPP_WARN_STREAM(nh_->get_logger(), "State machine base creation:" << shortname);
  // STATE MACHINE TOPICS
  stateMachinePub_ = nh_->create_publisher<smacc2_msgs::msg::SmaccStateMachine>(
    shortname + "/smacc/state_machine_description", rclcpp::QoS(1));
  stateMachineStatusPub_ = nh_->create_publisher<smacc2_msgs::msg::SmaccStatus>(
    shortname + "/smacc/status", rclcpp::QoS(1));
  transitionLogPub_ = nh_->create_publisher<smacc2_msgs::msg::SmaccTransitionLogEntry>(
    shortname + "/smacc/transition_log", rclcpp::QoS(1));
 
  // STATE MACHINE SERVICES
  transitionHistoryService_ = nh_->create_service<smacc2_msgs::srv::SmaccGetTransitionHistory>(
    shortname + "/smacc/transition_log_history",
    std::bind(
      &ISmaccStateMachine::getTransitionLogHistory, this, std::placeholders::_1,
      std::placeholders::_2, std::placeholders::_3));
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lockStateMachine()

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

private

Definition at line 211 of file smacc_state_machine.cpp.

{
  RCLCPP_DEBUG(nh_->get_logger(), "-- locking SM: %s", msg.c_str());
  m_mutex_.lock();
}

References m_mutex_, and nh_.

Referenced by notifyOnStateExited().

Here is the caller graph for this function:

◆ mapBehavior()

template<typename StateField , typename BehaviorType >

void smacc2::ISmaccStateMachine::mapBehavior ( )

Definition at line 281 of file smacc_state_machine_impl.hpp.

{
  std::string stateFieldName = demangleSymbol(typeid(StateField).name());
  std::string behaviorType = demangleSymbol(typeid(BehaviorType).name());
  RCLCPP_INFO(
    getLogger(), "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 smacc2::introspection::demangleSymbol(), getGlobalSMData(), getLogger(), requiresComponent(), and setGlobalSMData().

Here is the call graph for this function:

◆ notifyOnRuntimeConfigurationFinished()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnRuntimeConfigurationFinished ( StateType * state )

Definition at line 569 of file smacc_state_machine_impl.hpp.

{
  for (auto pair : this->orthogonals_)
  {
    // RCLCPP_INFO(getLogger(),"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_, smacc2::SignalDetector::notifyStateConfigured(), orthogonals_, signalDetector_, smacc2::STATE_ENTERING, stateMachineCurrentAction, and updateStatusMessage().

Here is the call graph for this function:

◆ notifyOnRuntimeConfigured()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnRuntimeConfigured ( StateType * state )

Definition at line 588 of file smacc_state_machine_impl.hpp.

{
  stateMachineCurrentAction = StateMachineInternalAction::STATE_CONFIGURING;
}

References smacc2::STATE_CONFIGURING, and stateMachineCurrentAction.

◆ notifyOnStateEntryEnd()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnStateEntryEnd ( StateType * state )

Definition at line 501 of file smacc_state_machine_impl.hpp.

{
  RCLCPP_INFO(
    getLogger(), "[%s] State OnEntry code finished",
    demangleSymbol(typeid(StateType).name()).c_str());
 
  auto currentState = this->currentState_.back();
  for (auto pair : this->orthogonals_)
  {
    RCLCPP_DEBUG(getLogger(), "ortho onentry: %s", pair.second->getName().c_str());
    auto & orthogonal = pair.second;
    try
    {
      orthogonal->onEntry();
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[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 = smacc2::demangleSymbol(typeid(*sr).name());
    RCLCPP_INFO_STREAM(getLogger(), "state reactor onEntry: " << srname);
    try
    {
      sr->onEntry();
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[State Reactor %s] Exception on Entry - continuing with next state reactor. Exception "
        "info: %s",
        srname.c_str(), e.what());
    }
  }
 
  for (auto & eg : currentState->getEventGenerators())
  {
    auto egname = smacc2::demangleSymbol(typeid(*eg).name());
    RCLCPP_INFO_STREAM(getLogger(), "event generator onEntry: " << egname);
    try
    {
      eg->onEntry();
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[Event generator %s] Exception on Entry - continuing with next state reactor. Exception "
        "info: %s",
        egname.c_str(), e.what());
    }
  }
 
  {
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
    this->updateStatusMessage();
    stateMachineCurrentAction = StateMachineInternalAction::STATE_RUNNING;
  }
}

References currentState_, smacc2::introspection::demangleSymbol(), getLogger(), m_mutex_, orthogonals_, smacc2::STATE_RUNNING, stateMachineCurrentAction, and updateStatusMessage().

Here is the call graph for this function:

◆ notifyOnStateEntryStart()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnStateEntryStart ( StateType * state )

Definition at line 485 of file smacc_state_machine_impl.hpp.

{
  std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
  RCLCPP_DEBUG(
    getLogger(),
    "[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_, smacc2::introspection::demangleSymbol(), getLogger(), m_mutex_, orthogonals_, stateMachineInfo_, and stateSeqCounter_.

Here is the call graph for this function:

◆ notifyOnStateExited()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnStateExited ( StateType * state )

Definition at line 656 of file smacc_state_machine_impl.hpp.

{
  this->lockStateMachine("state exit");
 
  signalDetector_->notifyStateExited(state);
 
  auto fullname = demangleSymbol(typeid(StateType).name());
  RCLCPP_WARN_STREAM(getLogger(), "exiting state: " << fullname);
 
  RCLCPP_INFO_STREAM(getLogger(), "Notification State Disposing: leaving state" << state);
  for (auto pair : this->orthogonals_)
  {
    auto & orthogonal = pair.second;
    try
    {
      orthogonal->onDispose();
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[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 = smacc2::demangleSymbol(typeid(*sr).name()).c_str();
    RCLCPP_INFO(getLogger(), "state reactor disposing: %s", srname);
    try
    {
      this->disconnectSmaccSignalObject(sr.get());
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[State Reactor %s] Exception on OnDispose - continuing with next state reactor. Exception "
        "info: %s",
        srname, e.what());
    }
  }
 
  for (auto & eg : state->getEventGenerators())
  {
    auto egname = smacc2::demangleSymbol(typeid(*eg).name()).c_str();
    RCLCPP_INFO(getLogger(), "state reactor disposing: %s", egname);
    try
    {
      this->disconnectSmaccSignalObject(eg.get());
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[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
  RCLCPP_WARN_STREAM(getLogger(), "state exit: " << fullname);
 
  stateMachineCurrentAction = StateMachineInternalAction::TRANSITIONING;
  this->unlockStateMachine("state exit");
}

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

Here is the call graph for this function:

◆ notifyOnStateExitting()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnStateExitting ( StateType * state )

Definition at line 594 of file smacc_state_machine_impl.hpp.

{
  stateMachineCurrentAction = StateMachineInternalAction::STATE_EXITING;
  auto fullname = demangleSymbol(typeid(StateType).name());
  RCLCPP_WARN_STREAM(getLogger(), "exiting state: " << fullname);
  // this->set_parameter("destroyed", true);
 
  RCLCPP_INFO_STREAM(getLogger(), "Notification State Exit: leaving state " << state);
  for (auto pair : this->orthogonals_)
  {
    auto & orthogonal = pair.second;
    try
    {
      orthogonal->onExit();
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[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 = smacc2::demangleSymbol(typeid(*sr).name());
    RCLCPP_INFO_STREAM(getLogger(), "state reactor OnExit: " << srname);
    try
    {
      sr->onExit();
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[State Reactor %s] Exception on OnExit - continuing with next state reactor. Exception "
        "info: %s",
        srname.c_str(), e.what());
    }
  }
 
  for (auto & eg : state->getEventGenerators())
  {
    auto egname = smacc2::demangleSymbol(typeid(*eg).name());
    RCLCPP_INFO_STREAM(getLogger(), "event generator OnExit: " << egname);
    try
    {
      eg->onExit();
    }
    catch (const std::exception & e)
    {
      RCLCPP_ERROR(
        getLogger(),
        "[State Reactor %s] Exception on OnExit - continuing with next state reactor. Exception "
        "info: %s",
        egname.c_str(), e.what());
    }
  }
}

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

Here is the call graph for this function:

◆ onInitialize()

void smacc2::ISmaccStateMachine::onInitialize ( )

virtual

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

Definition at line 156 of file smacc_state_machine.cpp.

156{}

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

Here is the caller graph for this function:

◆ onInitialized()

void smacc2::ISmaccStateMachine::onInitialized ( )

protected

Definition at line 158 of file smacc_state_machine.cpp.

{
  auto ros_clock = rclcpp::Clock::make_shared();
  timer_ =
    rclcpp::create_timer(nh_, ros_clock, 0.5s, [=]() { this->state_machine_visualization(); });
}

References nh_, state_machine_visualization(), and timer_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postEvent() [1/2]

template<typename EventType >

void smacc2::ISmaccStateMachine::postEvent ( EventLifeTime evlifetime = EventLifeTime::ABSOLUTE )

Definition at line 216 of file smacc_state_machine_impl.hpp.

{
  auto evname = smacc2::introspection::demangleSymbol<EventType>();
  RCLCPP_INFO_STREAM(getLogger(), "Event " << evname);
  auto * ev = new EventType();
  this->postEvent(ev, evlifetime);
}

References getLogger(), and postEvent().

Here is the call graph for this function:

◆ postEvent() [2/2]

template<typename EventType >

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

Definition at line 178 of file smacc_state_machine_impl.hpp.

{
  std::lock_guard<std::recursive_mutex> guard(eventQueueMutex_);
 
#define eventtypename demangleSymbol<EventType>().c_str()
 
  TRACEPOINT(smacc2_event, eventtypename);
 
  if (
    evlifetime == EventLifeTime::CURRENT_STATE &&
    (stateMachineCurrentAction == StateMachineInternalAction::STATE_EXITING ||
     stateMachineCurrentAction == StateMachineInternalAction::TRANSITIONING))
  {
    RCLCPP_WARN_STREAM(
      getLogger(),
      "[ISmaccStateMachine] CURRENT STATE SCOPED EVENT DISCARDED, state is exiting/transitioning "
        << eventtypename);
    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
 
  RCLCPP_DEBUG_STREAM(getLogger(), "[PostEvent entry point] " << eventtypename);
  for (auto currentState : currentState_)
  {
    propagateEventToStateReactors(currentState, ev);
  }
 
  this->signalDetector_->postEvent(ev);
}

References smacc2::CURRENT_STATE, currentState_, eventQueueMutex_, eventtypename, getLogger(), smacc2::SignalDetector::postEvent(), propagateEventToStateReactors(), signalDetector_, smacc2_event, smacc2::STATE_EXITING, stateMachineCurrentAction, TRACEPOINT(), and smacc2::TRANSITIONING.

Referenced by smacc2::ISmaccComponent::postEvent(), smacc2::ISmaccClient::postEvent(), smacc2::ISmaccComponent::postEvent(), smacc2::ISmaccClient::postEvent(), smacc2::ISmaccClientBehavior::postEvent(), and postEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ propagateEventToStateReactors()

template<typename EventType >

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

private

Definition at line 729 of file smacc_state_machine_impl.hpp.

{
  RCLCPP_DEBUG(
    getLogger(), "PROPAGATING EVENT [%s] TO SRs [%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 getLogger(), 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 smacc2::ISmaccStateMachine::publishTransition ( const SmaccTransitionInfo & transitionInfo )

Definition at line 146 of file smacc_state_machine.cpp.

{
  smacc2_msgs::msg::SmaccTransitionLogEntry transitionLogEntry;
  transitionLogEntry.timestamp = this->nh_->now();
  transitionInfoToMsg(transitionInfo, transitionLogEntry.transition);
  this->transitionLogHistory_.push_back(transitionLogEntry);
 
  transitionLogPub_->publish(transitionLogEntry);
}

References nh_, smacc2::introspection::transitionInfoToMsg(), transitionLogHistory_, and transitionLogPub_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ requiresComponent()

template<typename SmaccComponentType >

void smacc2::ISmaccStateMachine::requiresComponent	(	SmaccComponentType *&	storage,
		bool	throwsExceptionIfNotExist = `false`
	)

Definition at line 127 of file smacc_state_machine_impl.hpp.

{
  RCLCPP_DEBUG(
    getLogger(), "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;
      }
    }
  }
 
  RCLCPP_WARN(
    getLogger(), "component %s is required but it was not found in any orthogonal",
    demangleSymbol(typeid(SmaccComponentType).name()).c_str());
 
  if (throwsException)
    throw std::runtime_error("component is required but it was not found in any orthogonal");
 
  // std::string componentkey = demangledTypeName<SmaccComponentType>();
  // SmaccComponentType *ret;
 
  // auto it = components_.find(componentkey);
 
  // if (it == components_.end())
  // {
  //     RCLCPP_DEBUG(getLogger(),"%s smacc component is required. Creating a new instance.",
  //     componentkey.c_str());
 
  //     ret = new SmaccComponentType();
  //     ret->setStateMachine(this);
  //     components_[componentkey] = static_cast<smacc2::ISmaccComponent *>(ret);
  //     RCLCPP_DEBUG(getLogger(),"%s resource is required. Done.", componentkey.c_str());
  // }
  // else
  // {
  //     RCLCPP_DEBUG(getLogger(),"%s resource is required. Found resource in cache.",
  //     componentkey.c_str()); ret = dynamic_cast<SmaccComponentType *>(it->second);
  // }
 
  // storage = ret;
}

References smacc2::introspection::demangleSymbol(), getLogger(), m_mutex_, and orthogonals_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

void smacc2::ISmaccStateMachine::reset ( )

virtual

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

Definition at line 97 of file smacc_state_machine.cpp.

97{}

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

Here is the caller graph for this function:

◆ setGlobalSMData()

template<typename T >

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

Definition at line 260 of file smacc_state_machine_impl.hpp.

{
  {
    std::lock_guard<std::recursive_mutex> lock(m_mutex_);
    // RCLCPP_WARN(getLogger(),"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 mapBehavior(), and smacc2::ISmaccOrthogonal::setGlobalSMData().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ state_machine_visualization()

void smacc2::ISmaccStateMachine::state_machine_visualization ( )

Definition at line 195 of file smacc_state_machine.cpp.

{
  std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
  smacc2_msgs::msg::SmaccStateMachine state_machine_msg;
  state_machine_msg.states = stateMachineInfo_->stateMsgs;
 
  std::sort(
    state_machine_msg.states.begin(), state_machine_msg.states.end(),
    [](auto & a, auto & b) { return a.index < b.index; });
  stateMachinePub_->publish(state_machine_msg);
 
  status_msg_.header.stamp = this->nh_->now();
  stateMachineStatusPub_->publish(status_msg_);
}

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

Referenced by onInitialized().

Here is the caller graph for this function:

◆ stop()

void smacc2::ISmaccStateMachine::stop ( )

virtual

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

Definition at line 99 of file smacc_state_machine.cpp.

99{}

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

Here is the caller graph for this function:

◆ unlockStateMachine()

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

private

Definition at line 217 of file smacc_state_machine.cpp.

{
  RCLCPP_DEBUG(nh_->get_logger(), "-- unlocking SM: %s", msg.c_str());
  m_mutex_.unlock();
}

References m_mutex_, and nh_.

Referenced by notifyOnStateExited().

Here is the caller graph for this function:

◆ updateStatusMessage()

void smacc2::ISmaccStateMachine::updateStatusMessage ( )

private

Definition at line 109 of file smacc_state_machine.cpp.

{
  std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
  if (currentStateInfo_ != nullptr)
  {
    RCLCPP_WARN_STREAM(
      nh_->get_logger(), "[StateMachine] setting state active "
                           << ": " << currentStateInfo_->getFullPath());
 
    if (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 = this->nh_->now();
      stateMachineStatusPub_->publish(status_msg_);
    }
  }
}

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

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

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ ISmaccState

friend class ISmaccState

friend

Definition at line 234 of file smacc_state_machine.hpp.

◆ SignalDetector

friend class SignalDetector

friend

Definition at line 235 of file smacc_state_machine.hpp.

Member Data Documentation

◆ currentState_

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

protected

Definition at line 190 of file smacc_state_machine.hpp.

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

◆ currentStateInfo_

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

protected

Definition at line 192 of file smacc_state_machine.hpp.

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

◆ eventQueueMutex_

std::recursive_mutex smacc2::ISmaccStateMachine::eventQueueMutex_

private

Definition at line 206 of file smacc_state_machine.hpp.

Referenced by postEvent().

◆ globalData_

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

private

Definition at line 213 of file smacc_state_machine.hpp.

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

◆ longLivedSignalConnections_

std::vector<boost::signals2::scoped_connection> smacc2::ISmaccStateMachine::longLivedSignalConnections_

protected

Definition at line 199 of file smacc_state_machine.hpp.

◆ m_mutex_

std::recursive_mutex smacc2::ISmaccStateMachine::m_mutex_

private

Definition at line 205 of file smacc_state_machine.hpp.

Referenced by createOrthogonal(), createSignalConnection(), getGlobalSMData(), getMutex(), getOrthogonal(), lockStateMachine(), notifyOnRuntimeConfigurationFinished(), notifyOnStateEntryEnd(), notifyOnStateEntryStart(), smacc2::SignalDetector::pollOnce(), requiresComponent(), setGlobalSMData(), state_machine_visualization(), unlockStateMachine(), and updateStatusMessage().

◆ nh_

rclcpp::Node::SharedPtr smacc2::ISmaccStateMachine::nh_

protected

Definition at line 180 of file smacc_state_machine.hpp.

Referenced by disconnectSmaccSignalObject(), getLogger(), getNode(), getTransitionLogHistory(), initializeROS(), ISmaccStateMachine(), lockStateMachine(), onInitialized(), publishTransition(), state_machine_visualization(), unlockStateMachine(), updateStatusMessage(), and ~ISmaccStateMachine().

◆ orthogonals_

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

protected

Definition at line 197 of file smacc_state_machine.hpp.

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

◆ runMode_

smacc2::SMRunMode smacc2::ISmaccStateMachine::runMode_

private

Definition at line 218 of file smacc_state_machine.hpp.

Referenced by ISmaccStateMachine(), and updateStatusMessage().

◆ signalDetector_

SignalDetector* smacc2::ISmaccStateMachine::signalDetector_

private

Definition at line 221 of file smacc_state_machine.hpp.

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

◆ stateCallbackConnections

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

private

Definition at line 210 of file smacc_state_machine.hpp.

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

◆ stateMachineCurrentAction

StateMachineInternalAction smacc2::ISmaccStateMachine::stateMachineCurrentAction

private

Definition at line 208 of file smacc_state_machine.hpp.

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

◆ stateMachineInfo_

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

protected

Definition at line 202 of file smacc_state_machine.hpp.

Referenced by buildStateMachineInfo(), getStateMachineInfo(), smacc2::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl(), notifyOnStateEntryStart(), and state_machine_visualization().

◆ stateMachinePub_

rclcpp::Publisher<smacc2_msgs::msg::SmaccStateMachine>::SharedPtr smacc2::ISmaccStateMachine::stateMachinePub_

protected

Definition at line 183 of file smacc_state_machine.hpp.

Referenced by initializeROS(), and state_machine_visualization().

◆ stateMachineStatusPub_

rclcpp::Publisher<smacc2_msgs::msg::SmaccStatus>::SharedPtr smacc2::ISmaccStateMachine::stateMachineStatusPub_

protected

Definition at line 184 of file smacc_state_machine.hpp.

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

◆ stateSeqCounter_

int64_t smacc2::ISmaccStateMachine::stateSeqCounter_

private

Definition at line 223 of file smacc_state_machine.hpp.

Referenced by getCurrentStateCounter(), and notifyOnStateEntryStart().

◆ status_msg_

smacc2_msgs::msg::SmaccStatus smacc2::ISmaccStateMachine::status_msg_

protected

Definition at line 194 of file smacc_state_machine.hpp.

Referenced by state_machine_visualization(), and updateStatusMessage().

◆ timer_

rclcpp::TimerBase::SharedPtr smacc2::ISmaccStateMachine::timer_

protected

Definition at line 182 of file smacc_state_machine.hpp.

Referenced by onInitialized().

◆ transitionHistoryService_

rclcpp::Service<smacc2_msgs::srv::SmaccGetTransitionHistory>::SharedPtr smacc2::ISmaccStateMachine::transitionHistoryService_

protected

Definition at line 186 of file smacc_state_machine.hpp.

Referenced by initializeROS().

◆ transitionLogHistory_

std::vector<smacc2_msgs::msg::SmaccTransitionLogEntry> smacc2::ISmaccStateMachine::transitionLogHistory_

private

Definition at line 216 of file smacc_state_machine.hpp.

Referenced by getTransitionLogHistory(), and publishTransition().

◆ transitionLogPub_

rclcpp::Publisher<smacc2_msgs::msg::SmaccTransitionLogEntry>::SharedPtr smacc2::ISmaccStateMachine::transitionLogPub_

protected

Definition at line 185 of file smacc_state_machine.hpp.

Referenced by initializeROS(), and publishTransition().

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

smacc2/include/smacc2/smacc_state_machine.hpp
smacc2/include/smacc2/impl/smacc_state_machine_impl.hpp
smacc2/src/smacc2/smacc_state_machine.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ ISmaccStateMachine()

◆ ~ISmaccStateMachine()

Member Function Documentation

◆ buildStateMachineInfo()

◆ checkStateMachineConsistence()

◆ createOrthogonal()

◆ createSignalConnection()

◆ disconnectSmaccSignalObject()

◆ eStop()

◆ getClientBehavior()

◆ getCurrentState()

◆ getCurrentStateCounter()

◆ getCurrentStateInfo()

◆ getGlobalSMData()

◆ getLogger()

◆ getMutex()

◆ getNode()

◆ getOrthogonal()

◆ getOrthogonals()

◆ getStateMachineInfo()

◆ getStateMachineName()

◆ getTransitionLogHistory()

◆ initializeROS()

◆ lockStateMachine()

◆ mapBehavior()

◆ notifyOnRuntimeConfigurationFinished()

◆ notifyOnRuntimeConfigured()

◆ notifyOnStateEntryEnd()

◆ notifyOnStateEntryStart()

◆ notifyOnStateExited()

◆ notifyOnStateExitting()

◆ onInitialize()

◆ onInitialized()

◆ postEvent() [1/2]

◆ postEvent() [2/2]

◆ propagateEventToStateReactors()

◆ publishTransition()

◆ requiresComponent()

◆ reset()

◆ setGlobalSMData()

◆ state_machine_visualization()

◆ stop()

◆ unlockStateMachine()

◆ updateStatusMessage()

Friends And Related Symbol Documentation

◆ ISmaccState

◆ SignalDetector

Member Data Documentation

◆ currentState_

◆ currentStateInfo_

◆ eventQueueMutex_

◆ globalData_

◆ longLivedSignalConnections_

◆ m_mutex_

◆ nh_

◆ orthogonals_

◆ runMode_

◆ signalDetector_

◆ stateCallbackConnections

◆ stateMachineCurrentAction

◆ stateMachineInfo_

◆ stateMachinePub_

◆ stateMachineStatusPub_

◆ stateSeqCounter_

◆ status_msg_

◆ timer_

◆ transitionHistoryService_

◆ transitionLogHistory_

◆ transitionLogPub_