/ - Diff - Colony Scout - Robotics Club

+     *
      * @author Colony Project, CMU Robotics Club
      * @author Priyanka Deo
      * @author Alex Zirbel
      **/
     #include "ros/ros.h"
-...
     static int button2_pressed; /**< Whether or not button 2 is pressed. */
     /**
      * @brief Handles button events
+     *
      * Handles button events based on subscription to the button_event topic.
+     *
      * @param msg The message from the button_event topic, containing buttons
      * statuses.
      */
     void event_button(const buttons::button_event::ConstPtr& msg)
+    {
         //TODO: What goes here?
+    }
     /**
      * @brief Outputs whether or not the buttons are pressed.
+     *
      * Serves the service query_buttons by responding to service requests
      * with the status of the buttons
      * @param req The request. The only field is the units requested.
      * @param res The response. The fields will be filled with values.
      */
     bool buttons_query(buttons::query_buttons::Request &req,
                       buttons::query_buttons::Response &res)
+    {
         int units = req.units;
         res.button1_pressed = button1_pressed;
         res.button2_pressed = button2_pressed;
         ROS_DEBUG("Button status queried");
         return true;
+    }
     /**
      * @brief Buttons driver. This is a ROS node that queries button status.
+     *
      * This is the main function for the buttons node. It is run
-...
+     *
      * @param argc The number of command line arguments (should be 1)
      * @param argv The array of command line arguments
      **/
      */
     int main(int argc, char **argv)
+    {
         /* Initialize in ROS the buttons driver node */
-...
         /* Advertise that this serves the query_buttons service */
         ros::NodeHandle n;
         ros::ServiceServer service = n.advertiseService("query_buttons",
                                                         buttons_query);
         /* Subscribe to the button_event topic */
         ros::Subscriber sub0 = n.subscribe("button_event", 4, event_button);
         ros::Publisher pub = n.advertise<buttons::button_event>("button_event",
                                                                 QUEUE_SIZE);
         /* Initialize hardware for buttons */
         // Hardware init functions here
         // Publish a button event now and then
         ROS_INFO("Ready to query buttons.");
         ROS_INFO("Ready to handle buttons. [unimplemented]");
         ros::spin();
         return 0;

+     *
      * @author Colony Project, CMU Robotics Club
      * @author Priyanka Deo
      **/
      * @author Alex Zirbel
      */
     #ifndef _BUTTONS_H_
     #define _BUTTONS_H_
     #include "buttons/query_buttons.h"
     #include "buttons/button_event.h"
     #define QUEUE_SIZE 10
     #define BUTTON_PRESSED 0x1
     /** @brief Initialize the buttons module and driver. **/
     int main(int argc, char **argv);
     /** @brief Responds to topic to notify of button events. **/
     void event_button(const buttons::button_event::ConstPtr& msg);
     /** @brief Responds to service to query buttons. **/
     bool buttons_query(buttons::query_buttons::Request &req,
                       buttons::query_buttons::Response &res);
     #endif

scout/buttons/srv/query_buttons.srv
1		int8 units
2		---
3		bool button1_pressed
4		bool button2_pressed

scout/libscout/CMakeLists.txt
29	29	#rosbuild_add_executable(example examples/example.cpp)
30	30	#target_link_libraries(example ${PROJECT_NAME})
31	31
32		rosbuild_add_executable(priya_behavior src/priya_behavior_process.cpp src/PriyaBehavior.cpp src/Behavior.cpp src/MotorControl.cpp src/HeadlightControl.cpp src/ButtonControl.cpp)
	32	rosbuild_add_executable(priya_behavior src/priya_behavior_process.cpp src/PriyaBehavior.cpp src/Behavior.cpp src/MotorControl.cpp src/SonarControl.cpp src/HeadlightControl.cpp src/ButtonControl.cpp)

      * @author Colony Project, CMU Robotics Club
      * @author Priyanka Deo
      * @author Leon Zhang
      * @author Alex Zirbel
      **/
     #include "ButtonControl.h"
     /*!
     using namespace std;
     /**
      * @brief Initialize the buttons module of libscout.
+     *
      * Initialize the libscout node as a subscriber of button_event
      */
     ButtonControl::ButtonControl(const ros::NodeHandle& libscout_node) : node(libscout_node)
     ButtonControl::ButtonControl(const ros::NodeHandle& libscout_node,
                                  string scoutname)
         : node(libscout_node)
+    {
         button_event_sub = node.subscribe("button_event", QUEUE_SIZE, event_button);
         button_event_sub = node.subscribe(scoutname + "/button_event",
                                           QUEUE_SIZE,
                                           &ButtonControl::event_callback,
                                           this);
+    }
     /*!*
     /**
      * @brief Respond to button events
      * Sends out button events if buttons are pressed.
      * Processes message and updates private variables
+     *
      * @param subscription to button_event message
      */
     void ButtonControl::event_button(const buttons::button_event::ConstPtr& msg)
     void ButtonControl::event_callback(const buttons::button_event::ConstPtr& msg)
+    {
         button1_pressed = msg.button1_pressed;
         button2_pressed = msg.button2_pressed;
         button1_value = msg->button1_pressed;
         button2_value = msg->button2_pressed;
+    }
     /**
     *@brief check if button 1 is currently being pressed
+    *
     *@return true if button is pressed, otherwise false
     */
      * @brief check if button 1 is currently being pressed
+     *
      * @return true if button is pressed, otherwise false
      */
     bool ButtonControl::button1_is_pressed()
+    {
         return button1_value;
+    }
     /**
     *@brief check if button 2 is currently being pressed
+    *
     *@return true if button is pressed, otherwise false
     */
      * @brief check if button 2 is currently being pressed
+     *
      * @return true if button is pressed, otherwise false
      */
     bool ButtonControl::button2_is_pressed()
+    {
         return button2_value;

      * @author Priyanka Deo
      * @author Leon Zhang
      **/
     #include "buttons/button_event.h"
     #include "constants.h"
-...
     class ButtonControl
+    {
         public:
             /** set up buttons node and prepare to communicate over ROS**/
             ButtonControl(const ros::NodeHandle& libscout_node);
             void event_button(const buttons::button_event::ConstPtr& msg);
             /** Set up buttons node and prepare to communicate over ROS */
             ButtonControl(const ros::NodeHandle& libscout_node,
                           std::string scoutname);
             void event_callback(const buttons::button_event::ConstPtr& msg);
             bool button1_is_pressed();
             bool button2_is_pressed();
-...
             bool button1_value;
             bool button2_value;
             /* ROS node created in libscout.cpp */
             ros::NodeHandle node;
             /** ROS subscriber declaration */
             ros::Subscriber button_event_sub;
+    }
     };
     #endif

     #include "SonarControl.h"
     #define MAX_ATTEMPTS 10
     using namespace std;
     /**
-...
                                string scoutname)
         : node(libscout_node)
+    {
         sonar_set_scan_pub =
             node.advertise<sonar::sonar_set_scan>(scoutname + "/set_sonar_scan",
                                                   QUEUE_SIZE);
         sonar_toggle_pub =
             node.advertise<sonar::sonar_toggle>(scoutname + "/toggle_sonar",
                                                 QUEUE_SIZE);
         sonar_distance_sub = node.subscribe(scoutname + "sonar_distance",
                                             QUEUE_SIZE, distance_callback);
         sonar_set_scan_client =
             node.serviceClient<sonar::sonar_set_scan>(scoutname+"/set_sonar_scan");
         sonar_toggle_client =
             node.serviceClient<sonar::sonar_toggle>(scoutname + "/toggle_sonar");
         sonar_distance_sub = node.subscribe(scoutname + "/sonar_distance",
                                             QUEUE_SIZE,
                                             &SonarControl::distance_callback,
                                             this);
         // Initialize all the sonar readings to 0 and timestamps to undefined
         for (int i = 0; i < 48; i++)
-...
             readings[i] = 0;
             timestamps[i] = ros::Time::now(); // A common shortcut for no reading
+        }
         /// @todo Test, and replace 10 with a const int
         num_attempts = MAX_ATTEMPTS;
+    }
     /**
-...
      * @brief Sets the sonar to a position.
+     *
      * @param position Value between 0-180 of degree position to set sonar
      * @return NONE
      * @todo should return bool. See below.
      */
     void SonarControl::set_single(int position)
+    {
-...
+     *
      * @param start_pos The leftmost (smallest) value that the sonar can take
      * @param end_pos The rightmost (largest) value that the sonar can take
      * @return NONE
      * @todo Also misimplemented, should return bool. Look at srv def in sonar/
      */
     void SonarControl::set_range(int start_pos, int end_pos)
+    {
-...
             end_pos = temp;
+        }
         // Turn sonar on
         sonar::sonar_toggle on_msg;
         on_msg.set_on = true;
         sonar_toggle_pub.publish(on_msg);
         // Make sure sonar is on
         set_on();
         // Set scan range
         sonar::sonar_set_scan msg;
         msg.stop_l = start_pos;
         msg.stop_r = end_pos;
         sonar::sonar_set_scan srv;
         srv.request.stop_l = start_pos;
         srv.request.stop_r = end_pos;
         // Check if the service call failed or if the response was false
         if (!sonar_set_scan_client.call(srv) || srv.response.ack == false)
+        {
             if (--num_attempts == 0)
+            {
                 ROS_ERROR("SonarControl::set_range() failed permanently.");
+            }
         sonar_set_scan_pub.publish(msg);
         ros::spinOnce();  ///<! Sure? Does this belong here?
             ROS_WARN("SonarControl::set_range() failed once.");
+        }
+    }
     /**
      * @brief Turn on sonar readings
+     *
      * (Re)starts sonar panning and taking readings.
      */
     void SonarControl::set_on()
+    {
         set_power(true);
+    }
     /**
      * @brief Turn off sonar readings
+     *
      * Stops sonar from panning and taking readings.
      * @todo Misimplemented. Needs to use a service call and return the ack as bool
      */
     void SonarControl::set_off()
+    {
         set_power(false);
+    }
     /**
      * @brief Turn sonar readings either off or on.
+     *
      * Attempts to turn the readings off or on, num_attempts times.
+     *
      * @return NONE
      * @param is_on True if power should be set on, false if should be off.
      */
     float SonarControl::set_off()
     void SonarControl::set_power(bool is_on)
+    {
         sonar::sonar_toggle on_msg;
         on_msg.set_on = false;
         sonar_toggle_pub.publish(on_msg);
         sonar::sonar_toggle srv;
         srv.request.set_on = is_on;
         // Check if the service call failed or if the response was false
         if (!sonar_toggle_client.call(srv) || srv.response.ack == false)
+        {
             if (--num_attempts == 0)
+            {
                 ROS_ERROR("SonarControl::set_power() failed permanently.");
+            }
             ROS_WARN("SonarControl::set_power() failed once.");
+        }
         // Reset num_attempts
         num_attempts = MAX_ATTEMPTS;
+    }
     /**

     #include <ros/ros.h>
     #include <sonar/sonar_set_scan.h>
     #include <sonar/sonar_toggle.h>
     #include <sonar/sonar_direction.h>
     #include <sonar/sonar_distance.h>
     #include "constants.h"
     class SonarControl
+    {
-...
             SonarControl(const ros::NodeHandle& libscout_node,
                          std::string scoutname);
             /** Sets sonar to a position (0-180 deg) specified by input */
             /** Sets sonar to a position (0-23) specified by input */
             void set_single(int position);
             /** Sets sonar to scan a range in 0-180 specified by input */
             /** Sets sonar to scan a range in 0-23 specified by input */
             void set_range(int start_pos, int end_pos);
             /** (Re)starts sonar panning and taking readings */
             void set_on();
             /** Stops sonar from panning and taking readings */
             void set_off();
         private:
             /** Record the new sonar distance measurement */
             void distance_callback(const sonar::sonar_distance::ConstPtr& msg);
             /** Sends a sonar_toggle message. */
             void set_power(bool is_on);
             /** Converts between values output by sensor and physical distances */
             //float sonar_to_dist(float sonar_value);
             //float dist_to_sonar(float distance);
             /** If a service call fails, tries again this many times. */
             int num_attempts;
             /** Keep track of the latest readings and their time of receipt.
              *  Readings are in millimeters. */
             int readings[48];
             ros::Time timestamps[48];
             /* ROS publisher and client declaration */
             ros::Publisher sonar_set_scan_pub;
             ros::Publisher sonar_toggle_pub;
             ros::ServiceClient sonar_set_scan_client;
             ros::ServiceClient sonar_toggle_client;
             ros::Subscriber sonar_distance_sub;
             ros::NodeHandle node;

+     *
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
      **/
      */
     #include <ros/ros.h>
     #include "PriyaBehavior.h"
-...
+    {
         string scoutname = "";
         // Running with no arguments only supports one scout. Check in case
         // the user meant to specify a scout in the arguments.
         if (argc != 2)
+        {
             cout << "You have started this behavior in hardware mode." << endl
-...
             scoutname = argv[1];
+        }
         ros::init(argc, argv, "libscout");
         /// @todo Will using argc and argv cause problems? (I don't think so but..)
         ros::init(argc, argv, "priya_behavior");
         PriyaBehavior *behavior = new PriyaBehavior(scoutname);
         behavior->run();

      **/
     void sonar_init(void)
+    {
         ROS_INFO("Sonar_init called [unimplemented].");
         sonar_stepper_pos = 0;
+    }
-...
     bool handle_sonar_toggle(sonar::sonar_toggle::Request  &req,
                              sonar::sonar_toggle::Response &res)
+    {
         if (req.set_on)
         if (req.set_on && !is_on)
+        {
             ROS_INFO("Turning on the sonar [unimplemented]");
         else
+        }
         else if (req.set_off && is_on)
+        {
             ROS_INFO("Turning off the sonar [unimplemented]");
+        }
         res.ack = true;

     #ifndef _SONAR_H_
     #define _SONAR_H_
     /** @brief Initialize the sonar in the library module **/
     /** Initialize the sonar module and drivers **/
     void sonar_init(void);
     /** @brief Initialize the sonar module and drivers **/
     void sonar_module_init(void);
     /** Responds to sonar on/off requests. */
     bool handle_sonar_toggle(sonar::sonar_toggle::Request  &req,
                              sonar::sonar_toggle::Response &res)
     /** @brief Read raw sonar data from the sonar module. Takes stepper
      * position and sensor to read **/
     int sonar_read_raw(int direction, int sensor);
     /** @brief Wrapper for reading sonar data (angle in degrees and distance in
      * cm) **/
     int sonar_read(int direction);
     /** @brief Subscribe function to sonar topic **/
     void sonar_subscribe(int *function());
     /** Responds to requests which set the scan range. */
     bool handle_sonar_set_scan(sonar::sonar_set_scan::Request  &req,
                                sonar::sonar_set_scan::Response &res)
     #endif

ID	b00761a0e88f934a309a939b653d9f441b127ae8
Parent	c492be62
Child	4069a378

Project

General

Profile

Colony » Colony Scout

Revision b00761a0