/ - Diff - Colony Scout OS - Robotics Club

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(libscout_node src/behavior.cpp src/libscout.cpp src/libmotors.cpp src/libheadlights.cpp src/libbuttons.cpp)
33	32	rosbuild_add_executable(alex_behavior src/alex_behavior.cpp src/libscout.h src/MotorControl.cpp src/HeadlightControl.cpp)
	33	rosbuild_add_executable(priya_behavior src/priya_behavior_process.cpp src/PriyaBehavior.cpp src/Behavior.cpp src/libscout.h src/MotorControl.cpp src/HeadlightControl.cpp)
	34	rosbuild_add_executable(drive_square src/drive_square.cpp src/libscout.h src/MotorControl.cpp src/HeadlightControl.cpp)

scout/libscout/src/Behavior.cpp
31	31	*
32	32	* @author Colony Project, CMU Robotics Club
33	33	* @author Priyanka Deo
	34	* @author Alex Zirbel
34	35	**/
35	36
36	37	#include "Behavior.h"
37	38
38		Behavior::init(int argc, char** argv)
39		{
40		ros::init(argc, argv, "libscout");
	39	using namespace std;
41	40
42		motors(node);
	41	Behavior::Behavior(string scoutname)
	42	{
	43	motors = new MotorControl(node, scoutname);
	44	loop_rate = new ros::Rate(10);
43	45	//buttons(node);
44	46	//sonar(node);
45
46		ros::Rate loop_rate(10);
47	47	}
48	48
49		Behavior::ok()
	49	bool Behavior::ok()
50	50	{
51		return ros::ok()
	51	return ros::ok();
52	52	}
53	53
54		Behavior::spin()
	54	void Behavior::spin()
55	55	{
56	56	ros::spin();
57	57	return;
58	58	}
59	59
60		Behavior::spinOnce()
	60	void Behavior::spinOnce()
61	61	{
62		ros::SpinOnce();
	62	ros::spinOnce();
63	63	return;
64	64	}

+     *
      * @author Colony Project, CMU Robotics Club
      * @author Priyanka Deo
      * @author Alex Zirbel
      **/
     #ifdef _BEHAVIOR_H_
     #ifndef _BEHAVIOR_H_
     #define _BEHAVIOR_H_
     #include "libscout.h"
     #include <ros/ros.h>
     #include <libscout/constants.h>
     #include "MotorControl.h"
     #include "HeadlightControl.h"
     #include "SonarControl.h"
     class Behavior
+    {
         public:
     	ros::NodeHandle node;
     	ros::Rate loop_rate;
     	//Declare all used library controls
     	MotorControl motors;
     	//ButtonControl buttons;
     	//SonarControl sonar;
             // Initializes ROS for behavior
             Behavior(std::string scoutname);
     	//Initializes ROS for behavior
     	void init(int argc, char** argv);
             // User implemented behavior
             virtual void run() = 0;
     	//User implemented behavior
     	virtual int main(int argc, char** argv) = 0;
         protected:
             ros::NodeHandle node;
             ros::Rate *loop_rate;
     	//Wrappers for ROS functions
     	bool ok();
     	void spin();
     	void spinOnce();
             // Declare all used library controls
             MotorControl * motors;
             //ButtonControl buttons;
             //SonarControl sonar;
             // Wrappers for ROS functions
             bool ok();
             void spin();
             void spinOnce();
     };
     #endif

     #include "MotorControl.h"
     using namespace std;
     /**
      * @brief Initialize the motors module of libscout.
+     *
      * Initialize the libscout node as a publisher of set_motors and a client of
      * query_motors.
      */
     MotorControl::MotorControl(const ros::NodeHandle& libscout_node)
     MotorControl::MotorControl(const ros::NodeHandle& libscout_node,
                                string scoutname)
         : node(libscout_node)
+    {
         set_motors_pub =
             node.advertise<motors::set_motors>("scout1/set_motors", QUEUE_SIZE);
             node.advertise<motors::set_motors>(scoutname + "/set_motors",
                                                QUEUE_SIZE);
         query_motors_client =
             node.serviceClient<motors::query_motors>("query_motors");
             node.serviceClient<motors::query_motors>(scoutname + "/query_motors");
+    }
     /**

+    {
         public:
             /** Set up the motor node and prepare to communicate over ROS */
             MotorControl(const ros::NodeHandle& libscout_node);
             MotorControl(const ros::NodeHandle& libscout_node,
                          std::string scoutname);
             /** Uses which to specify what to change, and sets all to same speed */
             void set(int which, float speed, char units=MOTOR_DEFAULT_UNIT);
-...
             ros::ServiceClient query_motors_client;
             ros::NodeHandle node;
     };
     #endif

     /**
      * 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.
      */
     /**
      * @file PriyaBehavior.cpp
      * @brief A simple robot behavior, smart-runaround style, that uses
      * the behavior class
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
      * @author Priyanka Deo
      */
     #include "PriyaBehavior.h"
     void PriyaBehavior::run()
+    {
         while(ok())
+        {
             motors->set_sides(20, 80, MOTOR_ABSOLUTE);
             spinOnce();
             loop_rate->sleep();
+        }
+    }

     /**
      * 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.
      **/
     /**
      * @file PriyaBehavior.h
      * @brief A simple behavior which drives the scout in a circle.
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Priyanka Deo
      * @author Alex Zirbel
      **/
     #ifndef _PRIYA_BEHAVIOR_H_
     #define _PRIYA_BEHAVIOR_H_
     #include "Behavior.h"
     /**
      * @brief PriyaBehavior A simple robot behavior.
+     *
      * Inherits Behavior class which contains all basic behavior
      * functionality.
      */
     class PriyaBehavior : Behavior
+    {
         public:
             PriyaBehavior(std::string scoutname) : Behavior(scoutname) {}
             /**
              * @brief Runs the behavior.
              */
             void run();
     };
     #endif

     /**
      * 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.
      */
     /**
      * @file alex_behavior.cpp
      * @brief A simple robot behavior, smart-runaround style.
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
      */
     #include "libscout.h"
     /**
      * @brief Main. The main function for the behavior.
+     *
      * This is the main function for libscout. It calls init() which initializes
      * the clients and publishers/subscribers for the other parts of the library.
      */
     int main(int argc, char **argv)
+    {
         ros::init(argc, argv, "libscout");
         ros::NodeHandle node;
         MotorControl motors(node);
         //ButtonControl buttons(node);
         ros::Rate loop_rate(10);
         while(ros::ok())
+        {
             motors.set_sides(20, 80, MOTOR_ABSOLUTE);
             ros::spinOnce();
             loop_rate.sleep();
+        }
         return 0;
+    }

     /**
      * 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.
      **/
     /**
      * @file behavior.cpp
      * @brief Contains behavior
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Ben Wasserman
      **/
     #include "libscout.h"
     /*!
      * \brief Main. The main function for the behavior.
+     *
      * This is the main function for libscout. It calls init() which initializes
      * the clients and publishers/subscribers for the other parts of the library.
+     *
      * \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){
       /* Todo: Replace this tester code */
       /* Creates a simple publisher/subscriber node to test simulator
        * for motors interface
        */
       /* Initialize ROS */
       ros::init(argc, argv, "libscout");
       /* Initialize Scout library */
       init(LIB_ALL, argc, argv);
       /* Some nodehandle to something. I'd tell you what except its called n_
        * so it wouldnt reflect in the rest of the code.
        */
       ros::NodeHandle n_;
       ros::Publisher motors_set = n_.advertise<motors::set_motors>("Stuff", 1000);
       ros::Rate loop_rate(10);
       while(ros::ok()){
         motors::set_motors msg;
         /* Set message fields */
         msg.fl_speed = 125;
         msg.bl_speed = 125;
         msg.fr_speed = 125;
         msg.br_speed = 125;
         msg.units = MOTOR_ABSOLUTE;
         /* publish */
         motors_set.publish(msg);
         ros::spinOnce();
         loop_rate.sleep();
+      }
       return 0;
+    }

     /**
      * 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.
      */
     /**
      * @file libscout.cpp
      * @brief Contains top level scout library functions
+     *
      * Contains functions and definitions for the use of
      * libscout
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Ben Wasserman
      */
     #include "libscout.h"
     /** @todo Decide how to call user behaviors
+     *
      * I'm thinking that there be a function call in main that calls the "main"
      fn in the user behavior. However, their "main" function will not be called
      main. However, this has to be able to point to different functions by
      changing as little code in this file as possible. Also, the user behaviors
      should live in a different directory (possibly a different package).
      However, this other package should not be executed as a separate node,
      because that is the job of the libscout node/package to handle all the ROS
      stuff, and keep it under the lid. The user only has to call normal c
      functions. I also want to reduce the need to recompile this package when the
      user behavior, or any other package that works below the surface.
      */
     /**
      * @brief Initializes modules in the libscout.
+     *
      * Calls init functions for each module in libscout.
      * @param modules A bitmask of the modules that will be initialized.
      */
     int init(int modules, int argc, char **argv)
+    {
         ros::init(argc, argv, "libscout");
         ros::NodeHandle node;
         MotorControl motors = new MotorControl(node);
         HeadLightControl headlights = new HeadlightControl(node);
         SonarControl sonars = new SonarControl(node);
         /** @todo Copy this if for each module that gets added to the library */
         /*if(modules & LIB_MOTORS)
+        {
             libmotors_init();
+        }
         if(modules & LIB_HEADLIGHTS)
+        {
             libheadlights_init();
+        }
         if(modules & LIB_BUTTONS)
+        {
             libbuttons_init();
         }*/
         /** @todo Add other lib inits **/
         return 0;
+    }

     /**
      * 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.
      **/
     /**
      * @file libscout.h
      * @brief Contains top level scout library functions
+     *
      * Contains functions and definitions for the use of
      * libscout
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Ben Wasserman
      **/
     /* Author: Ben Wasserman
     */
     #ifndef _LIBSCOUT_H_
     #define _LIBSCOUT_H_
     #include <ros/ros.h>
     #include <libscout/constants.h>
     #include "MotorControl.h"
     #include "HeadlightControl.h"
     #include "SonarControl.h"
     /* Libscout functions */
     int init(int modules, int argc, char **argv);
     #endif

     /**
      * 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.
      */
     /**
      * @file priya_behavior.cpp
      * @brief A simple robot behavior, smart-runaround style, that uses
      * the behavior class
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
      * @author Priyanka Deo
      */
     #include "Behavior.h"
     /**
      * @brief Priya_Behavior A simple robot behavior.
+     *
      * Inherits Behavior class which contains all basic behavior
      * functionality.
      */
     class Priya_Behavior:Behavior
+    {
     	/**
     	 * @brief Main. The main function for the behavior.
+    	 *
     	 * Defined in Behavior class as a virtual. Must be
     	 * implemented in functional behaviors.
     	 */
     	int main(int argc, char **argv)
+    	{
     		init(argc, argv);
     		while(ok())
+    		{
     			motors.set_sides(20, 80, MOTOR_ABSOLUTE);
     			spinOnce();
     			loop_rate.sleep();
+    		}
     		return 0;
+    	}
     };

     /**
      * 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.
      **/
     /**
      * @file Behavior.cpp
      * @brief A wrapper that executes PriyaBehavior as an executable.
+     *
      * Should be auto-generated in the future.
+     *
      * @author Colony Project, CMU Robotics Club
      * @author Alex Zirbel
      **/
     #include <ros/ros.h>
     #include "PriyaBehavior.h"
     using namespace std;
     int main (int argc, char **argv)
+    {
         if (argc != 2)
+        {
             cout << "Usage: " << argv[0] << " <scoutname>" << endl;
             exit(1);
+        }
         ros::init(argc, argv, "libscout");
         PriyaBehavior *behavior = new PriyaBehavior(argv[1]);
         behavior->run();
+    }

scout/scoutsim/srv/TeleportAbsolute.srv
1		float32 x
2		float32 y
3		float32 theta
4		---

scout/scoutsim/srv/TeleportRelative.srv
1		float32 linear
2		float32 angular
3		---

Project

General

Profile

Colony » Colony Scout » Colony Scout OS

Revision c384dc7e