drive.H

Go to the documentation of this file.

// Copyright (C) 2006 University of Louisiana at Lafayette
// Authors: Suresh Golconda

#ifndef CAJUN_DRIVE_H
#define CAJUN_DRIVE_H

#include "linear_interpolator.H"
#include "speed_planner.H"
#include "guide_mode.H"
#include "steering_pid.H"
#include "safe_speed_advisor.H"
#include "throttle.H"
#include "world_state.H"
#include "base_steering.H"
#include "throttle.H"
#include "conf.H"
#include "integral.H"

namespace cajun
{
        class drive_t
        {
        public:
                drive_t (base_path_interpolator_t *path_interpolator,
                         speed_planner_t *speed_planner,
                         guide_mode_t *guide_mode,
                         base_steering_t *steering_controller,
                         safe_speed_advisor_t *safe_speed_advisor,
                         base_throttle_t *throttle_controller,
                         world_state_t *world_state,
                         const conf_t &steering_conf,
                         const conf_t &cajun_conf);
                ~drive_t () {};
        private:
                base_path_interpolator_t *m_path_interpolator;
                speed_planner_t  *m_speed_planner;
                guide_mode_t *m_guide_mode;
                base_steering_t *m_steering_controller;
                safe_speed_advisor_t *m_safe_speed_advisor;
                base_throttle_t *m_throttle_controller;
                world_state_t *m_world_state;

                nav_data_t m_nav;
                heading_data_t m_heading;
                sog_data_t m_sog;
                drive_data_t m_drive;
                steering_data_t m_steering;
                signal_line_data_t m_signal_line;
                path_data_t m_input_path;

                std::vector<waypoint_t> m_path;
                bool m_input_path_forward;
                steering_data_t::gear_t m_pres_gear;
                steering_data_t::gear_t m_req_gear;
                double m_gear_req_tstamp; // tstamp when last gear requested
                double m_gear_change_time; // time to change gear
                bool m_gear_change_stop; // stop for changing gear

                bool m_nav_staled;
                bool m_heading_staled;
                bool m_sog_staled;
                bool m_drive_staled;
                bool m_signal_line_staled;
                bool m_path_staled;

                // Bot should stop and quit after stopping
                bool m_bot_should_die;
                // Bot should stop and wait for env to change to drive
                bool m_bot_should_stop;
                // Bot reached zero speed
                bool m_bot_stopped;
                bool m_software_pause;
                // Received external hardware pause
                bool m_hardware_pause;
                // No more path infront of bot to drive to
                bool m_covered_input_path;
                // When input path is empty
                bool m_empty_input_path;
                // When prev and next path points are zero, stop bot
                bool m_zero_speed_path;

                double m_min_wheel_angle;
                double m_max_wheel_angle;

                double m_max_stop_speed;
                double m_pause_brake;
                double m_prev_tstamp;
                double m_unpause_delay_left;
                double m_unpause_delay;
                double m_path_data_timeout;
                double m_data_timeout;
                int m_steering_position_feedback;
                double m_min_dis_to_reach_wp;

                bool read_steering_conf (const conf_t &steering_conf);
                bool read_cajun_conf (const conf_t &cajun_conf);

                void update_data (double tstamp);
                void compute_azimuths ();
                void update_signal_line (double tstamp);
                bool check_staled_data (double tstamp);
                void update_stale_status (double tstamp, double data_tstamp,
                                          double timeout,
                                          bool &data_staled, const char *data_name);

                void update_delayed_hardware_pause (double tstamp,
                                                    bool h_pause);
                void update_software_pause (double tstamp, int goal_index);
                void update_bot_should_die (double tstamp,
                                            bool received_interrupt);
                void update_bot_should_stop (double tstamp, int goal_index);
                void update_zero_speed (double tstamp, int goal_index);
                void update_gear_action (double tstamp);

                void update_action_status (double tstamp, bool bot_should_die,
                                           int goal_index);
                double steering_position (double tstamp);
                double map_steering_angle_to_command (double st_angle);
                void convert_to_output_format (double tstamp,
                                               path_data_t &output_path);
                void update_flag (double tstamp, bool &present_status,
                                  bool new_status, const char *mesg,
                                  const char *mesg_okay, const char *mesg_not_okay);
                void change_gear (double tstamp_);

        public:
                void drive_the_bot (double tstamp, bool bot_should_die);
                void publish_pause_values (double tstamp, double pause_brake,
                                           steering_data_t::gear_t gear_);
                bool shutdown ();
        };
};


#endif

---