smacc2 Namespace Reference

Namespaces
namespace	client_bases
namespace	client_behaviors
namespace	client_core_components
namespace	default_events
namespace	default_transition_tags
namespace	event_generators
namespace	introspection
namespace	state_reactors
namespace	utils

Classes
struct	AddTEventTypeStateReactor
struct	AddTEventTypeStateReactorInfo
class	CallbackCounterSemaphore
class	CbServiceServerCallbackBase
class	ClientHandler
struct	ComponentKey
struct	EvCbFailure
struct	EvCbFinished
struct	EvCbSuccess
class	HasSpecificNamedOnExit
class	HasStandardOnExit
class	ISmaccClient
class	ISmaccClientBehavior
class	ISmaccComponent
class	ISmaccOrthogonal
class	ISmaccState
class	ISmaccStateMachine
class	ISmaccUpdatable
class	Orthogonal
class	SignalDetector
class	SmaccAsyncClientBehavior
class	SmaccClientBehavior
class	SmaccEventGenerator
class	SmaccSignal
class	SmaccState
struct	SmaccStateMachineBase
	State Machine. More...
class	SmExecution
class	StateReactor
class	Transition

Typedefs
template<class T >
using	deep_history = sc::deep_history<T>

Enumerations
enum class	SMRunMode { DEBUG , RELEASE }
enum class	ComponentRequirement { SOFT , HARD }
enum class	ExecutionModel { SINGLE_THREAD_SPINNER , MULTI_THREAD_SPINNER }
enum class	EventLifeTime { ABSOLUTE , CURRENT_STATE }
enum class	StateMachineInternalAction {   STATE_CONFIGURING , STATE_ENTERING , STATE_RUNNING , STATE_EXITING ,   TRANSITIONING }

Functions
template<typename TState , typename TTransitionTagName >
void	specificNamedOnExit (TState &st, TTransitionTagName tn, std::true_type)
template<typename TState , typename TTransitionTagName >
void	specificNamedOnExit (TState &, TTransitionTagName, std::false_type)
template<typename TState , typename TTransitionTagName >
void	specificNamedOnExit (TState &m, TTransitionTagName tn)
template<typename TState >
void	standardOnExit (TState &st, std::true_type)
template<typename TState >
void	standardOnExit (TState &, std::false_type)
template<typename TState >
void	standardOnExit (TState &m)
void	onSigQuit (int sig)
void	onSignalShutdown (int sig)
template<typename StateMachineType >
void	run (ExecutionModel executionModel=ExecutionModel::SINGLE_THREAD_SPINNER)
template<typename StateMachineType >
SmExecution &	run_async ()

Typedef Documentation

deep_history

template<class T >

using smacc2::deep_history = sc::deep_history<T>

Definition at line 54 of file common.hpp.

Enumeration Type Documentation

ComponentRequirement

enum class smacc2::ComponentRequirement

strong

Enumerator
SOFT
HARD

Definition at line 74 of file common.hpp.

{
  SOFT,
  HARD
};

EventLifeTime

enum class smacc2::EventLifeTime

strong

Enumerator
ABSOLUTE
CURRENT_STATE

Definition at line 46 of file smacc_state_machine.hpp.

{
  ABSOLUTE,
  CURRENT_STATE /*events are discarded if we are leaving the state it were created. I is used for client behaviors whose lifetime is associated to state*/
};

ExecutionModel

enum class smacc2::ExecutionModel

strong

Enumerator
SINGLE_THREAD_SPINNER
MULTI_THREAD_SPINNER

Definition at line 29 of file smacc_signal_detector.hpp.

{
  SINGLE_THREAD_SPINNER,
  MULTI_THREAD_SPINNER
};

SMRunMode

enum class smacc2::SMRunMode

strong

Enumerator
DEBUG
RELEASE

Definition at line 68 of file common.hpp.

{
  DEBUG,
  RELEASE
};

StateMachineInternalAction

enum class smacc2::StateMachineInternalAction

strong

Enumerator
STATE_CONFIGURING
STATE_ENTERING
STATE_RUNNING
STATE_EXITING
TRANSITIONING

Definition at line 52 of file smacc_state_machine.hpp.

{
  STATE_CONFIGURING,
  STATE_ENTERING,
  STATE_RUNNING,
  STATE_EXITING,
  TRANSITIONING
};

Function Documentation

onSignalShutdown()

void smacc2::onSignalShutdown

(

int

sig

)

Definition at line 404 of file signal_detector.cpp.

{
  // IMPORTANT: Signal handlers can only call async-signal-safe functions
  // We must NOT call complex C++ methods here (like terminateScheduler)
  // as they may use mutexes/condition variables which are not signal-safe
 
  // Stop the signal detector loop (atomic operation - signal-safe)
  SmExecution & smExecution = SmExecution::getInstance();
  if (smExecution.signalDetector)
  {
    smExecution.signalDetector->stop();
  }
 
  // Trigger ROS2 shutdown (this handles its own signal safety)
  rclcpp::shutdown();
 
  // Note: Scheduler termination will happen from main thread after polling loop exits
}

References smacc2::SmExecution::getInstance(), smacc2::SmExecution::signalDetector, and smacc2::SignalDetector::stop().

Referenced by run(), and run_async().

Here is the call graph for this function:

Here is the caller graph for this function:

onSigQuit()

void smacc2::onSigQuit

(

int

sig

)

Definition at line 423 of file signal_detector.cpp.

{
  RCLCPP_INFO(rclcpp::get_logger("SMACC"), "SignalDetector: SIGQUIT received.");
  exit(0);
}

Referenced by run(), and run_async().

Here is the caller graph for this function:

run()

template<typename StateMachineType >

void smacc2::run

(

ExecutionModel

executionModel = ExecutionModel::SINGLE_THREAD_SPINNER

)

Definition at line 144 of file smacc_signal_detector.hpp.

{
  // Register signal handlers for graceful shutdown
  ::signal(SIGINT, onSignalShutdown);
  ::signal(SIGTERM, onSignalShutdown);
  ::signal(SIGQUIT, onSigQuit);
 
  // Get singleton instance
  SmExecution & smExecution = SmExecution::getInstance();
 
  // create the asynchronous state machine scheduler
  SmaccFifoScheduler scheduler1(true);
 
  // create the signalDetector component
  SignalDetector signalDetector(&scheduler1, executionModel);
 
  // Store in singleton for signal handler access
  smExecution.signalDetector = &signalDetector;
  smExecution.scheduler1 = &scheduler1;
 
  // create the asynchronous state machine processor
  SmaccFifoScheduler::processor_handle sm =
    scheduler1.create_processor<StateMachineType>(&signalDetector);
 
  // initialize the asynchronous state machine processor
  signalDetector.setProcessorHandle(sm);
  smExecution.sm = sm;
 
  scheduler1.initiate_processor(sm);
 
  //create a thread for the asynchronous state machine processor execution
  boost::thread schedulerThread(boost::bind(&sc::fifo_scheduler<>::operator(), &scheduler1, 0));
  smExecution.schedulerThread = &schedulerThread;
 
  // use the  main thread for the signal detector component (waiting actionclient requests)
  signalDetector.pollingLoop();
 
  // After polling loop exits (due to shutdown), terminate the scheduler from main thread
  // This is safe to call here (not from signal handler) as we're in the main thread context
  RCLCPP_INFO(rclcpp::get_logger("SMACC"), "Polling loop exited. Terminating scheduler...");
  signalDetector.terminateScheduler();
 
  // Wait for scheduler thread to finish
  RCLCPP_INFO(rclcpp::get_logger("SMACC"), "Waiting for scheduler thread to join...");
  schedulerThread.join();
  RCLCPP_INFO(rclcpp::get_logger("SMACC"), "Scheduler thread terminated. Shutdown complete.");
 
  // Clear singleton references
  smExecution.signalDetector = nullptr;
  smExecution.scheduler1 = nullptr;
  smExecution.schedulerThread = nullptr;
}

References smacc2::SmExecution::getInstance(), onSignalShutdown(), onSigQuit(), smacc2::SignalDetector::pollingLoop(), smacc2::SmExecution::scheduler1, smacc2::SmExecution::schedulerThread, smacc2::SignalDetector::setProcessorHandle(), smacc2::SmExecution::signalDetector, smacc2::SmExecution::sm, and smacc2::SignalDetector::terminateScheduler().

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

Here is the call graph for this function:

Here is the caller graph for this function:

run_async()

template<typename StateMachineType >

SmExecution & smacc2::run_async

(

)

Definition at line 198 of file smacc_signal_detector.hpp.

{
  // Register signal handlers for graceful shutdown
  ::signal(SIGINT, onSignalShutdown);
  ::signal(SIGTERM, onSignalShutdown);
  ::signal(SIGQUIT, onSigQuit);
 
  // Get singleton instance
  SmExecution & smExecution = SmExecution::getInstance();
 
  // create the asynchronous state machine scheduler
  smExecution.scheduler1 = new SmaccFifoScheduler(true);
 
  // create the signalDetector component
  smExecution.signalDetector = new SignalDetector(smExecution.scheduler1);
 
  // create the asynchronous state machine processor
  smExecution.sm =
    smExecution.scheduler1->create_processor<StateMachineType>(smExecution.signalDetector);
 
  // initialize the asynchronous state machine processor
  smExecution.signalDetector->setProcessorHandle(smExecution.sm);
 
  smExecution.scheduler1->initiate_processor(smExecution.sm);
 
  //create a thread for the asynchronous state machine processor execution
  smExecution.schedulerThread =
    new boost::thread(boost::bind(&sc::fifo_scheduler<>::operator(), smExecution.scheduler1, NULL));
  smExecution.signalDetectorLoop =
    new boost::thread(boost::bind(&SignalDetector::pollingLoop, smExecution.signalDetector));
 
  return smExecution;
}

References smacc2::SmExecution::getInstance(), onSignalShutdown(), onSigQuit(), smacc2::SignalDetector::pollingLoop(), smacc2::SmExecution::scheduler1, smacc2::SmExecution::schedulerThread, smacc2::SignalDetector::setProcessorHandle(), smacc2::SmExecution::signalDetector, smacc2::SmExecution::signalDetectorLoop, and smacc2::SmExecution::sm.

Here is the call graph for this function:

specificNamedOnExit() [1/3]

template<typename TState , typename TTransitionTagName >

void smacc2::specificNamedOnExit	(	TState &	,
		TTransitionTagName	,
		std::false_type	)

Definition at line 50 of file state_traits.hpp.

{
}

specificNamedOnExit() [2/3]

template<typename TState , typename TTransitionTagName >

void smacc2::specificNamedOnExit	(	TState &	m,
		TTransitionTagName	tn )

Definition at line 55 of file state_traits.hpp.

{
  specificNamedOnExit(
    m, tn,
    std::integral_constant<bool, HasSpecificNamedOnExit<TState, TTransitionTagName>::value>());
}

References specificNamedOnExit().

Here is the call graph for this function:

specificNamedOnExit() [3/3]

template<typename TState , typename TTransitionTagName >

void smacc2::specificNamedOnExit	(	TState &	st,
		TTransitionTagName	tn,
		std::true_type	)

Definition at line 44 of file state_traits.hpp.

{
  st.onExit(tn);
}

Referenced by smacc2::Transition< Event, Destination, Tag, TransitionContext, pTransitionAction >::reactions< State >::react_with_action(), smacc2::Transition< Event, Destination, Tag, TransitionContext, pTransitionAction >::reactions< State >::react_without_action(), and specificNamedOnExit().

Here is the caller graph for this function:

standardOnExit() [1/3]

template<typename TState >

void smacc2::standardOnExit	(	TState &	,
		std::false_type	)

Definition at line 89 of file state_traits.hpp.

{
}

standardOnExit() [2/3]

template<typename TState >

void smacc2::standardOnExit

(

TState &

m

)

Definition at line 94 of file state_traits.hpp.

{
  standardOnExit(m, std::integral_constant<bool, HasStandardOnExit<TState>::value>());
}

References standardOnExit().

Here is the call graph for this function:

standardOnExit() [3/3]

template<typename TState >

void smacc2::standardOnExit	(	TState &	st,
		std::true_type	)

Definition at line 83 of file state_traits.hpp.

{
  st.onExit();
}

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

Here is the caller graph for this function: