/ - Diff - Colony Scout - Robotics Club

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file analog.cpp

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file analog.h

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file bom.cpp

     /**
      * Copyright (c) 2007 Colony Project
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
-...
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file bom.h
      * @brief Contains bom declarations and functions.

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file buttons.cpp

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file buttons.h

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file cliffsensor.cpp

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file cliffsensor.h

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**

     /**
      *Copyright (c) 2011 Colony Project
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
-...
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file encoders.h

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file headlights.cpp

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file headlights.h

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)
	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)

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file Behavior.cpp
      * @brief Contains basic functions for the structure of all behaviours.
      * @brief Contains basic functions for the structure of all behaviors.
+     *
      * Contains function implementations needed for all behavior.
+     *
-...
     using namespace std;
     /**
      * Constructs a behavior and sets up all control classes.
+     *
      * This constructor is used by all behaviors which inherit the Behavior
      * class, so that it is easy to create a behavior with access to ROS
      * functionality through the control classes.
+     *
      * @param scoutname If nonempty, specifies which scout in the simulator
      *                  will be controlled by this behavior.
      */
     Behavior::Behavior(string scoutname)
+    {
         motors = new MotorControl(node, scoutname);
         buttons = new ButtonControl(node, scoutname);
         sonar = new SonarControl(node, scoutname);
         loop_rate = new ros::Rate(10);
         //buttons(node);
         //sonar(node);
+    }
     /**
      * Allows the behavior to check ros::ok(), without being aware of ROS.
      */
     bool Behavior::ok()
+    {
         return ros::ok();
+    }
     /**
      * Allows the behavior to call ros::spin(), without being aware of ROS.
      */
     void Behavior::spin()
+    {
         ros::spin();
         return;
+    }
     /**
      * Allows the behavior to call ros::spinOnce(), without being aware of ROS.
      */
     void Behavior::spinOnce()
+    {
         ros::spinOnce();

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file Behavior.h
-...
     #include "MotorControl.h"
     #include "HeadlightControl.h"
     #include "ButtonControl.h"
     #include "SonarControl.h"
     #include "constants.h"
-...
             // Initializes ROS for behavior
             Behavior(std::string scoutname);
             // User implemented behavior
             /// Extended by subclasses to actually run the behavior.
             virtual void run() = 0;
         protected:
             ros::NodeHandle node;
             /// @todo Should this really be a pointer, or the object itself somehow?
             ros::Rate *loop_rate;
             // Declare all used library controls
             MotorControl * motors;
             //ButtonControl buttons;
             //SonarControl sonar;
             ButtonControl * buttons;
             SonarControl * sonar;
             // Wrappers for ROS functions
             bool ok();

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file MotorControl.cpp

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file MotorControl.h

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file PriyaBehavior.h
-...
     class PriyaBehavior : Behavior
+    {
         public:
             /// @todo Is this the best way to inherit the Behavior constructor?
             PriyaBehavior(std::string scoutname) : Behavior(scoutname) {};
             PriyaBehavior(std::string scoutname) : Behavior(scoutname) {}
             /**
              * @brief Runs the behavior.
              */
             /** Actually executes the behavior. */
             void run();
     };

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file SonarControl.cpp
      * @brief Contains sonar function imeplementations
      * @brief Contains sonar function implementation
+     *
      * Contains functions for the use of sonar control.
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Priyanka Deo
      * @author Alex Zirbel
      **/
     #include "SonarControl.h"
     using namespace std;
     /**
      * @brief Initialize the sonar module of libscout.
+     *
      * Initialize the libscout node as a publisher of sonar_set_scan and
      * sonar_toggle and a client of query_sonar.
      */
     SonarControl::SonarControl(const ros::NodeHandle& libscout_node)
     SonarControl::SonarControl(const ros::NodeHandle& libscout_node,
                                string scoutname)
         : node(libscout_node)
+    {
         sonar_set_scan_pub =
             node.advertise<sonar::sonar_set_scan>("set_sonar_scan", QUEUE_SIZE);
             node.advertise<sonar::sonar_set_scan>(scoutname + "/set_sonar_scan",
                                                   QUEUE_SIZE);
         sonar_toggle_pub =
     	node.advertise<sonar::sonar_toggle>("toggle_sonar", QUEUE_SIZE);
         query_sonar =
             node.serviceClient<sonar::sonar_direction>("query_sonar");
             node.advertise<sonar::sonar_toggle>(scoutname + "/toggle_sonar",
                                                 QUEUE_SIZE);
         sonar_distance_sub = node.subscribe(scoutname + "sonar_distance",
                                             QUEUE_SIZE, distance_callback);
         // 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
+        }
+    }
     /**
      * Update the array of sonar values, and the last read timestamps,
      * to reflect the new reading received.
      */
     void SonarControl::distance_callback(const sonar::sonar_distance::ConstPtr& msg)
+    {
         // Error checking so that the array doesn't cause a segfault
         if (msg->pos < 0 || msg-> pos > 23)
+        {
             ROS_ERROR("SonarControl received an invalid sonar position.");
             return;
+        }
         readings[msg->pos] = msg->distance0;
         readings[msg->pos + 24] = msg->distance1;
         timestamps[msg->pos] = msg->header.stamp;
         timestamps[msg->pos + 24] = msg->header.stamp;
+    }
     /**
-...
+     *
      * @param position Value between 0-180 of degree position to set sonar
      * @return NONE
      * @todo should return bool. See below.
      */
     void SonarControl::set(int position)
     void SonarControl::set_single(int position)
+    {
         set_range(position, 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)
+    {
         /** Turn sonar on */
         // Check that the range is valid
         if (start_pos < 0 || end_pos < 0 || start_pos > 23 || end_pos > 23)
+        {
             ROS_ERROR("Commanded SonarControl::set_range to a bad value.");
             return;
+        }
         // Sort the start and end positions into increasing order
         if (start_pos > end_pos)
+        {
             int temp = start_pos;
             start_pos = end_pos;
             end_pos = temp;
+        }
         // Turn sonar on
         sonar::sonar_toggle on_msg;
         on_msg.set_on = true;
         sonar_toggle_pub.publish(on_msg);
         /** Set scan range */
         // Set scan range
         sonar::sonar_set_scan msg;
         //TODO Enable some checks of start and end position
         msg.stop_l = start_pos;
         msg.stop_r = end_pos;
         sonar_set_scan_pub.publish(msg);
         ros::spinOnce();
         ros::spinOnce();  ///<! Sure? Does this belong here?
+    }
     /**
      * @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
+     *
      * @return NONE
      */
     float SonarControl::set_off()
+    {
         /** Turn sonar off */
         sonar::sonar_toggle on_msg;
         on_msg.set_on = false;
         sonar_toggle_pub.publish(on_msg);
+    }
     /**
      * @brief Query the current front sonar readings
+     *
      * Sends a request to the query_sonar service which will reply with the
      *  current readings of the sonar.
+     *
      * @TODO Change so we can get multiple sonar readings with one call
+     *
      * @return The reading of the front sonar
      */
     float SonarControl::query_front()
+    {
         sonar::sonar_direction srv;
         if(query_sonar.call(srv))
+        {
             srv.response.distance0;
+        }
         else
+        {
             ROS_FATAL("Failed to call service query_motors");
+        }
         return 0;
+    }
     /**
      * @brief Query the current back sonar readings
+     *
      * Sends a request to the query_sonar service which will reply with the
      *  current readings of the sonar.
+     *
      * @TODO Change so we can get multiple sonar readings with one call
+     *
      * @return The reading of the back sonar
      */
     float SonarControl::query_back()
+    {
         sonar::sonar_direction srv;
         if(query_sonar.call(srv))
+        {
             srv.response.distance1;
+        }
         else
+        {
             ROS_FATAL("Failed to call service query_motors");
+        }
         return 0;
+    }
     /**
      * @brief Converts value returne by sonar to physical distances.
-...
      * @param sonar_value The returned value of the sonar
      * @return The physical distance measured by the sonar.
      **/
     float sonar_to_dist(float sonar_value)
+    {
     //float sonar_to_dist(float sonar_value)
     //{
         //TODO impelement later based on sonar readings
         return sonar_value;
+    }
     //    return sonar_value;
     //}
     /**
      * @brief Converts values from physical distances to values read by sonar
-...
      * @param distance The physical distance as measured.
      * @return The value read by the sonar that corresponds to the given distance
      **/
     float dist_to_sonar(float distance)
+    {
     //float dist_to_sonar(float distance)
     //{
         //TODO implement later based on sonar readings
         return distance;
+    }
     //    return distance;
     //}

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file SonarControl.h
-...
+    {
         public:
             /** Set up the motor node and prepare to communicate over ROS */
             SonarControl(const ros::NodeHandle& libscout_node);
             SonarControl(const ros::NodeHandle& libscout_node,
                          std::string scoutname);
             /** Sets sonar to a position (0-180 deg) specified by input */
             void set(int position);
             void set_single(int position);
             /** Sets sonar to scan a range in 0-180 specified by input */
             void set_range(int start_pos, int end_pos);
     	/** Stops sonar from panning and taking readings */
     	void set_off();
             /** Returns the distance readings of sonars */
             float query_front(void);
             float query_back(void);
             /** Stops sonar from panning and taking readings */
             void set_off();
         private:
             /** Converts between values output by sensor and physical distances */
             float sonar_to_dist(float sonar_value);
             float dist_to_sonar(float distance);
             /** Record the new sonar distance measurement */
             void distance_callback(const sonar::sonar_distance::ConstPtr& msg);
             /* Front and back distance values read by sonar. */
             float front_dist;
             float back_dist;
             /** Converts between values output by sensor and physical distances */
             //float sonar_to_dist(float sonar_value);
             //float dist_to_sonar(float distance);
             /** ROS publisher and client declaration */
             /* ROS publisher and client declaration */
             ros::Publisher sonar_set_scan_pub;
             ros::Publisher sonar_toggle_pub;
             ros::ServiceClient query_sonar;
             ros::Subscriber sonar_distance_sub;
             ros::NodeHandle node;
     };

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file constants.h

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file Behavior.cpp
-...
         PriyaBehavior *behavior = new PriyaBehavior(scoutname);
         behavior->run();
         return 0;
+    }

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file motors.cpp

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file motors.h

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file power.cpp

      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file motors.h

     The code in this package was developed using the structure of Willow
     Garage's turtlesim package.  It was modified by the CMU Robotics Club
     to be used as a simulator for the Colony Scout robot.
     All redistribution of this code is limited to the terms of Willow Garage's
     licensing terms, as well as under permission from the CMU Robotics Club.
     Please see both licensing agreements below.
     ******************************************************************************
     ** BELOW IS THE LICENSING AGREEMENT FROM WILLOW GARAGE                      **
     ******************************************************************************
     Copyright (c) 2009, Willow Garage, Inc.
     All rights reserved.
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
        Redistributions of source code must retain the above copyright
           notice, this list of conditions and the following disclaimer.
        Redistributions in binary form must reproduce the above copyright
           notice, this list of conditions and the following disclaimer in the
           documentation and/or other materials provided with the distribution.
        Neither the name of the Willow Garage, Inc. nor the names of its
           contributors may be used to endorse or promote products derived from
           this software without specific prior written permission.
     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
     LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     POSSIBILITY OF SUCH DAMAGE.
     ******************************************************************************
     ** BELOW IS THE LICENSING AGREEMENT FROM THE COLONY PROJECT                 **
     ******************************************************************************
     Copyright (c) 2011 Colony Project
     Permission is hereby granted, free of charge, to any person
     obtaining a copy of this software and associated documentation
     files (the "Software"), to deal in the Software without
     restriction, including without limitation the rights to use,
     copy, modify, merge, publish, distribute, sublicense, and/or sell
     copies of the Software, and to permit persons to whom the
     Software is furnished to do so, subject to the following
     conditions:
     The above copyright notice and this permission notice shall be
     included in all copies or substantial portions of the Software.
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     OTHER DEALINGS IN THE SOFTWARE.

     /*
      * This package was developed by the CMU Robotics Club project using code
      * from Willow Garage, Inc.  Please see licensing.txt for details.
     /**
      * The code in this package was developed using the structure of Willow
      * Garage's turtlesim package.  It was modified by the CMU Robotics Club
      * to be used as a simulator for the Colony Scout robot.
+     *
      * All redistribution of this code is limited to the terms of Willow Garage's
      * licensing terms, as well as under permission from the CMU Robotics Club.
+     *
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * Copyright (c) 2009, Willow Garage, Inc.
      * All rights reserved.
+     *
      * @brief Keeps track of a single scout robot.
      * @file scout.cpp
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
+     *
      *    Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *    Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *    Neither the name of the Willow Garage, Inc. nor the names of its
      *       contributors may be used to endorse or promote products derived from
      *       this software without specific prior written permission.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      */
     #include "scout.h"
-...
             set_pen_srv = node.advertiseService("set_pen",
                                                 &Scout::setPenCallback,
                                                 this);
             teleport_relative_srv =
                 node.advertiseService("teleport_relative",
                                      &Scout::teleportRelativeCallback,
                                      this);
             teleport_absolute_srv =
                 node.advertiseService("teleport_absolute",
                                      &Scout::teleportAbsoluteCallback,
                                      this);
             meter = scout.GetHeight();
+        }
-...
         /**
          * A callback function that sets velocity based on a set_motors
          * request.
          * @todo Use "callback" in all callback function names? Or remove?
          */
         void Scout::setMotors(const motors::set_motors::ConstPtr& msg)
+        {
-...
             ang_vel = SPEED_SCALE_FACTOR * (r_speed - l_speed);
+        }
         float Scout::getSonar(float angle)
+        {
             return 0.0;
+        }
         bool Scout::setPenCallback(scoutsim::SetPen::Request& req,
                                    scoutsim::SetPen::Response&)
+        {
-...
             return true;
+        }
         /// @TODO remove
         bool Scout::teleportRelativeCallback(scoutsim::TeleportRelative::Request& req,
                                              scoutsim::TeleportRelative::Response&)
+        {
             teleport_requests.push_back(TeleportRequest(0,
 ,
                                                          req.angular,
                                                          req.linear,
                                                          true));
             return true;
+        }
         /// @TODO remove
         bool Scout::teleportAbsoluteCallback(scoutsim::TeleportAbsolute::Request& req,
                                              scoutsim::TeleportAbsolute::Response&)
+        {
             teleport_requests.push_back(TeleportRequest(req.x,
                                                          req.y,
                                                          req.theta,
 ,
                                                          false));
             return true;
+        }
         void Scout::update(double dt, wxMemoryDC& path_dc,
                             const wxImage& path_image, wxColour background_color,
                             float canvas_width, float canvas_height)
+        {
             // first process any teleportation requests, in order
             V_TeleportRequest::iterator it = teleport_requests.begin();
             V_TeleportRequest::iterator end = teleport_requests.end();
             for (; it != end; ++it)
+            {
                 const TeleportRequest& req = *it;
                 Vector2 old_pos = pos;
                 if (req.relative)
+                {
                     orient += req.theta;
                     pos.x += sin(orient + PI/2.0) * req.linear;
                     pos.y += cos(orient + PI/2.0) * req.linear;
+                }
                 else
+                {
                     pos.x = req.pos.x;
                     pos.y = std::max(0.0f, canvas_height - req.pos.y);
                     orient = req.theta;
+                }
                 path_dc.SetPen(pen);
                 path_dc.DrawLine(pos.x * meter, pos.y * meter,
                                  old_pos.x * meter, old_pos.y * meter);
+            }
             teleport_requests.clear();
             if (ros::WallTime::now() - last_command_time > ros::WallDuration(1.0))
+            {
                 lin_vel = 0.0f;
                 ang_vel = 0.0f;
+            }
             Vector2 old_pos = pos;
             orient = fmod(orient + ang_vel * dt, 2*PI);

     /*
      * This package was developed by the CMU Robotics Club project using code
      * from Willow Garage, Inc.  Please see licensing.txt for details.
     /**
      * The code in this package was developed using the structure of Willow
      * Garage's turtlesim package.  It was modified by the CMU Robotics Club
      * to be used as a simulator for the Colony Scout robot.
+     *
      * All redistribution of this code is limited to the terms of Willow Garage's
      * licensing terms, as well as under permission from the CMU Robotics Club.
+     *
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * Copyright (c) 2009, Willow Garage, Inc.
      * All rights reserved.
+     *
      * @file scout.h
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
+     *
      *    Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *    Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *    Neither the name of the Willow Garage, Inc. nor the names of its
      *       contributors may be used to endorse or promote products derived from
      *       this software without specific prior written permission.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      */
     #ifndef _SCOUTSIM_SCOUT_H_
-...
     #include <scoutsim/Pose.h>
     #include <scoutsim/SetPen.h>
     #include <scoutsim/TeleportRelative.h>
     #include <scoutsim/TeleportAbsolute.h>
     #include <scoutsim/Color.h>
     #include <wx/wx.h>
     #include "scout_constants.h"
     #define PI 3.14159265
     /// The scale factor so the speed of scout robots is reasonable for the sim
     #define SPEED_SCALE_FACTOR 0.05
-...
             private:
                 void setMotors(const motors::set_motors::ConstPtr& msg);
                 float getSonar(float angle);
                 bool setPenCallback(scoutsim::SetPen::Request&,
                                     scoutsim::SetPen::Response&);
                 bool teleportRelativeCallback(scoutsim::TeleportRelative::Request&,
                                               scoutsim::TeleportRelative::Response&);
                 bool teleportAbsoluteCallback(scoutsim::TeleportAbsolute::Request&,
                                               scoutsim::TeleportAbsolute::Response&);
                 ros::NodeHandle node;
-...
                 int motor_bl_speed;
                 int motor_br_speed;
                 // Each scout has a unique id number, which is also displayed on its image.
                 int scout_id;
                 float lin_vel;
                 float ang_vel;
                 bool pen_on;
-...
                 ros::Publisher pose_pub;
                 ros::Publisher color_pub;
                 ros::ServiceServer set_pen_srv;
                 ros::ServiceServer teleport_relative_srv;
                 ros::ServiceServer teleport_absolute_srv;
                 ros::WallTime last_command_time;
                 float meter;
                 struct TeleportRequest
+                {
                     TeleportRequest(float x, float y, float new_theta,
                                     float new_linear, bool new_relative)
                         : pos(x, y)
                           , theta(new_theta)
                           , linear(new_linear)
                           , relative(new_relative)
                     {}
                     Vector2 pos;
                     float theta;
                     float linear;
                     bool relative;
                 };
                 typedef std::vector<TeleportRequest> V_TeleportRequest;
                 V_TeleportRequest teleport_requests;
         };
         typedef boost::shared_ptr<Scout> ScoutPtr;
+    }
     #endif

     /*
      * This package was developed by the CMU Robotics Club project using code
      * from Willow Garage, Inc.  Please see licensing.txt for details.
     /**
      * The code in this package was developed using the structure of Willow
      * Garage's turtlesim package.  It was modified by the CMU Robotics Club
      * to be used as a simulator for the Colony Scout robot.
+     *
      * All redistribution of this code is limited to the terms of Willow Garage's
      * licensing terms, as well as under permission from the CMU Robotics Club.
+     *
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * Copyright (c) 2009, Willow Garage, Inc.
      * All rights reserved.
+     *
      * @brief Runs the simulator, keeping track of all the scout robots.
      * @file scoutsim.cpp
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
+     *
      *    Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *    Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *    Neither the name of the Willow Garage, Inc. nor the names of its
      *       contributors may be used to endorse or promote products derived from
      *       this software without specific prior written permission.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      */
     #include <wx/app.h>
-...
     class ScoutApp : public wxApp
+    {
     public:
       char** local_argv;
       ros::NodeHandlePtr nh;
         public:
             char** local_argv;
             ros::NodeHandlePtr nh;
       ScoutApp()
+      {
+      }
             ScoutApp()
+            {
+            }
       bool OnInit()
+      {
             bool OnInit()
+            {
     #ifdef __WXMAC__
         ProcessSerialNumber PSN;
         GetCurrentProcess(&PSN);
         TransformProcessType(&PSN,kProcessTransformToForegroundApplication);
         SetFrontProcess(&PSN);
                 ProcessSerialNumber PSN;
                 GetCurrentProcess(&PSN);
                 TransformProcessType(&PSN,kProcessTransformToForegroundApplication);
                 SetFrontProcess(&PSN);
     #endif
         // create our own copy of argv, with regular char*s.
         local_argv =  new char*[ argc ];
         for ( int i = 0; i < argc; ++i )
+        {
           local_argv[ i ] = strdup( wxString( argv[ i ] ).mb_str() );
+        }
                 // Create our own copy of argv, with regular char*s.
                 local_argv = new char*[ argc ];
                 for ( int i = 0; i < argc; ++i )
+                {
                     local_argv[ i ] = strdup( wxString( argv[ i ] ).mb_str() );
+                }
         ros::init(argc, local_argv, "scoutsim");
         nh.reset(new ros::NodeHandle);
                 ros::init(argc, local_argv, "scoutsim");
                 nh.reset(new ros::NodeHandle);
         wxInitAllImageHandlers();
                 wxInitAllImageHandlers();
         scoutsim::SimFrame* frame = new scoutsim::SimFrame(NULL);
                 scoutsim::SimFrame* frame = new scoutsim::SimFrame(NULL);
         SetTopWindow(frame);
         frame->Show();
                 SetTopWindow(frame);
                 frame->Show();
         return true;
+      }
                 return true;
+            }
       int OnExit()
+      {
         for ( int i = 0; i < argc; ++i )
+        {
           free( local_argv[ i ] );
+        }
         delete [] local_argv;
             int OnExit()
+            {
                 for ( int i = 0; i < argc; ++i )
+                {
                     free( local_argv[ i ] );
+                }
                 delete [] local_argv;
         return 0;
+      }
                 return 0;
+            }
     };
     DECLARE_APP(ScoutApp);
     IMPLEMENT_APP(ScoutApp);

     /*
      * This package was developed by the CMU Robotics Club project using code
      * from Willow Garage, Inc.  Please see licensing.txt for details.
     /**
      * The code in this package was developed using the structure of Willow
      * Garage's turtlesim package.  It was modified by the CMU Robotics Club
      * to be used as a simulator for the Colony Scout robot.
+     *
      * All redistribution of this code is limited to the terms of Willow Garage's
      * licensing terms, as well as under permission from the CMU Robotics Club.
+     *
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * Copyright (c) 2009, Willow Garage, Inc.
      * All rights reserved.
+     *
      * @brief Keeps track of the frame (visualization of the whole environment).
      * @file sim_frame.cpp
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
+     *
      *    Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *    Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *    Neither the name of the Willow Garage, Inc. nor the names of its
      *       contributors may be used to endorse or promote products derived from
      *       this software without specific prior written permission.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      */
     #include "sim_frame.h"
-...
                                    width_in_meters, height_in_meters);
+            }
             ++frame_count;
             frame_count++;
+        }
         bool SimFrame::clearCallback(std_srvs::Empty::Request&,
                                      std_srvs::Empty::Response&)
+        {

     /*
      * This package was developed by the CMU Robotics Club project using code
      * from Willow Garage, Inc.  Please see licensing.txt for details.
     /**
      * The code in this package was developed using the structure of Willow
      * Garage's turtlesim package.  It was modified by the CMU Robotics Club
      * to be used as a simulator for the Colony Scout robot.
+     *
      * All redistribution of this code is limited to the terms of Willow Garage's
      * licensing terms, as well as under permission from the CMU Robotics Club.
+     *
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * Copyright (c) 2009, Willow Garage, Inc.
      * All rights reserved.
+     *
      * @file sim_frame.h
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
+     *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are met:
+     *
      *    Redistributions of source code must retain the above copyright
      *       notice, this list of conditions and the following disclaimer.
      *    Redistributions in binary form must reproduce the above copyright
      *       notice, this list of conditions and the following disclaimer in the
      *       documentation and/or other materials provided with the distribution.
      *    Neither the name of the Willow Garage, Inc. nor the names of its
      *       contributors may be used to endorse or promote products derived from
      *       this software without specific prior written permission.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      */
     #include <wx/wx.h>

scout/sonar/msg/sonar_direction.msg
1		# Gives a timestamp so nodes make sure they use current readings
2		Header header
3
4		# Distance reading from the front sonar
5		int8 distance0
6		# Distance reading from the back sonar
7		int8 distnace1

     /**
      * Copyright (c) 2007 Colony Project
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
-...
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file sonar.cpp
-...
      * @author Alex Zirbel
      **/
     #include "scout/sonar.h"
     #include "ros/ros.h"
     #include <ros/ros.h>
     #include <cstdlib>
     #include "sonar.h"
     /**
      * @defgroup sonar Sonar
      * @brief Functions for using the sonar
-...
         is_on = true;
         /* Initialize hardware for sonar */
         //Hardware init functions here
         // Hardware init functions here
         sonar_init();
         /* Initialize the sonar driver node in ROS */
-...
                                                         handle_sonar_set_scan);
         ROS_INFO("Sonar: Ready");
         // Sonar reading and publishing here
         ros::spin();
         return 0;

     /**
      * Copyright (c) 2007 Colony Project
      * Copyright (c) 2011 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
-...
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
      */
     /**
      * @file sonar.h

ID	c492be629f06e3cf71fdf832ce2cd5ac1ec779f8
Parent	cc558a8d
Child	b00761a0

Project

General

Profile

Colony » Colony Scout

Revision c492be62