smacc2::ISmaccStateMachine Class Reference

#include <smacc_state_machine.hpp>

Inheritance diagram for smacc2::ISmaccStateMachine:

Collaboration diagram for smacc2::ISmaccStateMachine:

Public Member Functions
	ISmaccStateMachine (std::string stateMachineName, 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< smacc2::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)
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 More...
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)
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)
void	disposeStateAndDisconnectSignals ()
template<typename StateType >
void	notifyOnRuntimeConfigurationFinished (StateType *state)
unsigned long	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_
ISmaccState *	currentState_
std::shared_ptr< SmaccStateInfo >	currentStateInfo_
smacc2_msgs::msg::SmaccStatus	status_msg_
std::map< std::string, std::shared_ptr< smacc2::ISmaccOrthogonal > >	orthogonals_
std::shared_ptr< SmaccStateMachineInfo >	stateMachineInfo_

Private Member Functions
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::list< boost::signals2::connection >	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_
unsigned long	stateSeqCounter_

Friends
class	ISmaccState
class	SignalDetector

Detailed Description

Definition at line 63 of file smacc_state_machine.hpp.

Constructor & Destructor Documentation

ISmaccStateMachine()

smacc2::ISmaccStateMachine::ISmaccStateMachine	(	std::string	stateMachineName,
		SignalDetector *	signalDetector
	)

Definition at line 35 of file smacc_state_machine.cpp.

: currentState_(nullptr), stateSeqCounter_(0)
{
  rclcpp::NodeOptions node_options;
  // 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, node_options);  //
  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 75 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 598 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 229 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> lock(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 355 of file smacc_state_machine_impl.hpp.

{
  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 = binder.bindaux(signal, callback, object);
 
  // 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)
  {
  }
  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());
    stateCallbackConnections.push_back(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.");
  }
 
  return connection;
}

References smacc2::utils::Bind< arity >::bindaux(), callback(), getLogger(), and stateCallbackConnections.

Referenced by smacc2::ISmaccClient::connectSignal(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onAborted(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onCancelled(), smacc2::SmaccAsyncClientBehavior::onFailure(), smacc2::SmaccAsyncClientBehavior::onFinished(), smacc2::components::CpTopicSubscriber< MessageType >::onFirstMessageReceived(), smacc2::client_bases::SmaccSubscriberClient< MessageType >::onFirstMessageReceived(), cl_keyboard::ClKeyboard::OnKeyPress(), smacc2::components::CpTopicSubscriber< MessageType >::onMessageReceived(), smacc2::client_bases::SmaccSubscriberClient< MessageType >::onMessageReceived(), cl_multirole_sensor::ClMultiroleSensor< MessageType >::onMessageTimeout(), cl_move_group_interface::ClMoveGroup::onMotionExecutionFailed(), cl_move_group_interface::ClMoveGroup::onMotionExecutionSuccedded(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onSucceeded(), smacc2::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:

disposeStateAndDisconnectSignals()

void smacc2::ISmaccStateMachine::disposeStateAndDisconnectSignals

(

)

Definition at line 213 of file smacc_state_machine.cpp.

{
  for (auto & conn : this->stateCallbackConnections)
  {
    RCLCPP_WARN_STREAM(
      getLogger(),
      "[StateMachine] Disconnecting scoped-lifetime SmaccSignal "
      "subscription");
    conn.disconnect();
  }
 
  this->stateCallbackConnections.clear();
 
  currentState_ = nullptr;
}

References currentState_, getLogger(), and stateCallbackConnections.

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

Here is the call graph for this function:

Here is the caller graph for this function:

eStop()

void smacc2::ISmaccStateMachine::eStop ( )

virtual

Reimplemented in smacc2::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >, smacc2::SmaccStateMachineBase< $SmName$, State1 >, smacc2::SmaccStateMachineBase< SmAdvancedRecovery1, MsRun >, smacc2::SmaccStateMachineBase< SmAtomic, State1 >, smacc2::SmaccStateMachineBase< SmAtomic24Hr, State1 >, smacc2::SmaccStateMachineBase< SmAtomicPerformanceTrace1, State1 >, smacc2::SmaccStateMachineBase< SmAtomicSubscribersPerformanceTest, State1 >, smacc2::SmaccStateMachineBase< SmAutowareAvp, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmAwsWarehouseNavigation, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmBranching, State1 >, smacc2::SmaccStateMachineBase< SmCoretestTransitionSpeed1, State1 >, smacc2::SmaccStateMachineBase< SmDanceBot, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotStrikesBack, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWarehouse, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWareHouse2, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWareHouse3, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmFerrari, MsRun >, smacc2::SmaccStateMachineBase< SmHuskyBarrelSearch1, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmMultiStage1, MsMode1 >, smacc2::SmaccStateMachineBase< SmPubsub1, MsRun >, smacc2::SmaccStateMachineBase< SmRespira1, MsRun >, smacc2::SmaccStateMachineBase< SmTestMoveitUr5Sim, StAcquireSensors >, and smacc2::SmaccStateMachineBase< SmThreeSome, MsRun >.

Definition at line 86 of file smacc_state_machine.cpp.

{}

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

Here is the caller graph for this function:

getCurrentState()

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

inline

Definition at line 608 of file smacc_state_machine_impl.hpp.

{ return this->currentState_; }

References currentState_.

Referenced by smacc2::SignalDetector::pollOnce(), and cl_nav2z::WaypointNavigator::sendNextGoal().

Here is the caller graph for this function:

getCurrentStateCounter()

uint64_t smacc2::ISmaccStateMachine::getCurrentStateCounter ( ) const

inline

Definition at line 606 of file smacc_state_machine_impl.hpp.

{ return this->stateSeqCounter_; }

References stateSeqCounter_.

Referenced by smacc2::SignalDetector::pollOnce().

Here is the caller graph for this function:

getCurrentStateInfo()

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

inline

Definition at line 105 of file smacc_state_machine.hpp.

{ return currentStateInfo_; }

References currentStateInfo_.

getGlobalSMData()

template<typename T >

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

Definition at line 222 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(), smacc2::ISmaccState::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 155 of file smacc_state_machine.hpp.

{ return nh_->get_logger(); }

References nh_.

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

Here is the caller graph for this function:

getMutex()

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

inline

Definition at line 157 of file smacc_state_machine.hpp.

{ return this->m_mutex_; }

References m_mutex_.

getNode()

rclcpp::Node::SharedPtr smacc2::ISmaccStateMachine::getNode

(

)

Definition at line 80 of file smacc_state_machine.cpp.

{ return this->nh_; }

References nh_.

Referenced by buildStateMachineInfo(), smacc2::ISmaccClient::getNode(), smacc2::ISmaccClientBehavior::getNode(), smacc2::ISmaccOrthogonal::getNode(), smacc2::SignalDetector::getNode(), smacc2::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl(), $sm_name$::$SmName$::onInitialize(), smacc2::SignalDetector::pollOnce(), and smacc2::SmaccState< MostDerived, Context, InnerInitial, historyMode >::SmaccState().

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_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

getOrthogonals()

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

(

)

const

Definition at line 89 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::ISmaccState::requiresClient().

Here is the caller graph for this function:

getStateMachineInfo()

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

inline

Definition at line 610 of file smacc_state_machine_impl.hpp.

{
  return *this->stateMachineInfo_;
}

References stateMachineInfo_.

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

Here is the caller graph for this function:

getStateMachineName()

std::string smacc2::ISmaccStateMachine::getStateMachineName

(

)

Definition at line 208 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 169 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 150 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", 1);
  stateMachineStatusPub_ =
    nh_->create_publisher<smacc2_msgs::msg::SmaccStatus>(shortname + "/smacc/status", 1);
  transitionLogPub_ = nh_->create_publisher<smacc2_msgs::msg::SmaccTransitionLogEntry>(
    shortname + "/smacc/transition_log", 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:

mapBehavior()

template<typename StateField , typename BehaviorType >

void smacc2::ISmaccStateMachine::mapBehavior

Definition at line 277 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 482 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();
  }
 
  this->updateStatusMessage();
 
  stateMachineCurrentAction = StateMachineInternalAction::STATE_ENTERING;
}

References orthogonals_, smacc2::STATE_ENTERING, stateMachineCurrentAction, and updateStatusMessage().

Referenced by smacc2::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 smacc2::ISmaccStateMachine::notifyOnRuntimeConfigured

(

StateType *

state

)

Definition at line 497 of file smacc_state_machine_impl.hpp.

{
  stateMachineCurrentAction = StateMachineInternalAction::STATE_CONFIGURING;
}

References smacc2::STATE_CONFIGURING, and stateMachineCurrentAction.

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

Here is the caller graph for this function:

notifyOnStateEntryEnd()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnStateEntryEnd

(

StateType *

state

)

Definition at line 418 of file smacc_state_machine_impl.hpp.

{
  RCLCPP_INFO(
    getLogger(), "[%s] State OnEntry code finished",
    demangleSymbol(typeid(StateType).name()).c_str());
 
  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 : this->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 : this->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());
    }
  }
 
  this->updateStatusMessage();
  stateMachineCurrentAction = StateMachineInternalAction::STATE_STEADY;
}

References currentState_, smacc2::introspection::demangleSymbol(), smacc2::ISmaccState::getEventGenerators(), getLogger(), smacc2::ISmaccState::getStateReactors(), orthogonals_, smacc2::STATE_STEADY, stateMachineCurrentAction, and updateStatusMessage().

Referenced by smacc2::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 smacc2::ISmaccStateMachine::notifyOnStateEntryStart

(

StateType *

state

)

Definition at line 402 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_ = state;
  currentStateInfo_ = stateMachineInfo_->getState<StateType>();
}

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

Referenced by smacc2::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 smacc2::ISmaccStateMachine::notifyOnStateExited

(

StateType *

state

)

Definition at line 568 of file smacc_state_machine_impl.hpp.

{
  auto fullname = demangleSymbol(typeid(StateType).name());
 
  // then call exit state
  RCLCPP_WARN_STREAM(getLogger(), "state exit: " << fullname);
 
  stateMachineCurrentAction = StateMachineInternalAction::TRANSITIONING;
  //this->unlockStateMachine("state exit");
}

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

Referenced by smacc2::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 smacc2::ISmaccStateMachine::notifyOnStateExitting

(

StateType *

state

)

Definition at line 503 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());
    }
  }
 
  //this->lockStateMachine("state exit");
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

onInitialize()

void smacc2::ISmaccStateMachine::onInitialize ( )

virtual

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

Reimplemented in $sm_name$::$SmName$, sm_atomic_performance_trace_1::SmAtomicPerformanceTrace1, sm_atomic_subscribers_performance_test::SmAtomicSubscribersPerformanceTest, sm_coretest_transition_speed_1::SmCoretestTransitionSpeed1, $sm_name$::$SmName$, sm_advanced_recovery_1::SmAdvancedRecovery1, sm_atomic::SmAtomic, sm_atomic_24hr::SmAtomic24Hr, sm_autoware_avp::SmAutowareAvp, sm_aws_warehouse_navigation::SmAwsWarehouseNavigation, sm_branching::SmBranching, sm_dance_bot::SmDanceBot, sm_dance_bot_strikes_back::SmDanceBotStrikesBack, sm_dance_bot_warehouse::SmDanceBotWarehouse, sm_dance_bot_warehouse_2::SmDanceBotWareHouse2, sm_dance_bot_warehouse_3::SmDanceBotWareHouse3, sm_ferrari::SmFerrari, sm_husky_barrel_search_1::SmHuskyBarrelSearch1, sm_multi_stage_1::SmMultiStage1, sm_pubsub_1::SmPubsub1, sm_respira_1::SmRespira1, sm_test_moveit_ur5_sim::SmTestMoveitUr5Sim, and sm_three_some::SmThreeSome.

Definition at line 141 of file smacc_state_machine.cpp.

{}

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 143 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_, service_node_3::s, 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 213 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 174 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);
  auto currentstate = currentState_;
  if (currentstate != nullptr)
  {
    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::ISmaccClientBehavior::postEvent(), smacc2::ISmaccState::postEvent(), postEvent(), and smacc2::StateReactor::setOutputEvent().

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 580 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 smacc2::ISmaccState::getClassName(), getLogger(), smacc2::ISmaccState::getParentState(), smacc2::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 smacc2::ISmaccStateMachine::publishTransition

(

const SmaccTransitionInfo &

transitionInfo

)

Definition at line 131 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(), and smacc2::ISmaccState::notifyTransitionFromTransitionTypeInfo().

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

)

Definition at line 126 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());
 
  // 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::ISmaccClientBehavior::requiresComponent(), smacc2::ISmaccOrthogonal::requiresComponent(), and smacc2::ISmaccState::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 >, smacc2::SmaccStateMachineBase< $SmName$, State1 >, smacc2::SmaccStateMachineBase< SmAdvancedRecovery1, MsRun >, smacc2::SmaccStateMachineBase< SmAtomic, State1 >, smacc2::SmaccStateMachineBase< SmAtomic24Hr, State1 >, smacc2::SmaccStateMachineBase< SmAtomicPerformanceTrace1, State1 >, smacc2::SmaccStateMachineBase< SmAtomicSubscribersPerformanceTest, State1 >, smacc2::SmaccStateMachineBase< SmAutowareAvp, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmAwsWarehouseNavigation, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmBranching, State1 >, smacc2::SmaccStateMachineBase< SmCoretestTransitionSpeed1, State1 >, smacc2::SmaccStateMachineBase< SmDanceBot, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotStrikesBack, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWarehouse, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWareHouse2, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWareHouse3, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmFerrari, MsRun >, smacc2::SmaccStateMachineBase< SmHuskyBarrelSearch1, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmMultiStage1, MsMode1 >, smacc2::SmaccStateMachineBase< SmPubsub1, MsRun >, smacc2::SmaccStateMachineBase< SmRespira1, MsRun >, smacc2::SmaccStateMachineBase< SmTestMoveitUr5Sim, StAcquireSensors >, and smacc2::SmaccStateMachineBase< SmThreeSome, MsRun >.

Definition at line 82 of file smacc_state_machine.cpp.

{}

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 257 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 cl_nav2z::CbNavigateGlobalPosition::execute(), mapBehavior(), $sm_name$::$SmName$::onInitialize(), sm_dance_bot::SmDanceBot::onInitialize(), sm_dance_bot_strikes_back::SmDanceBotStrikesBack::onInitialize(), sm_dance_bot_warehouse::SmDanceBotWarehouse::onInitialize(), sm_dance_bot_warehouse_2::SmDanceBotWareHouse2::onInitialize(), sm_dance_bot_warehouse_3::SmDanceBotWareHouse3::onInitialize(), smacc2::ISmaccOrthogonal::setGlobalSMData(), and smacc2::ISmaccState::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 180 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 >, smacc2::SmaccStateMachineBase< $SmName$, State1 >, smacc2::SmaccStateMachineBase< SmAdvancedRecovery1, MsRun >, smacc2::SmaccStateMachineBase< SmAtomic, State1 >, smacc2::SmaccStateMachineBase< SmAtomic24Hr, State1 >, smacc2::SmaccStateMachineBase< SmAtomicPerformanceTrace1, State1 >, smacc2::SmaccStateMachineBase< SmAtomicSubscribersPerformanceTest, State1 >, smacc2::SmaccStateMachineBase< SmAutowareAvp, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmAwsWarehouseNavigation, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmBranching, State1 >, smacc2::SmaccStateMachineBase< SmCoretestTransitionSpeed1, State1 >, smacc2::SmaccStateMachineBase< SmDanceBot, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotStrikesBack, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWarehouse, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWareHouse2, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmDanceBotWareHouse3, MsDanceBotRunMode >, smacc2::SmaccStateMachineBase< SmFerrari, MsRun >, smacc2::SmaccStateMachineBase< SmHuskyBarrelSearch1, StAcquireSensors >, smacc2::SmaccStateMachineBase< SmMultiStage1, MsMode1 >, smacc2::SmaccStateMachineBase< SmPubsub1, MsRun >, smacc2::SmaccStateMachineBase< SmRespira1, MsRun >, smacc2::SmaccStateMachineBase< SmTestMoveitUr5Sim, StAcquireSensors >, and smacc2::SmaccStateMachineBase< SmThreeSome, MsRun >.

Definition at line 84 of file smacc_state_machine.cpp.

{}

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

Here is the caller graph for this function:

updateStatusMessage()

void smacc2::ISmaccStateMachine::updateStatusMessage ( )

private

Definition at line 94 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 Function Documentation

ISmaccState

friend class ISmaccState

friend

Definition at line 222 of file smacc_state_machine.hpp.

SignalDetector

friend class SignalDetector

friend

Definition at line 223 of file smacc_state_machine.hpp.

Member Data Documentation

currentState_

ISmaccState* smacc2::ISmaccStateMachine::currentState_

protected

Definition at line 180 of file smacc_state_machine.hpp.

Referenced by disposeStateAndDisconnectSignals(), getCurrentState(), notifyOnStateEntryEnd(), notifyOnStateEntryStart(), and postEvent().

currentStateInfo_

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

protected

Definition at line 182 of file smacc_state_machine.hpp.

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

eventQueueMutex_

std::recursive_mutex smacc2::ISmaccStateMachine::eventQueueMutex_

private

Definition at line 194 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 201 of file smacc_state_machine.hpp.

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

m_mutex_

std::recursive_mutex smacc2::ISmaccStateMachine::m_mutex_

private

Definition at line 193 of file smacc_state_machine.hpp.

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

nh_

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

protected

Definition at line 170 of file smacc_state_machine.hpp.

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

orthogonals_

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

protected

Definition at line 187 of file smacc_state_machine.hpp.

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

runMode_

smacc2::SMRunMode smacc2::ISmaccStateMachine::runMode_

private

Definition at line 206 of file smacc_state_machine.hpp.

Referenced by ISmaccStateMachine(), and updateStatusMessage().

signalDetector_

SignalDetector* smacc2::ISmaccStateMachine::signalDetector_

private

Definition at line 209 of file smacc_state_machine.hpp.

Referenced by ISmaccStateMachine(), and postEvent().

stateCallbackConnections

std::list<boost::signals2::connection> smacc2::ISmaccStateMachine::stateCallbackConnections

private

Definition at line 198 of file smacc_state_machine.hpp.

Referenced by createSignalConnection(), and disposeStateAndDisconnectSignals().

stateMachineCurrentAction

StateMachineInternalAction smacc2::ISmaccStateMachine::stateMachineCurrentAction

private

Definition at line 196 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 190 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 173 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 174 of file smacc_state_machine.hpp.

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

stateSeqCounter_

unsigned long smacc2::ISmaccStateMachine::stateSeqCounter_

private

Definition at line 211 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 184 of file smacc_state_machine.hpp.

Referenced by state_machine_visualization(), and updateStatusMessage().

timer_

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

protected

Definition at line 172 of file smacc_state_machine.hpp.

Referenced by onInitialized().

transitionHistoryService_

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

protected

Definition at line 176 of file smacc_state_machine.hpp.

Referenced by initializeROS().

transitionLogHistory_

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

private

Definition at line 204 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 175 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