arbitrator Namespace Reference

Classes
class	Arbitrator
class	ArbitratorNode
class	ArbitratorStateMachine
struct	ArbitratorStateTransition
class	BeamSearchStrategy
	Implementation of SearchStrategy by usage of Beam Search. More...
class	CapabilitiesInterface
	Generic interface for interacting with Plugins via their capabilities instead of directly by their topics. More...
struct	Config
	Config struct. More...
class	CostFunction
	Generic interface representing a means of computing cost for plans in the search graph. More...
class	CostSystemCostFunction
	Implementation of the CostFunction interface. More...
class	FixedPriorityCostFunction
	Implementation of the CostFunction interface. More...
class	NeighborGenerator
class	PlanningStrategy
	Generic interface representing a strategy for arriving at a maneuver plan. More...
class	PluginNeighborGenerator
	Implementation of the NeighborGenerator interface using plugins. More...
class	SearchStrategy
	Generic interface representing a computation to prioritize nodes for expansion in a search graph. More...
class	TreePlanner
	Implementation of PlanningStrategy using a generic tree search algorithm. More...
struct	VehicleState
	Struct defining the vehicle state required for maneuver planning. More...

Enumerations
enum	ArbitratorState {   INITIAL = 0 , PLANNING , WAITING , PAUSED ,   SHUTDOWN }
enum	ArbitratorEvent {   SYSTEM_STARTUP_COMPLETE = 0 , PLANNING_COMPLETE , PLANNING_TIMER_TRIGGER , ARBITRATOR_PAUSED ,   ARBITRATOR_RESUMED , SYSTEM_SHUTDOWN_INITIATED }

Functions
std::string	guidance_state_to_string (uint8_t state)
	Convert guidance state enum to string representation. More...
std::ostream &	operator<< (std::ostream &output, const std::map< std::string, double > &map)
std::string	maneuver_type_to_string (uint8_t type)
	Convert maneuver type enum to string representation. More...
def	generate_launch_description ()

Enumeration Type Documentation

ArbitratorEvent

enum arbitrator::ArbitratorEvent

Possible events for the Arbitrator to respond to: SYSTEM_STARTUP_COMPLETE - The rest of the system is ready for the arbitrator to being planning PLANNING_COMPLETE - The Arbitrator itself has completed a maneuver plan PLANNING_TIMER_TRIGGER - The time has come for another plan to be generated ARBITRATOR_PAUSED - The Arbitrator has been paused externally ARBITRATOR_RESUMED - The Arbitrator has been resumed externally

Enumerator
SYSTEM_STARTUP_COMPLETE
PLANNING_COMPLETE
PLANNING_TIMER_TRIGGER
ARBITRATOR_PAUSED
ARBITRATOR_RESUMED
SYSTEM_SHUTDOWN_INITIATED

Definition at line 47 of file arbitrator_state_machine.hpp.

                         {
        SYSTEM_STARTUP_COMPLETE = 0,
        PLANNING_COMPLETE,
        PLANNING_TIMER_TRIGGER,
        ARBITRATOR_PAUSED,
        ARBITRATOR_RESUMED,
        SYSTEM_SHUTDOWN_INITIATED
    };

ArbitratorState

enum arbitrator::ArbitratorState

Possible states for the Arbitrator to be in: INITIAL- Startup state while the rest of the system is initalizing PLANNING - Actiively generating a maneuver plan WAITING - After the completion of a plan, waiting for a timer trigger to replan PAUSED - Similar to waiting, but will ignore a timer trigger. Must be resumed externally.

Enumerator
INITIAL
PLANNING
WAITING
PAUSED
SHUTDOWN

Definition at line 31 of file arbitrator_state_machine.hpp.

                         {
        INITIAL = 0,
        PLANNING,
        WAITING,
        PAUSED,
        SHUTDOWN
    };

Function Documentation

generate_launch_description()

def arbitrator.generate_launch_description

(

)

Definition at line 31 of file arbitrator.launch.py.

def generate_launch_description():
 
    # Declare the log_level launch argument
    log_level = LaunchConfiguration('log_level')
    declare_log_level_arg = DeclareLaunchArgument(
        name ='log_level', default_value='DEBUG')
    
    # Get parameter file path
    param_file_path = os.path.join(
        get_package_share_directory('arbitrator'), 'config/arbitrator_params.yaml')
 
        
    # Launch node(s) in a carma container to allow logging to be configured
    container = ComposableNodeContainer(
        package='carma_ros2_utils',
        name='arbitrator_container',
        namespace=GetCurrentNamespace(),
        executable='carma_component_container_mt',
        composable_node_descriptions=[
            
            # Launch the core node(s)
            ComposableNode(
                    package='arbitrator',
                    plugin='arbitrator::ArbitratorNode',
                    name='arbitrator_node',
                    extra_arguments=[
                        {'use_intra_process_comms': True},
                        {'--log-level' : log_level }
                    ],
                    parameters=[ param_file_path ]
            ),
        ]
    )
 
    return LaunchDescription([
        declare_log_level_arg,
        container
    ])

guidance_state_to_string()

std::string arbitrator::guidance_state_to_string ( uint8_t  state )

inline

Convert guidance state enum to string representation.

Parameters

state

The guidance state enum value

Returns

String representation of the guidance state

Definition at line 45 of file arbitrator.hpp.

                                                             {
        switch(state) {
            case carma_planning_msgs::msg::GuidanceState::STARTUP:
                return "STARTUP";
            case carma_planning_msgs::msg::GuidanceState::DRIVERS_READY:
                return "DRIVERS_READY";
            case carma_planning_msgs::msg::GuidanceState::ACTIVE:
                return "ACTIVE";
            case carma_planning_msgs::msg::GuidanceState::ENGAGED:
                return "ENGAGED";
            case carma_planning_msgs::msg::GuidanceState::INACTIVE:
                return "INACTIVE";
            case carma_planning_msgs::msg::GuidanceState::SHUTDOWN:
                return "SHUTDOWN";
            default:
                return "UNKNOWN";
        }
    }

References lightbar_manager::ACTIVE, lightbar_manager::ENGAGED, port_drayage_plugin::INACTIVE, and SHUTDOWN.

maneuver_type_to_string()

std::string arbitrator::maneuver_type_to_string ( uint8_t  type )

inline

Convert maneuver type enum to string representation.

Parameters

type	The maneuver type enum value

Returns

String representation of the maneuver type

Definition at line 39 of file tree_planner.hpp.

                                                           {
        switch(type) {
            case carma_planning_msgs::msg::Maneuver::LANE_FOLLOWING:
                return "LANE_FOLLOWING";
            case carma_planning_msgs::msg::Maneuver::LANE_CHANGE:
                return "LANE_CHANGE";
            case carma_planning_msgs::msg::Maneuver::INTERSECTION_TRANSIT_STRAIGHT:
                return "INTERSECTION_TRANSIT_STRAIGHT";
            case carma_planning_msgs::msg::Maneuver::INTERSECTION_TRANSIT_LEFT_TURN:
                return "INTERSECTION_TRANSIT_LEFT_TURN";
            case carma_planning_msgs::msg::Maneuver::INTERSECTION_TRANSIT_RIGHT_TURN:
                return "INTERSECTION_TRANSIT_RIGHT_TURN";
            case carma_planning_msgs::msg::Maneuver::STOP_AND_WAIT:
                return "STOP_AND_WAIT";
            default:
                return "UNKNOWN";
        }
    }

References create_two_lane_map::type.

Referenced by arbitrator::TreePlanner::generate_plan().

Here is the caller graph for this function:

operator<<()

std::ostream & arbitrator::operator<<	(	std::ostream &	output,
		const std::map< std::string, double > &	map
	)

Definition at line 31 of file arbitrator_config.hpp.

    {
        output << "Map { " << std::endl;
        for (auto const& pair : map)
        {
            output << pair.first << ": " << pair.second << std::endl;
        }
        output << "}";
        return output;
    }