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, 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, ComponentRequirement requirementType)
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)
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 >
smacc2::SmaccSignalConnection	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::Publisher< smacc2_msgs::msg::SmaccEvent >::SharedPtr	eventsLogPub_
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::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 63 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 756 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_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

checkStateMachineConsistence()

void smacc2::ISmaccStateMachine::checkStateMachineConsistence ( )

protected

Definition at line 234 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 85 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 smacc2::introspection::demangledTypeName(), getLogger(), m_mutex_, and orthogonals_.

Here is the call graph for this function:

createSignalConnection()

template<typename TSmaccSignal , typename TMemberFunctionPrototype , typename TSmaccObjectType >

smacc2::SmaccSignalConnection smacc2::ISmaccStateMachine::createSignalConnection	(	TSmaccSignal &	signal,
		TMemberFunctionPrototype	callback,
		TSmaccObjectType *	object )

Definition at line 422 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;
  smacc2::SmaccSignalConnection 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 unknown lifetime "
      "behavior. An exception may occur if the object is destroyed during the execution.");
 
    connection = binder.bindaux(signal, callback, object, nullptr);
  }
 
  return connection;
}

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

Referenced by smacc2::ISmaccClient::connectSignal(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onAborted(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onAborted(), smacc2::client_core_components::CpActionClient< ActionType >::onAborted(), cl_gcalcli::CpCalendarPoller::onAgendaUpdated(), cl_isaac_apriltag::CpAprilTagTracker::onAprilTagDetected(), cl_gcalcli::CpGcalcliConnection::onAuthenticationRequired(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onCancelled(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onCancelled(), smacc2::client_core_components::CpActionClient< ActionType >::onCancelled(), smacc2::client_core_components::CpSubprocessExecutor::onCommandCompleted(), smacc2::client_core_components::CpSubprocessExecutor::onCommandFailed(), cl_modbus_tcp_relay::CpModbusConnection::onConnectionError(), cl_gcalcli::CpGcalcliConnection::onConnectionLost(), cl_modbus_tcp_relay::CpModbusConnection::onConnectionLost(), cl_gcalcli::CpGcalcliConnection::onConnectionRestored(), cl_modbus_tcp_relay::CpModbusConnection::onConnectionRestored(), cl_px4_mr::CbArmPX4::onEntry(), cl_px4_mr::CbChangeAltitude::onEntry(), cl_px4_mr::CbDisarmPX4::onEntry(), cl_px4_mr::CbFollowWaypoints::onEntry(), cl_px4_mr::CbGoToLocation::onEntry(), cl_px4_mr::CbLand::onEntry(), cl_px4_mr::CbReturnToHome::onEntry(), cl_px4_mr::CbTakeOff::onEntry(), cl_gcalcli::CpCalendarEventListener::onEventDetected(), cl_gcalcli::CpCalendarEventListener::onEventEnded(), cl_gcalcli::CpCalendarEventListener::onEventStarted(), smacc2::client_core_components::CpServiceClient< ServiceType >::onFailure(), smacc2::SmaccAsyncClientBehavior::onFailure(), smacc2::client_core_components::CpActionClient< ActionType >::onFeedback(), smacc2::SmaccAsyncClientBehavior::onFinished(), smacc2::client_bases::SmaccSubscriberClient< MessageType >::onFirstMessageReceived(), smacc2::client_core_components::CpTopicSubscriber< MessageType >::onFirstMessageReceived(), cl_keyboard::components::CpKeyboardListener1::OnKeyPress(), smacc2::client_bases::SmaccSubscriberClient< MessageType >::onMessageReceived(), smacc2::client_core_components::CpTopicSubscriber< MessageType >::onMessageReceived(), cl_generic_sensor::components::CpMessageTimeout< MessageType >::onMessageTimeout(), cl_moveit2z::ClMoveit2z::onMotionExecutionFailed(), cl_moveit2z::ClMoveit2z::onMotionExecutionSuccedded(), cl_nav2z::components::CpNav2ActionInterface::onNavigationAborted(), cl_nav2z::components::CpNav2ActionInterface::onNavigationCancelled(), cl_nav2z::components::CpNav2ActionInterface::onNavigationFeedback(), cl_nav2z::components::CpNav2ActionInterface::onNavigationSucceeded(), cl_modbus_tcp_relay::CpModbusRelay::onReadComplete(), smacc2::client_core_components::CpServiceClient< ServiceType >::onRequestSent(), smacc2::client_core_components::CpServiceClient< ServiceType >::onResponse(), smacc2::client_bases::SmaccServiceServerClient< TService >::onServiceRequestReceived(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onSucceeded(), smacc2::client_bases::SmaccActionClientBase< ActionType >::onSucceeded(), smacc2::client_core_components::CpActionClient< ActionType >::onSucceeded(), smacc2::SmaccAsyncClientBehavior::onSuccess(), cl_ros2_timer::CbTimerCountdownLoop::onTimerTick(), cl_ros2_timer::CbTimerCountdownOnce::onTimerTick(), smacc2::client_core_components::CpRos2Timer::onTimerTick(), cl_modbus_tcp_relay::CpModbusRelay::onWriteFailure(), cl_modbus_tcp_relay::CpModbusRelay::onWriteSuccess(), and cl_http::CbHttpRequestBase::runtimeConfigure().

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(), "[SmaccSignal] 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(), "[SmaccSignal] 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 100 of file smacc_state_machine.cpp.

{}

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 84 of file smacc_state_machine.hpp.

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

References getClientBehavior(), and getOrthogonal().

Referenced by smacc2::ISmaccState::getClientBehavior(), and getClientBehavior().

Here is the call graph for this function:

Here is the caller graph for this function:

getCurrentState()

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

inline

Definition at line 766 of file smacc_state_machine_impl.hpp.

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

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 764 of file smacc_state_machine_impl.hpp.

{ return this->stateSeqCounter_; }

References stateSeqCounter_.

getCurrentStateInfo()

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

inline

Definition at line 117 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 235 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 smacc2::ISmaccState::getGlobalSMData().

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 164 of file smacc_state_machine.hpp.

{ return nh_->get_logger(); }

References nh_.

Referenced by createOrthogonal(), createSignalConnection(), getGlobalSMData(), getOrthogonal(), smacc2::SmaccStateMachineBase< DerivedStateMachine, InitialStateType >::initiate_impl(), 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 166 of file smacc_state_machine.hpp.

{ return this->m_mutex_; }

References m_mutex_.

getNode()

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

(

)

Definition at line 94 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(), 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 47 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 smacc2::introspection::demangledTypeName(), getLogger(), m_mutex_, and orthogonals_.

Referenced by getClientBehavior(), and 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 103 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 768 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 229 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 190 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 164 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));
 
  eventsLogPub_ = nh_->create_publisher<smacc2_msgs::msg::SmaccEvent>(
    shortname + "/smacc/event_log", rclcpp::QoS(100));
 
  // 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));
 
  // Notify signal detector that ROS initialization is complete
  // This allows the polling loop to start safely accessing ROS objects
  signalDetector_->notifyRosInitialized();
}

References eventsLogPub_, getTransitionLogHistory(), nh_, smacc2::SignalDetector::notifyRosInitialized(), signalDetector_, 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 217 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:

notifyOnRuntimeConfigurationFinished()

template<typename StateType >

void smacc2::ISmaccStateMachine::notifyOnRuntimeConfigurationFinished

(

StateType *

state

)

Definition at line 578 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().

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 597 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 510 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(), "Orthogonal 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().

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 494 of file smacc_state_machine_impl.hpp.

{
  std::lock_guard<std::recursive_mutex> lock(m_mutex_);
 
  RCLCPP_DEBUG(
    getLogger(),
    "[State Machine] Initializing 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_.

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 665 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(), "Event generator 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().

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

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

Definition at line 155 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 157 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 226 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 smacc2::introspection::demangleSymbol(), 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 172 of file smacc_state_machine_impl.hpp.

{
  std::lock_guard<std::recursive_mutex> guard(eventQueueMutex_);
 
#define eventtypename demangleSymbol<EventType>().c_str()
 
  TRACETOOLS_TRACEPOINT(smacc2_event, eventtypename);
 
  {
    auto evinfo = SmaccEventInfo(TypeInfo::getTypeInfoFromType<EventType>());
    EventLabel<EventType>(evinfo.label);
 
    smacc2_msgs::msg::SmaccEvent event;
    event.event_type = evinfo.getEventTypeName();
    event.event_source = evinfo.getEventSourceName();
    event.event_object_tag = evinfo.getOrthogonalName();
    event.label = evinfo.label;
 
    if (this->eventsLogPub_)
    {
      this->eventsLogPub_->publish(event);
    }
  }
 
  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);
  if (!currentState_.empty())
  {
    propagateEventToStateReactors(currentState_.back(), ev);
  }
 
  this->signalDetector_->postEvent(ev);
}

References smacc2::CURRENT_STATE, currentState_, smacc2::introspection::EventLabel(), eventQueueMutex_, eventsLogPub_, eventtypename, getLogger(), smacc2::introspection::TypeInfo::getTypeInfoFromType(), smacc2::SignalDetector::postEvent(), propagateEventToStateReactors(), signalDetector_, smacc2_event, smacc2::STATE_EXITING, stateMachineCurrentAction, and smacc2::TRANSITIONING.

Referenced by smacc2::ISmaccClient::postEvent(), smacc2::ISmaccClient::postEvent(), smacc2::ISmaccClientBehavior::postEvent(), smacc2::ISmaccComponent::postEvent(), smacc2::ISmaccComponent::postEvent(), smacc2::ISmaccState::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 738 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::introspection::demangleSymbol(), 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 145 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,
		ComponentRequirement	requirementType )

Definition at line 119 of file smacc_state_machine_impl.hpp.

{
  bool throwsException = requirementType == ComponentRequirement::HARD;
  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(), smacc2::HARD, m_mutex_, and orthogonals_.

Referenced by 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 >.

Definition at line 96 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 270 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 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 201 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 98 of file smacc_state_machine.cpp.

{}

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 223 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 108 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 192 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 194 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().

eventsLogPub_

rclcpp::Publisher<smacc2_msgs::msg::SmaccEvent>::SharedPtr smacc2::ISmaccStateMachine::eventsLogPub_

protected

Definition at line 186 of file smacc_state_machine.hpp.

Referenced by initializeROS(), and 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().

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 179 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 199 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 initializeROS(), 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 182 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 183 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 196 of file smacc_state_machine.hpp.

Referenced by state_machine_visualization(), and updateStatusMessage().

timer_

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

protected

Definition at line 181 of file smacc_state_machine.hpp.

Referenced by onInitialized().

transitionHistoryService_

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

protected

Definition at line 188 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 184 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