subsystem_controllers::DriverManager Class Reference

The DriverManager serves as a component to manage CARMA required ROS1 Drivers. More...

#include <driver_manager.hpp>

Collaboration diagram for subsystem_controllers::DriverManager:

Public Member Functions
	DriverManager ()
	Default constructor for DriverManager with driver_timeout_ = 1000ms. More...
	DriverManager (const std::vector< std::string > &critical_driver_names, const std::vector< std::string > &camera_entries, const long driver_timeout)
	Constructor for DriverManager. More...
void	update_driver_status (const carma_driver_msgs::msg::DriverStatus::SharedPtr msg, long current_time)
	Update driver status. More...
std::string	are_critical_drivers_operational (long current_time)
	Check if all critical drivers are operational. More...
void	evaluate_sensor (int &sensor_input, bool available, long current_time, long timestamp, long driver_timeout)
	Evaluate if the sensor is available. More...
carma_msgs::msg::SystemAlert	handle_spin (long time_now, long start_up_timestamp, long startup_duration)
	Handle the spin and publisher. More...

Protected Member Functions
	FRIEND_TEST (DriverManagerTest, testCarTruckHandleSpinFatalUnknown)

Protected Attributes
std::vector< std::string >	critical_drivers_
std::vector< std::string >	camera_entries_
std::shared_ptr< EntryManager >	em_
	Entry manager to keep track of detected plugins. More...
long	driver_timeout_ = 1000
bool	starting_up_ = true

Detailed Description

The DriverManager serves as a component to manage CARMA required ROS1 Drivers.

Definition at line 44 of file driver_manager.hpp.

Constructor & Destructor Documentation

DriverManager() [1/2]

subsystem_controllers::DriverManager::DriverManager

(

)

Default constructor for DriverManager with driver_timeout_ = 1000ms.

Definition at line 29 of file driver_manager.cpp.

{}

DriverManager() [2/2]

subsystem_controllers::DriverManager::DriverManager	(	const std::vector< std::string > &	critical_driver_names,
		const std::vector< std::string > &	camera_entries,
		const long	driver_timeout
	)

Constructor for DriverManager.

Parameters

critical_driver_names	The set of drivers which will be treated as required. A failure in these plugins will result in an exception
camera_entries	The set of camera drivers.
driver_timeout	The timeout threshold for essential drivers

Definition at line 31 of file driver_manager.cpp.

            : critical_drivers_(critical_driver_names.begin(), critical_driver_names.end()),
            camera_entries_(camera_entries.begin(), camera_entries.end()),
            driver_timeout_(driver_timeout)
    {
        // Intialize entry manager
        em_ = std::make_shared<EntryManager>(critical_driver_names, camera_entries);
 
    }

References em_.

Member Function Documentation

are_critical_drivers_operational()

std::string subsystem_controllers::DriverManager::are_critical_drivers_operational

(

long

current_time

)

Check if all critical drivers are operational.

Definition at line 108 of file driver_manager.cpp.

    {
        int ssc=0;
        int camera=0;
 
        std::vector<Entry> driver_list = em_->get_entries(); //Real time driver list from driver status
        for(auto i = driver_list.begin(); i < driver_list.end(); ++i)
        {
            RCLCPP_DEBUG_STREAM(rclcpp::get_logger("subsystem_controller"), "i->name_: " << i->name_
                << ", current_time: " << current_time
                << ", i->timestamp_: " << i->timestamp_
                << ", difference: " << current_time-(i->timestamp_) );
            if(em_->is_entry_required(i->name_))
            {
                evaluate_sensor(ssc,i->available_,current_time,i->timestamp_,driver_timeout_);
            }
            else if(em_->is_camera_entry_required(i->name_)==0)
            {
                evaluate_sensor(camera,i->available_,current_time,i->timestamp_,driver_timeout_);
            }
        }
 
        // Manual disable of ssc entry in case ssc wrapper is in ros2
        if (critical_drivers_.empty())
        {
            ssc = 1;
        }
 
        //Decision making
        if (ssc == 1 && camera == 1)
        {
            return "s_1_c_1";
        }
        else if (ssc == 1 && camera == 0)
        {
            return "s_1_c_0";
        }
        else{
            return "s_0";
        }
 
 
    }

References critical_drivers_, driver_timeout_, em_, evaluate_sensor(), and process_bag::i.

Referenced by handle_spin().

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_sensor()

void subsystem_controllers::DriverManager::evaluate_sensor	(	int &	sensor_input,
		bool	available,
		long	current_time,
		long	timestamp,
		long	driver_timeout
	)

Evaluate if the sensor is available.

Definition at line 94 of file driver_manager.cpp.

    {
 
        if((!available) || (current_time-timestamp > driver_timeout))
        {
            sensor_input=0;
        }
        else
        {
            sensor_input=1;
        }
 
    }

Referenced by are_critical_drivers_operational().

Here is the caller graph for this function:

FRIEND_TEST()

subsystem_controllers::DriverManager::FRIEND_TEST ( DriverManagerTest  , testCarTruckHandleSpinFatalUnknown    )

protected

handle_spin()

carma_msgs::msg::SystemAlert subsystem_controllers::DriverManager::handle_spin	(	long	time_now,
		long	start_up_timestamp,
		long	startup_duration
	)

Handle the spin and publisher.

Definition at line 44 of file driver_manager.cpp.

    {
        carma_msgs::msg::SystemAlert alert;
 
        std::string status = are_critical_drivers_operational(time_now);
        if(status.compare("s_1_c_1") == 0)
        {
            starting_up_ = false;
            alert.description = "All essential drivers are ready";
            alert.type = carma_msgs::msg::SystemAlert::DRIVERS_READY;
            return alert;
        }
        else if(starting_up_ && (time_now - start_up_timestamp <= startup_duration))
        {
            alert.description = "System is starting up...";
            alert.type = carma_msgs::msg::SystemAlert::NOT_READY;
            return alert;
        }
        else if(status.compare("s_1_c_0")==0)
        {
            alert.description = "Camera Failed";
            alert.type = carma_msgs::msg::SystemAlert::SHUTDOWN;
            return alert;
        }
        else if(status.compare("s_0") == 0)
        {
            alert.description = "SSC Failed";
            alert.type = carma_msgs::msg::SystemAlert::SHUTDOWN;
            return alert;
        }
        else
        {
            alert.description = "Unknown problem assessing essential driver availability";
            alert.type = carma_msgs::msg::SystemAlert::FATAL;
            return alert;
        }
 
    }

References are_critical_drivers_operational(), arbitrator::SHUTDOWN, and starting_up_.

Here is the call graph for this function:

update_driver_status()

void subsystem_controllers::DriverManager::update_driver_status	(	const carma_driver_msgs::msg::DriverStatus::SharedPtr	msg,
		long	current_time
	)

Update driver status.

Definition at line 84 of file driver_manager.cpp.

    {
        // update driver status is only called in response to a message received on driver_discovery. This topic is only being published in ros1
        Entry driver_status(msg->status == carma_driver_msgs::msg::DriverStatus::OPERATIONAL || msg->status == carma_driver_msgs::msg::DriverStatus::DEGRADED,
                            msg->name,current_time);
 
        em_->update_entry(driver_status);
    }

References em_.

Member Data Documentation

camera_entries_

std::vector<std::string> subsystem_controllers::DriverManager::camera_entries_

protected

Definition at line 91 of file driver_manager.hpp.

critical_drivers_

std::vector<std::string> subsystem_controllers::DriverManager::critical_drivers_

protected

Definition at line 88 of file driver_manager.hpp.

Referenced by are_critical_drivers_operational().

driver_timeout_

long subsystem_controllers::DriverManager::driver_timeout_ = 1000

protected

Definition at line 97 of file driver_manager.hpp.

Referenced by are_critical_drivers_operational().

em_

std::shared_ptr<EntryManager> subsystem_controllers::DriverManager::em_

protected

Entry manager to keep track of detected plugins.

Definition at line 94 of file driver_manager.hpp.

Referenced by DriverManager(), are_critical_drivers_operational(), and update_driver_status().

starting_up_

bool subsystem_controllers::DriverManager::starting_up_ = true

protected

Definition at line 99 of file driver_manager.hpp.

Referenced by handle_spin().

---

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

• subsystem_controllers/include/subsystem_controllers/drivers_controller/driver_manager.hpp
• subsystem_controllers/src/drivers_controller/driver_manager.cpp