├── CMakeLists.txt ├── README.md ├── embedded ├── avrdude_script.sh ├── ros_lib │ ├── ArduinoHardware.h │ ├── actionlib │ │ ├── TestAction.h │ │ ├── TestActionFeedback.h │ │ ├── TestActionGoal.h │ │ ├── TestActionResult.h │ │ ├── TestFeedback.h │ │ ├── TestGoal.h │ │ ├── TestRequestAction.h │ │ ├── TestRequestActionFeedback.h │ │ ├── TestRequestActionGoal.h │ │ ├── TestRequestActionResult.h │ │ ├── TestRequestFeedback.h │ │ ├── TestRequestGoal.h │ │ ├── TestRequestResult.h │ │ ├── TestResult.h │ │ ├── TwoIntsAction.h │ │ ├── TwoIntsActionFeedback.h │ │ ├── TwoIntsActionGoal.h │ │ ├── TwoIntsActionResult.h │ │ ├── TwoIntsFeedback.h │ │ ├── TwoIntsGoal.h │ │ └── TwoIntsResult.h │ ├── actionlib_msgs │ │ ├── GoalID.h │ │ ├── GoalStatus.h │ │ └── GoalStatusArray.h │ ├── actionlib_tutorials │ │ ├── AveragingAction.h │ │ ├── AveragingActionFeedback.h │ │ ├── AveragingActionGoal.h │ │ ├── AveragingActionResult.h │ │ ├── AveragingFeedback.h │ │ ├── AveragingGoal.h │ │ ├── AveragingResult.h │ │ ├── FibonacciAction.h │ │ ├── FibonacciActionFeedback.h │ │ ├── FibonacciActionGoal.h │ │ ├── FibonacciActionResult.h │ │ ├── FibonacciFeedback.h │ │ ├── FibonacciGoal.h │ │ └── FibonacciResult.h │ ├── arbotix_msgs │ │ ├── Analog.h │ │ ├── Digital.h │ │ ├── Enable.h │ │ ├── Relax.h │ │ ├── SetSpeed.h │ │ └── SetupChannel.h │ ├── base_local_planner │ │ └── Position2DInt.h │ ├── bond │ │ ├── Constants.h │ │ └── Status.h │ ├── capabilities │ │ ├── Capability.h │ │ ├── CapabilityEvent.h │ │ ├── CapabilitySpec.h │ │ ├── EstablishBond.h │ │ ├── FreeCapability.h │ │ ├── GetCapabilitySpec.h │ │ ├── GetCapabilitySpecs.h │ │ ├── GetInterfaces.h │ │ ├── GetNodeletManagerName.h │ │ ├── GetProviders.h │ │ ├── GetRemappings.h │ │ ├── GetRunningCapabilities.h │ │ ├── GetSemanticInterfaces.h │ │ ├── Remapping.h │ │ ├── RunningCapability.h │ │ ├── StartCapability.h │ │ ├── StopCapability.h │ │ └── UseCapability.h │ ├── concert_msgs │ │ ├── AllocateSoftware.h │ │ ├── ConcertClient.h │ │ ├── ConcertClientState.h │ │ ├── ConcertClients.h │ │ ├── ConductorGraph.h │ │ ├── EnableService.h │ │ ├── ErrorCodes.h │ │ ├── LinkConnection.h │ │ ├── LinkEdge.h │ │ ├── LinkGraph.h │ │ ├── LinkNode.h │ │ ├── ServiceProfile.h │ │ ├── Services.h │ │ ├── SoftwareInstance.h │ │ ├── SoftwareInstances.h │ │ ├── SoftwareProfile.h │ │ ├── SoftwareProfiles.h │ │ ├── Strings.h │ │ └── UpdateServiceConfig.h │ ├── concert_service_msgs │ │ ├── CaptureResourcePair.h │ │ ├── CaptureResourcePairRequest.h │ │ ├── CaptureResourcePairResponse.h │ │ ├── CaptureResourceRequest.h │ │ ├── CaptureResourceResponse.h │ │ ├── KillTurtlePair.h │ │ ├── KillTurtlePairRequest.h │ │ ├── KillTurtlePairResponse.h │ │ ├── KillTurtleRequest.h │ │ ├── KillTurtleResponse.h │ │ ├── SpawnTurtlePair.h │ │ ├── SpawnTurtlePairRequest.h │ │ ├── SpawnTurtlePairResponse.h │ │ ├── SpawnTurtleRequest.h │ │ └── SpawnTurtleResponse.h │ ├── control_msgs │ │ ├── FollowJointTrajectoryAction.h │ │ ├── FollowJointTrajectoryActionFeedback.h │ │ ├── FollowJointTrajectoryActionGoal.h │ │ ├── FollowJointTrajectoryActionResult.h │ │ ├── FollowJointTrajectoryFeedback.h │ │ ├── FollowJointTrajectoryGoal.h │ │ ├── FollowJointTrajectoryResult.h │ │ ├── GripperCommand.h │ │ ├── GripperCommandAction.h │ │ ├── GripperCommandActionFeedback.h │ │ ├── GripperCommandActionGoal.h │ │ ├── GripperCommandActionResult.h │ │ ├── GripperCommandFeedback.h │ │ ├── GripperCommandGoal.h │ │ ├── GripperCommandResult.h │ │ ├── JointControllerState.h │ │ ├── JointTolerance.h │ │ ├── JointTrajectoryAction.h │ │ ├── JointTrajectoryActionFeedback.h │ │ ├── JointTrajectoryActionGoal.h │ │ ├── JointTrajectoryActionResult.h │ │ ├── JointTrajectoryControllerState.h │ │ ├── JointTrajectoryFeedback.h │ │ ├── JointTrajectoryGoal.h │ │ ├── JointTrajectoryResult.h │ │ ├── PointHeadAction.h │ │ ├── PointHeadActionFeedback.h │ │ ├── PointHeadActionGoal.h │ │ ├── PointHeadActionResult.h │ │ ├── PointHeadFeedback.h │ │ ├── PointHeadGoal.h │ │ ├── PointHeadResult.h │ │ ├── QueryCalibrationState.h │ │ ├── QueryTrajectoryState.h │ │ ├── SingleJointPositionAction.h │ │ ├── SingleJointPositionActionFeedback.h │ │ ├── SingleJointPositionActionGoal.h │ │ ├── SingleJointPositionActionResult.h │ │ ├── SingleJointPositionFeedback.h │ │ ├── SingleJointPositionGoal.h │ │ └── SingleJointPositionResult.h │ ├── costmap_2d │ │ └── VoxelGrid.h │ ├── create_node │ │ ├── BatteryState.h │ │ ├── Drive.h │ │ ├── RawTurtlebotSensorState.h │ │ ├── RoombaSensorState.h │ │ ├── SetDigitalOutputs.h │ │ ├── SetTurtlebotMode.h │ │ ├── Turtle.h │ │ └── TurtlebotSensorState.h │ ├── diagnostic_msgs │ │ ├── AddDiagnostics.h │ │ ├── DiagnosticArray.h │ │ ├── DiagnosticStatus.h │ │ ├── KeyValue.h │ │ └── SelfTest.h │ ├── driver_base │ │ ├── ConfigString.h │ │ ├── ConfigValue.h │ │ └── SensorLevels.h │ ├── duration.cpp │ ├── dynamic_reconfigure │ │ ├── BoolParameter.h │ │ ├── Config.h │ │ ├── ConfigDescription.h │ │ ├── DoubleParameter.h │ │ ├── Group.h │ │ ├── GroupState.h │ │ ├── IntParameter.h │ │ ├── ParamDescription.h │ │ ├── Reconfigure.h │ │ ├── SensorLevels.h │ │ └── StrParameter.h │ ├── examples │ │ ├── ADC │ │ │ └── ADC.pde │ │ ├── Blink │ │ │ └── Blink.pde │ │ ├── BlinkM │ │ │ ├── BlinkM.pde │ │ │ └── BlinkM_funcs.h │ │ ├── Clapper │ │ │ └── Clapper.pde │ │ ├── HelloWorld │ │ │ └── HelloWorld.pde │ │ ├── IrRanger │ │ │ └── IrRanger.pde │ │ ├── Logging │ │ │ └── Logging.pde │ │ ├── Odom │ │ │ └── Odom.pde │ │ ├── ServiceClient │ │ │ ├── ServiceClient.pde │ │ │ └── client.py │ │ ├── ServiceServer │ │ │ └── ServiceServer.pde │ │ ├── ServoControl │ │ │ └── ServoControl.pde │ │ ├── Temperature │ │ │ └── Temperature.pde │ │ ├── TimeTF │ │ │ └── TimeTF.pde │ │ ├── Ultrasound │ │ │ └── Ultrasound.pde │ │ ├── button_example │ │ │ └── button_example.pde │ │ └── pubsub │ │ │ └── pubsub.pde │ ├── firebird │ │ ├── Aux.h │ │ ├── Battery.h │ │ ├── IR.h │ │ ├── Lcd.h │ │ ├── Sensor.h │ │ ├── Sharp.h │ │ └── WLS.h │ ├── gateway_msgs │ │ ├── Advertise.h │ │ ├── AdvertiseAll.h │ │ ├── ConnectHub.h │ │ ├── ConnectionStatistics.h │ │ ├── ConnectionType.h │ │ ├── ErrorCodes.h │ │ ├── GatewayInfo.h │ │ ├── Remote.h │ │ ├── RemoteAll.h │ │ ├── RemoteGateway.h │ │ ├── RemoteGatewayInfo.h │ │ ├── RemoteRule.h │ │ ├── RemoteRuleWithStatus.h │ │ ├── Rule.h │ │ └── SetWatcherPeriod.h │ ├── gazebo_msgs │ │ ├── ApplyBodyWrench.h │ │ ├── ApplyJointEffort.h │ │ ├── BodyRequest.h │ │ ├── ContactState.h │ │ ├── ContactsState.h │ │ ├── DeleteModel.h │ │ ├── GetJointProperties.h │ │ ├── GetLinkProperties.h │ │ ├── GetLinkState.h │ │ ├── GetModelProperties.h │ │ ├── GetModelState.h │ │ ├── GetPhysicsProperties.h │ │ ├── GetWorldProperties.h │ │ ├── JointRequest.h │ │ ├── LinkState.h │ │ ├── LinkStates.h │ │ ├── ModelState.h │ │ ├── ModelStates.h │ │ ├── ODEJointProperties.h │ │ ├── ODEPhysics.h │ │ ├── SetJointProperties.h │ │ ├── SetJointTrajectory.h │ │ ├── SetLinkProperties.h │ │ ├── SetLinkState.h │ │ ├── SetModelConfiguration.h │ │ ├── SetModelState.h │ │ ├── SetPhysicsProperties.h │ │ ├── SpawnModel.h │ │ └── WorldState.h │ ├── geographic_msgs │ │ ├── BoundingBox.h │ │ ├── GeoPoint.h │ │ ├── GeoPose.h │ │ ├── GeographicMap.h │ │ ├── GeographicMapChanges.h │ │ ├── GetGeographicMap.h │ │ ├── GetRoutePlan.h │ │ ├── KeyValue.h │ │ ├── MapFeature.h │ │ ├── RouteNetwork.h │ │ ├── RoutePath.h │ │ ├── RouteSegment.h │ │ ├── UpdateGeographicMap.h │ │ └── WayPoint.h │ ├── geometry_msgs │ │ ├── Accel.h │ │ ├── AccelStamped.h │ │ ├── AccelWithCovariance.h │ │ ├── AccelWithCovarianceStamped.h │ │ ├── Inertia.h │ │ ├── InertiaStamped.h │ │ ├── Point.h │ │ ├── Point32.h │ │ ├── PointStamped.h │ │ ├── Polygon.h │ │ ├── PolygonStamped.h │ │ ├── Pose.h │ │ ├── Pose2D.h │ │ ├── PoseArray.h │ │ ├── PoseStamped.h │ │ ├── PoseWithCovariance.h │ │ ├── PoseWithCovarianceStamped.h │ │ ├── Quaternion.h │ │ ├── QuaternionStamped.h │ │ ├── Transform.h │ │ ├── TransformStamped.h │ │ ├── Twist.h │ │ ├── TwistStamped.h │ │ ├── TwistWithCovariance.h │ │ ├── TwistWithCovarianceStamped.h │ │ ├── Vector3.h │ │ ├── Vector3Stamped.h │ │ ├── Wrench.h │ │ └── WrenchStamped.h │ ├── household_objects_database_msgs │ │ ├── DatabaseModelPose.h │ │ ├── DatabaseModelPoseList.h │ │ ├── DatabaseReturnCode.h │ │ ├── DatabaseScan.h │ │ ├── GetModelDescription.h │ │ ├── GetModelList.h │ │ ├── GetModelMesh.h │ │ ├── GetModelScans.h │ │ ├── SaveScan.h │ │ └── TranslateRecognitionId.h │ ├── kobuki_msgs │ │ ├── AutoDockingAction.h │ │ ├── AutoDockingActionFeedback.h │ │ ├── AutoDockingActionGoal.h │ │ ├── AutoDockingActionResult.h │ │ ├── AutoDockingFeedback.h │ │ ├── AutoDockingGoal.h │ │ ├── AutoDockingResult.h │ │ ├── BumperEvent.h │ │ ├── ButtonEvent.h │ │ ├── CliffEvent.h │ │ ├── ControllerInfo.h │ │ ├── DigitalInputEvent.h │ │ ├── DigitalOutput.h │ │ ├── DockInfraRed.h │ │ ├── ExternalPower.h │ │ ├── KeyboardInput.h │ │ ├── Led.h │ │ ├── MotorPower.h │ │ ├── PowerSystemEvent.h │ │ ├── RobotStateEvent.h │ │ ├── ScanAngle.h │ │ ├── SensorState.h │ │ ├── Sound.h │ │ ├── VersionInfo.h │ │ └── WheelDropEvent.h │ ├── laser_assembler │ │ ├── AssembleScans.h │ │ └── AssembleScans2.h │ ├── manipulation_msgs │ │ ├── CartesianGains.h │ │ ├── ClusterBoundingBox.h │ │ ├── Grasp.h │ │ ├── GraspPlanning.h │ │ ├── GraspPlanningAction.h │ │ ├── GraspPlanningActionFeedback.h │ │ ├── GraspPlanningActionGoal.h │ │ ├── GraspPlanningActionResult.h │ │ ├── GraspPlanningErrorCode.h │ │ ├── GraspPlanningFeedback.h │ │ ├── GraspPlanningGoal.h │ │ ├── GraspPlanningResult.h │ │ ├── GraspResult.h │ │ ├── GraspableObject.h │ │ ├── GraspableObjectList.h │ │ ├── GripperTranslation.h │ │ ├── ManipulationPhase.h │ │ ├── ManipulationResult.h │ │ ├── PlaceLocation.h │ │ ├── PlaceLocationResult.h │ │ └── SceneRegion.h │ ├── map_msgs │ │ ├── GetMapROI.h │ │ ├── GetPointMap.h │ │ ├── GetPointMapROI.h │ │ ├── OccupancyGridUpdate.h │ │ ├── PointCloud2Update.h │ │ ├── ProjectedMap.h │ │ ├── ProjectedMapInfo.h │ │ ├── ProjectedMapsInfo.h │ │ ├── SaveMap.h │ │ └── SetMapProjections.h │ ├── move_base_msgs │ │ ├── MoveBaseAction.h │ │ ├── MoveBaseActionFeedback.h │ │ ├── MoveBaseActionGoal.h │ │ ├── MoveBaseActionResult.h │ │ ├── MoveBaseFeedback.h │ │ ├── MoveBaseGoal.h │ │ └── MoveBaseResult.h │ ├── moveit_msgs │ │ ├── AllowedCollisionEntry.h │ │ ├── AllowedCollisionMatrix.h │ │ ├── ApplyPlanningScene.h │ │ ├── AttachedCollisionObject.h │ │ ├── BoundingVolume.h │ │ ├── CheckIfRobotStateExistsInWarehouse.h │ │ ├── CollisionObject.h │ │ ├── ConstraintEvalResult.h │ │ ├── Constraints.h │ │ ├── ContactInformation.h │ │ ├── CostSource.h │ │ ├── DeleteRobotStateFromWarehouse.h │ │ ├── DisplayRobotState.h │ │ ├── DisplayTrajectory.h │ │ ├── ExecuteKnownTrajectory.h │ │ ├── GetCartesianPath.h │ │ ├── GetConstraintAwarePositionIK.h │ │ ├── GetKinematicSolverInfo.h │ │ ├── GetMotionPlan.h │ │ ├── GetPlanningScene.h │ │ ├── GetPositionFK.h │ │ ├── GetPositionIK.h │ │ ├── GetRobotStateFromWarehouse.h │ │ ├── GetStateValidity.h │ │ ├── Grasp.h │ │ ├── GripperTranslation.h │ │ ├── JointConstraint.h │ │ ├── JointLimits.h │ │ ├── KinematicSolverInfo.h │ │ ├── LinkPadding.h │ │ ├── LinkScale.h │ │ ├── ListRobotStatesInWarehouse.h │ │ ├── LoadMap.h │ │ ├── MotionPlanDetailedResponse.h │ │ ├── MotionPlanRequest.h │ │ ├── MotionPlanResponse.h │ │ ├── MoveGroupAction.h │ │ ├── MoveGroupActionFeedback.h │ │ ├── MoveGroupActionGoal.h │ │ ├── MoveGroupActionResult.h │ │ ├── MoveGroupFeedback.h │ │ ├── MoveGroupGoal.h │ │ ├── MoveGroupResult.h │ │ ├── MoveItErrorCodes.h │ │ ├── ObjectColor.h │ │ ├── OrientationConstraint.h │ │ ├── OrientedBoundingBox.h │ │ ├── PickupAction.h │ │ ├── PickupActionFeedback.h │ │ ├── PickupActionGoal.h │ │ ├── PickupActionResult.h │ │ ├── PickupFeedback.h │ │ ├── PickupGoal.h │ │ ├── PickupResult.h │ │ ├── PlaceAction.h │ │ ├── PlaceActionFeedback.h │ │ ├── PlaceActionGoal.h │ │ ├── PlaceActionResult.h │ │ ├── PlaceFeedback.h │ │ ├── PlaceGoal.h │ │ ├── PlaceLocation.h │ │ ├── PlaceResult.h │ │ ├── PlannerInterfaceDescription.h │ │ ├── PlanningOptions.h │ │ ├── PlanningScene.h │ │ ├── PlanningSceneComponents.h │ │ ├── PlanningSceneWorld.h │ │ ├── PositionConstraint.h │ │ ├── PositionIKRequest.h │ │ ├── QueryPlannerInterfaces.h │ │ ├── RenameRobotStateInWarehouse.h │ │ ├── RobotState.h │ │ ├── RobotTrajectory.h │ │ ├── SaveMap.h │ │ ├── SaveRobotStateToWarehouse.h │ │ ├── TrajectoryConstraints.h │ │ ├── VisibilityConstraint.h │ │ └── WorkspaceParameters.h │ ├── nav_msgs │ │ ├── GetMap.h │ │ ├── GetMapAction.h │ │ ├── GetMapActionFeedback.h │ │ ├── GetMapActionGoal.h │ │ ├── GetMapActionResult.h │ │ ├── GetMapFeedback.h │ │ ├── GetMapGoal.h │ │ ├── GetMapResult.h │ │ ├── GetPlan.h │ │ ├── GridCells.h │ │ ├── MapMetaData.h │ │ ├── OccupancyGrid.h │ │ ├── Odometry.h │ │ ├── Path.h │ │ └── SetMap.h │ ├── navfn │ │ ├── MakeNavPlan.h │ │ └── SetCostmap.h │ ├── nodelet │ │ ├── NodeletList.h │ │ ├── NodeletLoad.h │ │ └── NodeletUnload.h │ ├── object_recognition_msgs │ │ ├── GetObjectInformation.h │ │ ├── ObjectInformation.h │ │ ├── ObjectRecognitionAction.h │ │ ├── ObjectRecognitionActionFeedback.h │ │ ├── ObjectRecognitionActionGoal.h │ │ ├── ObjectRecognitionActionResult.h │ │ ├── ObjectRecognitionFeedback.h │ │ ├── ObjectRecognitionGoal.h │ │ ├── ObjectRecognitionResult.h │ │ ├── ObjectType.h │ │ ├── RecognizedObject.h │ │ ├── RecognizedObjectArray.h │ │ ├── Table.h │ │ └── TableArray.h │ ├── octomap_msgs │ │ ├── BoundingBoxQuery.h │ │ ├── GetOctomap.h │ │ ├── Octomap.h │ │ └── OctomapWithPose.h │ ├── opencv_apps │ │ ├── Circle.h │ │ ├── CircleArray.h │ │ ├── CircleArrayStamped.h │ │ ├── Contour.h │ │ ├── ContourArray.h │ │ ├── ContourArrayStamped.h │ │ ├── Face.h │ │ ├── FaceArray.h │ │ ├── FaceArrayStamped.h │ │ ├── Flow.h │ │ ├── FlowArray.h │ │ ├── FlowArrayStamped.h │ │ ├── FlowStamped.h │ │ ├── Line.h │ │ ├── LineArray.h │ │ ├── LineArrayStamped.h │ │ ├── Moment.h │ │ ├── MomentArray.h │ │ ├── MomentArrayStamped.h │ │ ├── Point2D.h │ │ ├── Point2DArray.h │ │ ├── Point2DArrayStamped.h │ │ ├── Point2DStamped.h │ │ ├── Rect.h │ │ ├── RectArray.h │ │ ├── RectArrayStamped.h │ │ ├── RotatedRect.h │ │ ├── RotatedRectArray.h │ │ ├── RotatedRectArrayStamped.h │ │ ├── RotatedRectStamped.h │ │ └── Size.h │ ├── openni2_camera │ │ └── GetSerial.h │ ├── pano_ros │ │ ├── Pano.h │ │ ├── PanoCaptureAction.h │ │ ├── PanoCaptureActionFeedback.h │ │ ├── PanoCaptureActionGoal.h │ │ ├── PanoCaptureActionResult.h │ │ ├── PanoCaptureFeedback.h │ │ ├── PanoCaptureGoal.h │ │ ├── PanoCaptureResult.h │ │ ├── StitchAction.h │ │ ├── StitchActionFeedback.h │ │ ├── StitchActionGoal.h │ │ ├── StitchActionResult.h │ │ ├── StitchFeedback.h │ │ ├── StitchGoal.h │ │ └── StitchResult.h │ ├── pcl_msgs │ │ ├── ModelCoefficients.h │ │ ├── PointIndices.h │ │ ├── PolygonMesh.h │ │ └── Vertices.h │ ├── polled_camera │ │ └── GetPolledImage.h │ ├── robot_localization │ │ ├── SetDatum.h │ │ └── SetPose.h │ ├── robot_pose_ekf │ │ └── GetStatus.h │ ├── rocon_app_manager_msgs │ │ ├── Constants.h │ │ ├── ErrorCodes.h │ │ ├── GetRappList.h │ │ ├── IncompatibleRappList.h │ │ ├── Init.h │ │ ├── Invite.h │ │ ├── PublicInterface.h │ │ ├── PublishedInterface.h │ │ ├── Rapp.h │ │ ├── RappList.h │ │ ├── StartRapp.h │ │ ├── Status.h │ │ └── StopRapp.h │ ├── rocon_interaction_msgs │ │ ├── ErrorCodes.h │ │ ├── GetInteraction.h │ │ ├── GetInteractions.h │ │ ├── GetRoles.h │ │ ├── Interaction.h │ │ ├── InteractiveClient.h │ │ ├── InteractiveClients.h │ │ ├── Pair.h │ │ ├── Pairing.h │ │ ├── RemoconStatus.h │ │ ├── RequestInteraction.h │ │ ├── SetInteractions.h │ │ └── Strings.h │ ├── rocon_service_pair_msgs │ │ ├── TestiesPair.h │ │ ├── TestiesPairRequest.h │ │ ├── TestiesPairResponse.h │ │ ├── TestiesRequest.h │ │ └── TestiesResponse.h │ ├── rocon_std_msgs │ │ ├── Connection.h │ │ ├── GetPlatformInfo.h │ │ ├── Icon.h │ │ ├── KeyValue.h │ │ ├── MasterInfo.h │ │ ├── PlatformInfo.h │ │ ├── Remapping.h │ │ ├── StringArray.h │ │ ├── Strings.h │ │ ├── StringsPair.h │ │ ├── StringsPairRequest.h │ │ ├── StringsPairResponse.h │ │ ├── StringsRequest.h │ │ └── StringsResponse.h │ ├── ros.h │ ├── ros │ │ ├── duration.h │ │ ├── msg.h │ │ ├── node_handle.h │ │ ├── publisher.h │ │ ├── service_client.h │ │ ├── service_server.h │ │ ├── subscriber.h │ │ └── time.h │ ├── rosapi │ │ ├── DeleteParam.h │ │ ├── GetParam.h │ │ ├── GetParamNames.h │ │ ├── GetTime.h │ │ ├── HasParam.h │ │ ├── MessageDetails.h │ │ ├── Nodes.h │ │ ├── Publishers.h │ │ ├── SearchParam.h │ │ ├── ServiceHost.h │ │ ├── ServiceNode.h │ │ ├── ServiceProviders.h │ │ ├── ServiceRequestDetails.h │ │ ├── ServiceResponseDetails.h │ │ ├── ServiceType.h │ │ ├── Services.h │ │ ├── ServicesForType.h │ │ ├── SetParam.h │ │ ├── Subscribers.h │ │ ├── TopicType.h │ │ ├── Topics.h │ │ ├── TopicsForType.h │ │ └── TypeDef.h │ ├── rosauth │ │ └── Authentication.h │ ├── roscpp │ │ ├── Empty.h │ │ ├── GetLoggers.h │ │ ├── Logger.h │ │ └── SetLoggerLevel.h │ ├── roscpp_tutorials │ │ └── TwoInts.h │ ├── rosgraph_msgs │ │ ├── Clock.h │ │ ├── Log.h │ │ └── TopicStatistics.h │ ├── rospy_tutorials │ │ ├── AddTwoInts.h │ │ ├── BadTwoInts.h │ │ ├── Floats.h │ │ └── HeaderString.h │ ├── rosserial_arduino │ │ ├── Adc.h │ │ └── Test.h │ ├── rosserial_msgs │ │ ├── Log.h │ │ ├── RequestMessageInfo.h │ │ ├── RequestParam.h │ │ ├── RequestServiceInfo.h │ │ └── TopicInfo.h │ ├── scheduler_msgs │ │ ├── CurrentStatus.h │ │ ├── KnownResources.h │ │ ├── Request.h │ │ ├── Resource.h │ │ └── SchedulerRequests.h │ ├── sensor_msgs │ │ ├── BatteryState.h │ │ ├── CameraInfo.h │ │ ├── ChannelFloat32.h │ │ ├── CompressedImage.h │ │ ├── FluidPressure.h │ │ ├── Illuminance.h │ │ ├── Image.h │ │ ├── Imu.h │ │ ├── JointState.h │ │ ├── Joy.h │ │ ├── JoyFeedback.h │ │ ├── JoyFeedbackArray.h │ │ ├── LaserEcho.h │ │ ├── LaserScan.h │ │ ├── MagneticField.h │ │ ├── MultiDOFJointState.h │ │ ├── MultiEchoLaserScan.h │ │ ├── NavSatFix.h │ │ ├── NavSatStatus.h │ │ ├── PointCloud.h │ │ ├── PointCloud2.h │ │ ├── PointField.h │ │ ├── Range.h │ │ ├── RegionOfInterest.h │ │ ├── RelativeHumidity.h │ │ ├── SetCameraInfo.h │ │ ├── Temperature.h │ │ └── TimeReference.h │ ├── shape_msgs │ │ ├── Mesh.h │ │ ├── MeshTriangle.h │ │ ├── Plane.h │ │ └── SolidPrimitive.h │ ├── smach_msgs │ │ ├── SmachContainerInitialStatusCmd.h │ │ ├── SmachContainerStatus.h │ │ └── SmachContainerStructure.h │ ├── smart_battery_msgs │ │ └── SmartBatteryStatus.h │ ├── std_msgs │ │ ├── Bool.h │ │ ├── Byte.h │ │ ├── ByteMultiArray.h │ │ ├── Char.h │ │ ├── ColorRGBA.h │ │ ├── Duration.h │ │ ├── Empty.h │ │ ├── Float32.h │ │ ├── Float32MultiArray.h │ │ ├── Float64.h │ │ ├── Float64MultiArray.h │ │ ├── Header.h │ │ ├── Int16.h │ │ ├── Int16MultiArray.h │ │ ├── Int32.h │ │ ├── Int32MultiArray.h │ │ ├── Int64.h │ │ ├── Int64MultiArray.h │ │ ├── Int8.h │ │ ├── Int8MultiArray.h │ │ ├── MultiArrayDimension.h │ │ ├── MultiArrayLayout.h │ │ ├── String.h │ │ ├── Time.h │ │ ├── UInt16.h │ │ ├── UInt16MultiArray.h │ │ ├── UInt32.h │ │ ├── UInt32MultiArray.h │ │ ├── UInt64.h │ │ ├── UInt64MultiArray.h │ │ ├── UInt8.h │ │ └── UInt8MultiArray.h │ ├── std_srvs │ │ ├── Empty.h │ │ ├── SetBool.h │ │ └── Trigger.h │ ├── stdr_msgs │ │ ├── AddCO2Source.h │ │ ├── AddRfidTag.h │ │ ├── AddSoundSource.h │ │ ├── AddThermalSource.h │ │ ├── CO2SensorMeasurementMsg.h │ │ ├── CO2SensorMsg.h │ │ ├── CO2Source.h │ │ ├── CO2SourceVector.h │ │ ├── DeleteCO2Source.h │ │ ├── DeleteRfidTag.h │ │ ├── DeleteRobotAction.h │ │ ├── DeleteRobotActionFeedback.h │ │ ├── DeleteRobotActionGoal.h │ │ ├── DeleteRobotActionResult.h │ │ ├── DeleteRobotFeedback.h │ │ ├── DeleteRobotGoal.h │ │ ├── DeleteRobotResult.h │ │ ├── DeleteSoundSource.h │ │ ├── DeleteThermalSource.h │ │ ├── FootprintMsg.h │ │ ├── KinematicMsg.h │ │ ├── LaserSensorMsg.h │ │ ├── LoadExternalMap.h │ │ ├── LoadMap.h │ │ ├── MoveRobot.h │ │ ├── Noise.h │ │ ├── RegisterGui.h │ │ ├── RegisterRobotAction.h │ │ ├── RegisterRobotActionFeedback.h │ │ ├── RegisterRobotActionGoal.h │ │ ├── RegisterRobotActionResult.h │ │ ├── RegisterRobotFeedback.h │ │ ├── RegisterRobotGoal.h │ │ ├── RegisterRobotResult.h │ │ ├── RfidSensorMeasurementMsg.h │ │ ├── RfidSensorMsg.h │ │ ├── RfidTag.h │ │ ├── RfidTagVector.h │ │ ├── RobotIndexedMsg.h │ │ ├── RobotIndexedVectorMsg.h │ │ ├── RobotMsg.h │ │ ├── SonarSensorMsg.h │ │ ├── SoundSensorMeasurementMsg.h │ │ ├── SoundSensorMsg.h │ │ ├── SoundSource.h │ │ ├── SoundSourceVector.h │ │ ├── SpawnRobotAction.h │ │ ├── SpawnRobotActionFeedback.h │ │ ├── SpawnRobotActionGoal.h │ │ ├── SpawnRobotActionResult.h │ │ ├── SpawnRobotFeedback.h │ │ ├── SpawnRobotGoal.h │ │ ├── SpawnRobotResult.h │ │ ├── ThermalSensorMeasurementMsg.h │ │ ├── ThermalSensorMsg.h │ │ ├── ThermalSource.h │ │ └── ThermalSourceVector.h │ ├── stereo_msgs │ │ └── DisparityImage.h │ ├── tests │ │ ├── array_test │ │ │ └── array_test.pde │ │ ├── float64_test │ │ │ └── float64_test.pde │ │ └── time_test │ │ │ └── time_test.pde │ ├── tf │ │ ├── FrameGraph.h │ │ ├── tf.h │ │ ├── tfMessage.h │ │ └── transform_broadcaster.h │ ├── tf2_msgs │ │ ├── FrameGraph.h │ │ ├── LookupTransformAction.h │ │ ├── LookupTransformActionFeedback.h │ │ ├── LookupTransformActionGoal.h │ │ ├── LookupTransformActionResult.h │ │ ├── LookupTransformFeedback.h │ │ ├── LookupTransformGoal.h │ │ ├── LookupTransformResult.h │ │ ├── TF2Error.h │ │ └── TFMessage.h │ ├── theora_image_transport │ │ └── Packet.h │ ├── time.cpp │ ├── topic_tools │ │ ├── DemuxAdd.h │ │ ├── DemuxDelete.h │ │ ├── DemuxList.h │ │ ├── DemuxSelect.h │ │ ├── MuxAdd.h │ │ ├── MuxDelete.h │ │ ├── MuxList.h │ │ └── MuxSelect.h │ ├── trajectory_msgs │ │ ├── JointTrajectory.h │ │ ├── JointTrajectoryPoint.h │ │ ├── MultiDOFJointTrajectory.h │ │ └── MultiDOFJointTrajectoryPoint.h │ ├── turtle_actionlib │ │ ├── ShapeAction.h │ │ ├── ShapeActionFeedback.h │ │ ├── ShapeActionGoal.h │ │ ├── ShapeActionResult.h │ │ ├── ShapeFeedback.h │ │ ├── ShapeGoal.h │ │ ├── ShapeResult.h │ │ └── Velocity.h │ ├── turtlebot_actions │ │ ├── FindFiducialAction.h │ │ ├── FindFiducialActionFeedback.h │ │ ├── FindFiducialActionGoal.h │ │ ├── FindFiducialActionResult.h │ │ ├── FindFiducialFeedback.h │ │ ├── FindFiducialGoal.h │ │ ├── FindFiducialResult.h │ │ ├── TurtlebotMoveAction.h │ │ ├── TurtlebotMoveActionFeedback.h │ │ ├── TurtlebotMoveActionGoal.h │ │ ├── TurtlebotMoveActionResult.h │ │ ├── TurtlebotMoveFeedback.h │ │ ├── TurtlebotMoveGoal.h │ │ └── TurtlebotMoveResult.h │ ├── turtlebot_calibration │ │ └── ScanAngle.h │ ├── turtlebot_msgs │ │ ├── PanoramaImg.h │ │ ├── SetFollowState.h │ │ └── TakePanorama.h │ ├── turtlesim │ │ ├── Color.h │ │ ├── Kill.h │ │ ├── Pose.h │ │ ├── SetPen.h │ │ ├── Spawn.h │ │ ├── TeleportAbsolute.h │ │ └── TeleportRelative.h │ ├── uuid_msgs │ │ └── UniqueID.h │ ├── visualization_msgs │ │ ├── ImageMarker.h │ │ ├── InteractiveMarker.h │ │ ├── InteractiveMarkerControl.h │ │ ├── InteractiveMarkerFeedback.h │ │ ├── InteractiveMarkerInit.h │ │ ├── InteractiveMarkerPose.h │ │ ├── InteractiveMarkerUpdate.h │ │ ├── Marker.h │ │ ├── MarkerArray.h │ │ └── MenuEntry.h │ ├── world_canvas_msgs │ │ ├── Annotation.h │ │ ├── AnnotationData.h │ │ ├── Annotations.h │ │ ├── DeleteAnnotations.h │ │ ├── DeleteMap.h │ │ ├── EditAnnotationsData.h │ │ ├── GetAnnotations.h │ │ ├── GetAnnotationsData.h │ │ ├── ListMaps.h │ │ ├── ListWorlds.h │ │ ├── MapListEntry.h │ │ ├── PubAnnotationsData.h │ │ ├── PublishMap.h │ │ ├── RenameMap.h │ │ ├── ResetDatabase.h │ │ ├── SaveAnnotationsData.h │ │ ├── SaveMap.h │ │ ├── SetKeyword.h │ │ ├── SetRelationship.h │ │ ├── WorldCanvas.h │ │ ├── YAMLExport.h │ │ └── YAMLImport.h │ ├── yocs_msgs │ │ ├── ARPair.h │ │ ├── ARPairList.h │ │ ├── Column.h │ │ ├── ColumnList.h │ │ ├── DockingInteractorAction.h │ │ ├── DockingInteractorActionFeedback.h │ │ ├── DockingInteractorActionGoal.h │ │ ├── DockingInteractorActionResult.h │ │ ├── DockingInteractorFeedback.h │ │ ├── DockingInteractorGoal.h │ │ ├── DockingInteractorResult.h │ │ ├── LocalizeAction.h │ │ ├── LocalizeActionFeedback.h │ │ ├── LocalizeActionGoal.h │ │ ├── LocalizeActionResult.h │ │ ├── LocalizeFeedback.h │ │ ├── LocalizeGoal.h │ │ ├── LocalizeResult.h │ │ ├── NavigateToAction.h │ │ ├── NavigateToActionFeedback.h │ │ ├── NavigateToActionGoal.h │ │ ├── NavigateToActionResult.h │ │ ├── NavigateToFeedback.h │ │ ├── NavigateToGoal.h │ │ ├── NavigateToResult.h │ │ ├── NavigationControl.h │ │ ├── NavigationControlStatus.h │ │ ├── Table.h │ │ ├── TableList.h │ │ ├── Trajectory.h │ │ ├── TrajectoryList.h │ │ ├── Wall.h │ │ ├── WallList.h │ │ ├── Waypoint.h │ │ ├── WaypointList.h │ │ └── WaypointListService.h │ └── zeroconf_msgs │ │ ├── AddListener.h │ │ ├── AddService.h │ │ ├── DiscoveredService.h │ │ ├── ListDiscoveredServices.h │ │ ├── ListPublishedServices.h │ │ ├── Protocols.h │ │ ├── PublishedService.h │ │ ├── RemoveListener.h │ │ └── RemoveService.h ├── rosserial_firebird.ino.hex └── rosserial_firebird │ ├── LCD.c │ ├── firebird.c │ └── rosserial_firebird.ino ├── launch └── firebird.launch ├── msg ├── Aux.msg ├── Battery.msg ├── IR.msg ├── Lcd.msg ├── Sensor.msg ├── Sharp.msg └── WLS.msg ├── package.xml └── scripts └── firebird_test.py /embedded/avrdude_script.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | OPTIONS=$(getopt -o hf:gb -l help,file:,foo,bar -- "$@") 4 | 5 | if [ $? -ne 0 ]; then 6 | echo "getopt error" 7 | exit 1 8 | fi 9 | 10 | eval set -- $OPTIONS 11 | 12 | while true; do 13 | case "$1" in 14 | -h|--help) HELP=1 ;; 15 | -f|--file) FILE="$2" ; shift ;; 16 | -g|--foo) FOO=1 ;; 17 | -b|--bar) BAR=1 ;; 18 | --) shift ; break ;; 19 | *) echo "unknown option: $1" ; exit 1 ;; 20 | esac 21 | shift 22 | done 23 | 24 | if [ $# -ne 0 ]; then 25 | echo "unknown option(s): $@" 26 | exit 1 27 | fi 28 | 29 | 30 | echo "help: $HELP" 31 | echo "file: $FILE" 32 | 33 | avrdude -c stk500v2 -p m2560 -P /dev/ttyACM0 -U flash:w:$FILE:i 34 | #avrdude -c stk500v2 -p m640 -P /dev/ttyACM0 -U flash:w:$FILE:i 35 | -------------------------------------------------------------------------------- /embedded/ros_lib/actionlib/TestActionGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_actionlib_TestActionGoal_h 2 | #define _ROS_actionlib_TestActionGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalID.h" 10 | #include "actionlib/TestGoal.h" 11 | 12 | namespace actionlib 13 | { 14 | 15 | class TestActionGoal : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalID goal_id; 20 | actionlib::TestGoal goal; 21 | 22 | TestActionGoal(): 23 | header(), 24 | goal_id(), 25 | goal() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->goal_id.serialize(outbuffer + offset); 34 | offset += this->goal.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->goal_id.deserialize(inbuffer + offset); 43 | offset += this->goal.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "actionlib/TestActionGoal"; }; 48 | const char * getMD5(){ return "348369c5b403676156094e8c159720bf"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/actionlib/TestActionResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_actionlib_TestActionResult_h 2 | #define _ROS_actionlib_TestActionResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalStatus.h" 10 | #include "actionlib/TestResult.h" 11 | 12 | namespace actionlib 13 | { 14 | 15 | class TestActionResult : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalStatus status; 20 | actionlib::TestResult result; 21 | 22 | TestActionResult(): 23 | header(), 24 | status(), 25 | result() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->status.serialize(outbuffer + offset); 34 | offset += this->result.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->status.deserialize(inbuffer + offset); 43 | offset += this->result.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "actionlib/TestActionResult"; }; 48 | const char * getMD5(){ return "3d669e3a63aa986c667ea7b0f46ce85e"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/actionlib/TestRequestFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_actionlib_TestRequestFeedback_h 2 | #define _ROS_actionlib_TestRequestFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace actionlib 10 | { 11 | 12 | class TestRequestFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | TestRequestFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "actionlib/TestRequestFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/actionlib/TwoIntsActionGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_actionlib_TwoIntsActionGoal_h 2 | #define _ROS_actionlib_TwoIntsActionGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalID.h" 10 | #include "actionlib/TwoIntsGoal.h" 11 | 12 | namespace actionlib 13 | { 14 | 15 | class TwoIntsActionGoal : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalID goal_id; 20 | actionlib::TwoIntsGoal goal; 21 | 22 | TwoIntsActionGoal(): 23 | header(), 24 | goal_id(), 25 | goal() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->goal_id.serialize(outbuffer + offset); 34 | offset += this->goal.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->goal_id.deserialize(inbuffer + offset); 43 | offset += this->goal.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "actionlib/TwoIntsActionGoal"; }; 48 | const char * getMD5(){ return "684a2db55d6ffb8046fb9d6764ce0860"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/actionlib/TwoIntsFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_actionlib_TwoIntsFeedback_h 2 | #define _ROS_actionlib_TwoIntsFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace actionlib 10 | { 11 | 12 | class TwoIntsFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | TwoIntsFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "actionlib/TwoIntsFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/arbotix_msgs/Analog.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_arbotix_msgs_Analog_h 2 | #define _ROS_arbotix_msgs_Analog_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | 10 | namespace arbotix_msgs 11 | { 12 | 13 | class Analog : public ros::Msg 14 | { 15 | public: 16 | std_msgs::Header header; 17 | uint8_t value; 18 | 19 | Analog(): 20 | header(), 21 | value(0) 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->header.serialize(outbuffer + offset); 29 | *(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF; 30 | offset += sizeof(this->value); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | this->value = ((uint8_t) (*(inbuffer + offset))); 39 | offset += sizeof(this->value); 40 | return offset; 41 | } 42 | 43 | const char * getType(){ return "arbotix_msgs/Analog"; }; 44 | const char * getMD5(){ return "90539346f3c3c8fc47f159ab9a6ff208"; }; 45 | 46 | }; 47 | 48 | } 49 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/arbotix_msgs/Relax.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_SERVICE_Relax_h 2 | #define _ROS_SERVICE_Relax_h 3 | #include 4 | #include 5 | #include 6 | #include "ros/msg.h" 7 | 8 | namespace arbotix_msgs 9 | { 10 | 11 | static const char RELAX[] = "arbotix_msgs/Relax"; 12 | 13 | class RelaxRequest : public ros::Msg 14 | { 15 | public: 16 | 17 | RelaxRequest() 18 | { 19 | } 20 | 21 | virtual int serialize(unsigned char *outbuffer) const 22 | { 23 | int offset = 0; 24 | return offset; 25 | } 26 | 27 | virtual int deserialize(unsigned char *inbuffer) 28 | { 29 | int offset = 0; 30 | return offset; 31 | } 32 | 33 | const char * getType(){ return RELAX; }; 34 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 35 | 36 | }; 37 | 38 | class RelaxResponse : public ros::Msg 39 | { 40 | public: 41 | 42 | RelaxResponse() 43 | { 44 | } 45 | 46 | virtual int serialize(unsigned char *outbuffer) const 47 | { 48 | int offset = 0; 49 | return offset; 50 | } 51 | 52 | virtual int deserialize(unsigned char *inbuffer) 53 | { 54 | int offset = 0; 55 | return offset; 56 | } 57 | 58 | const char * getType(){ return RELAX; }; 59 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 60 | 61 | }; 62 | 63 | class Relax { 64 | public: 65 | typedef RelaxRequest Request; 66 | typedef RelaxResponse Response; 67 | }; 68 | 69 | } 70 | #endif 71 | -------------------------------------------------------------------------------- /embedded/ros_lib/bond/Constants.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_bond_Constants_h 2 | #define _ROS_bond_Constants_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace bond 10 | { 11 | 12 | class Constants : public ros::Msg 13 | { 14 | public: 15 | enum { DEAD_PUBLISH_PERIOD = 0.05 }; 16 | enum { DEFAULT_CONNECT_TIMEOUT = 10.0 }; 17 | enum { DEFAULT_HEARTBEAT_TIMEOUT = 4.0 }; 18 | enum { DEFAULT_DISCONNECT_TIMEOUT = 2.0 }; 19 | enum { DEFAULT_HEARTBEAT_PERIOD = 1.0 }; 20 | enum { DISABLE_HEARTBEAT_TIMEOUT_PARAM = /bond_disable_heartbeat_timeout }; 21 | 22 | Constants() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | return offset; 36 | } 37 | 38 | const char * getType(){ return "bond/Constants"; }; 39 | const char * getMD5(){ return "6fc594dc1d7bd7919077042712f8c8b0"; }; 40 | 41 | }; 42 | 43 | } 44 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_msgs/ConcertClientState.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_msgs_ConcertClientState_h 2 | #define _ROS_concert_msgs_ConcertClientState_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace concert_msgs 10 | { 11 | 12 | class ConcertClientState : public ros::Msg 13 | { 14 | public: 15 | enum { PENDING = pending }; 16 | enum { BAD = bad }; 17 | enum { BLOCKING = blocking }; 18 | enum { BUSY = busy }; 19 | enum { UNINVITED = uninvited }; 20 | enum { JOINING = joining }; 21 | enum { AVAILABLE = available }; 22 | enum { MISSING = missing }; 23 | enum { GONE = gone }; 24 | 25 | ConcertClientState() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "concert_msgs/ConcertClientState"; }; 42 | const char * getMD5(){ return "216b7a80921438395a695bb265efcaf1"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_msgs/ErrorCodes.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_msgs_ErrorCodes_h 2 | #define _ROS_concert_msgs_ErrorCodes_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace concert_msgs 10 | { 11 | 12 | class ErrorCodes : public ros::Msg 13 | { 14 | public: 15 | enum { SUCCESS = 0 }; 16 | enum { SERVICE_UNEXPECTED_ERROR = 31 }; 17 | enum { SERVICE_INSUFFICIENT_CLIENTS = 32 }; 18 | enum { SERVICE_NOT_READY = 33 }; 19 | 20 | ErrorCodes() 21 | { 22 | } 23 | 24 | virtual int serialize(unsigned char *outbuffer) const 25 | { 26 | int offset = 0; 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | return offset; 34 | } 35 | 36 | const char * getType(){ return "concert_msgs/ErrorCodes"; }; 37 | const char * getMD5(){ return "850c35c6305cee69bf981dadb8ebd51c"; }; 38 | 39 | }; 40 | 41 | } 42 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_msgs/Strings.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_msgs_Strings_h 2 | #define _ROS_concert_msgs_Strings_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace concert_msgs 10 | { 11 | 12 | class Strings : public ros::Msg 13 | { 14 | public: 15 | enum { PARAM_ROCON_SCREEN = /rocon/screen }; 16 | enum { SCHEDULER_UNALLOCATED_RESOURCE = unallocated }; 17 | enum { CONCERT_CLIENTS = /concert/conductor/concert_clients }; 18 | enum { SERVICE_NAMESPACE = /services }; 19 | enum { SOFTWARE_NAMESPACE = /software }; 20 | 21 | Strings() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | return offset; 29 | } 30 | 31 | virtual int deserialize(unsigned char *inbuffer) 32 | { 33 | int offset = 0; 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "concert_msgs/Strings"; }; 38 | const char * getMD5(){ return "38136d22fdc4ea7e6dd26ec382e266c8"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/CaptureResourcePair.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_CaptureResourcePair_h 2 | #define _ROS_concert_service_msgs_CaptureResourcePair_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "concert_service_msgs/CaptureResourcePairRequest.h" 9 | #include "concert_service_msgs/CaptureResourcePairResponse.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class CaptureResourcePair : public ros::Msg 15 | { 16 | public: 17 | concert_service_msgs::CaptureResourcePairRequest pair_request; 18 | concert_service_msgs::CaptureResourcePairResponse pair_response; 19 | 20 | CaptureResourcePair(): 21 | pair_request(), 22 | pair_response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->pair_request.serialize(outbuffer + offset); 30 | offset += this->pair_response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->pair_request.deserialize(inbuffer + offset); 38 | offset += this->pair_response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/CaptureResourcePair"; }; 43 | const char * getMD5(){ return "119d2731866ad230a6fd7e87d8a22b1f"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/CaptureResourcePairRequest.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_CaptureResourcePairRequest_h 2 | #define _ROS_concert_service_msgs_CaptureResourcePairRequest_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "concert_service_msgs/CaptureResourceRequest.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class CaptureResourcePairRequest : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | concert_service_msgs::CaptureResourceRequest request; 19 | 20 | CaptureResourcePairRequest(): 21 | id(), 22 | request() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->request.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->request.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/CaptureResourcePairRequest"; }; 43 | const char * getMD5(){ return "70e7b6a649a463eaffc6444527dec77e"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/CaptureResourcePairResponse.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_CaptureResourcePairResponse_h 2 | #define _ROS_concert_service_msgs_CaptureResourcePairResponse_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "concert_service_msgs/CaptureResourceResponse.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class CaptureResourcePairResponse : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | concert_service_msgs::CaptureResourceResponse response; 19 | 20 | CaptureResourcePairResponse(): 21 | id(), 22 | response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/CaptureResourcePairResponse"; }; 43 | const char * getMD5(){ return "173d52f12f1f234789c59ba574370e5b"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/KillTurtlePair.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_KillTurtlePair_h 2 | #define _ROS_concert_service_msgs_KillTurtlePair_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "concert_service_msgs/KillTurtlePairRequest.h" 9 | #include "concert_service_msgs/KillTurtlePairResponse.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class KillTurtlePair : public ros::Msg 15 | { 16 | public: 17 | concert_service_msgs::KillTurtlePairRequest pair_request; 18 | concert_service_msgs::KillTurtlePairResponse pair_response; 19 | 20 | KillTurtlePair(): 21 | pair_request(), 22 | pair_response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->pair_request.serialize(outbuffer + offset); 30 | offset += this->pair_response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->pair_request.deserialize(inbuffer + offset); 38 | offset += this->pair_response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/KillTurtlePair"; }; 43 | const char * getMD5(){ return "d7f05d5e41a7cb8b3cbf2ace791fdbe4"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/KillTurtlePairRequest.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_KillTurtlePairRequest_h 2 | #define _ROS_concert_service_msgs_KillTurtlePairRequest_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "concert_service_msgs/KillTurtleRequest.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class KillTurtlePairRequest : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | concert_service_msgs::KillTurtleRequest request; 19 | 20 | KillTurtlePairRequest(): 21 | id(), 22 | request() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->request.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->request.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/KillTurtlePairRequest"; }; 43 | const char * getMD5(){ return "0f974aecea7bf5add789608093b710e2"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/KillTurtlePairResponse.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_KillTurtlePairResponse_h 2 | #define _ROS_concert_service_msgs_KillTurtlePairResponse_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "concert_service_msgs/KillTurtleResponse.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class KillTurtlePairResponse : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | concert_service_msgs::KillTurtleResponse response; 19 | 20 | KillTurtlePairResponse(): 21 | id(), 22 | response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/KillTurtlePairResponse"; }; 43 | const char * getMD5(){ return "2d12e3db65db9ae3b7de64597c1f0f15"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/KillTurtleResponse.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_KillTurtleResponse_h 2 | #define _ROS_concert_service_msgs_KillTurtleResponse_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace concert_service_msgs 10 | { 11 | 12 | class KillTurtleResponse : public ros::Msg 13 | { 14 | public: 15 | 16 | KillTurtleResponse() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "concert_service_msgs/KillTurtleResponse"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/SpawnTurtlePair.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_SpawnTurtlePair_h 2 | #define _ROS_concert_service_msgs_SpawnTurtlePair_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "concert_service_msgs/SpawnTurtlePairRequest.h" 9 | #include "concert_service_msgs/SpawnTurtlePairResponse.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class SpawnTurtlePair : public ros::Msg 15 | { 16 | public: 17 | concert_service_msgs::SpawnTurtlePairRequest pair_request; 18 | concert_service_msgs::SpawnTurtlePairResponse pair_response; 19 | 20 | SpawnTurtlePair(): 21 | pair_request(), 22 | pair_response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->pair_request.serialize(outbuffer + offset); 30 | offset += this->pair_response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->pair_request.deserialize(inbuffer + offset); 38 | offset += this->pair_response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/SpawnTurtlePair"; }; 43 | const char * getMD5(){ return "d40647d6460ee3e522a284534a00ec9f"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/SpawnTurtlePairRequest.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_SpawnTurtlePairRequest_h 2 | #define _ROS_concert_service_msgs_SpawnTurtlePairRequest_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "concert_service_msgs/SpawnTurtleRequest.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class SpawnTurtlePairRequest : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | concert_service_msgs::SpawnTurtleRequest request; 19 | 20 | SpawnTurtlePairRequest(): 21 | id(), 22 | request() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->request.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->request.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/SpawnTurtlePairRequest"; }; 43 | const char * getMD5(){ return "0f974aecea7bf5add789608093b710e2"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/concert_service_msgs/SpawnTurtlePairResponse.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_concert_service_msgs_SpawnTurtlePairResponse_h 2 | #define _ROS_concert_service_msgs_SpawnTurtlePairResponse_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "concert_service_msgs/SpawnTurtleResponse.h" 10 | 11 | namespace concert_service_msgs 12 | { 13 | 14 | class SpawnTurtlePairResponse : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | concert_service_msgs::SpawnTurtleResponse response; 19 | 20 | SpawnTurtlePairResponse(): 21 | id(), 22 | response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "concert_service_msgs/SpawnTurtlePairResponse"; }; 43 | const char * getMD5(){ return "d5742d0ce5f2bef0a88989c31cd56f59"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/GripperCommand.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_GripperCommand_h 2 | #define _ROS_control_msgs_GripperCommand_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace control_msgs 10 | { 11 | 12 | class GripperCommand : public ros::Msg 13 | { 14 | public: 15 | float position; 16 | float max_effort; 17 | 18 | GripperCommand(): 19 | position(0), 20 | max_effort(0) 21 | { 22 | } 23 | 24 | virtual int serialize(unsigned char *outbuffer) const 25 | { 26 | int offset = 0; 27 | offset += serializeAvrFloat64(outbuffer + offset, this->position); 28 | offset += serializeAvrFloat64(outbuffer + offset, this->max_effort); 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->position)); 36 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->max_effort)); 37 | return offset; 38 | } 39 | 40 | const char * getType(){ return "control_msgs/GripperCommand"; }; 41 | const char * getMD5(){ return "680acaff79486f017132a7f198d40f08"; }; 42 | 43 | }; 44 | 45 | } 46 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/GripperCommandGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_GripperCommandGoal_h 2 | #define _ROS_control_msgs_GripperCommandGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "control_msgs/GripperCommand.h" 9 | 10 | namespace control_msgs 11 | { 12 | 13 | class GripperCommandGoal : public ros::Msg 14 | { 15 | public: 16 | control_msgs::GripperCommand command; 17 | 18 | GripperCommandGoal(): 19 | command() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->command.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->command.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "control_msgs/GripperCommandGoal"; }; 38 | const char * getMD5(){ return "86fd82f4ddc48a4cb6856cfa69217e43"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/JointTrajectoryFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_JointTrajectoryFeedback_h 2 | #define _ROS_control_msgs_JointTrajectoryFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace control_msgs 10 | { 11 | 12 | class JointTrajectoryFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | JointTrajectoryFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "control_msgs/JointTrajectoryFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/JointTrajectoryGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_JointTrajectoryGoal_h 2 | #define _ROS_control_msgs_JointTrajectoryGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "trajectory_msgs/JointTrajectory.h" 9 | 10 | namespace control_msgs 11 | { 12 | 13 | class JointTrajectoryGoal : public ros::Msg 14 | { 15 | public: 16 | trajectory_msgs::JointTrajectory trajectory; 17 | 18 | JointTrajectoryGoal(): 19 | trajectory() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->trajectory.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->trajectory.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "control_msgs/JointTrajectoryGoal"; }; 38 | const char * getMD5(){ return "2a0eff76c870e8595636c2a562ca298e"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/JointTrajectoryResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_JointTrajectoryResult_h 2 | #define _ROS_control_msgs_JointTrajectoryResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace control_msgs 10 | { 11 | 12 | class JointTrajectoryResult : public ros::Msg 13 | { 14 | public: 15 | 16 | JointTrajectoryResult() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "control_msgs/JointTrajectoryResult"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/PointHeadFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_PointHeadFeedback_h 2 | #define _ROS_control_msgs_PointHeadFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace control_msgs 10 | { 11 | 12 | class PointHeadFeedback : public ros::Msg 13 | { 14 | public: 15 | float pointing_angle_error; 16 | 17 | PointHeadFeedback(): 18 | pointing_angle_error(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | offset += serializeAvrFloat64(outbuffer + offset, this->pointing_angle_error); 26 | return offset; 27 | } 28 | 29 | virtual int deserialize(unsigned char *inbuffer) 30 | { 31 | int offset = 0; 32 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->pointing_angle_error)); 33 | return offset; 34 | } 35 | 36 | const char * getType(){ return "control_msgs/PointHeadFeedback"; }; 37 | const char * getMD5(){ return "cce80d27fd763682da8805a73316cab4"; }; 38 | 39 | }; 40 | 41 | } 42 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/PointHeadResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_PointHeadResult_h 2 | #define _ROS_control_msgs_PointHeadResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace control_msgs 10 | { 11 | 12 | class PointHeadResult : public ros::Msg 13 | { 14 | public: 15 | 16 | PointHeadResult() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "control_msgs/PointHeadResult"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/control_msgs/SingleJointPositionResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_control_msgs_SingleJointPositionResult_h 2 | #define _ROS_control_msgs_SingleJointPositionResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace control_msgs 10 | { 11 | 12 | class SingleJointPositionResult : public ros::Msg 13 | { 14 | public: 15 | 16 | SingleJointPositionResult() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "control_msgs/SingleJointPositionResult"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/driver_base/SensorLevels.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_driver_base_SensorLevels_h 2 | #define _ROS_driver_base_SensorLevels_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace driver_base 10 | { 11 | 12 | class SensorLevels : public ros::Msg 13 | { 14 | public: 15 | enum { RECONFIGURE_CLOSE = 3 }; 16 | enum { RECONFIGURE_STOP = 1 }; 17 | enum { RECONFIGURE_RUNNING = 0 }; 18 | 19 | SensorLevels() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | return offset; 27 | } 28 | 29 | virtual int deserialize(unsigned char *inbuffer) 30 | { 31 | int offset = 0; 32 | return offset; 33 | } 34 | 35 | const char * getType(){ return "driver_base/SensorLevels"; }; 36 | const char * getMD5(){ return "6322637bee96d5489db6e2127c47602c"; }; 37 | 38 | }; 39 | 40 | } 41 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/dynamic_reconfigure/SensorLevels.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_dynamic_reconfigure_SensorLevels_h 2 | #define _ROS_dynamic_reconfigure_SensorLevels_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace dynamic_reconfigure 10 | { 11 | 12 | class SensorLevels : public ros::Msg 13 | { 14 | public: 15 | enum { RECONFIGURE_CLOSE = 3 }; 16 | enum { RECONFIGURE_STOP = 1 }; 17 | enum { RECONFIGURE_RUNNING = 0 }; 18 | 19 | SensorLevels() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | return offset; 27 | } 28 | 29 | virtual int deserialize(unsigned char *inbuffer) 30 | { 31 | int offset = 0; 32 | return offset; 33 | } 34 | 35 | const char * getType(){ return "dynamic_reconfigure/SensorLevels"; }; 36 | const char * getMD5(){ return "6322637bee96d5489db6e2127c47602c"; }; 37 | 38 | }; 39 | 40 | } 41 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/examples/ADC/ADC.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial ADC Example 3 | * 4 | * This is a poor man's Oscilloscope. It does not have the sampling 5 | * rate or accuracy of a commerical scope, but it is great to get 6 | * an analog value into ROS in a pinch. 7 | */ 8 | 9 | #if (ARDUINO >= 100) 10 | #include 11 | #else 12 | #include 13 | #endif 14 | #include 15 | #include 16 | 17 | ros::NodeHandle nh; 18 | 19 | rosserial_arduino::Adc adc_msg; 20 | ros::Publisher p("adc", &adc_msg); 21 | 22 | void setup() 23 | { 24 | pinMode(13, OUTPUT); 25 | nh.initNode(); 26 | 27 | nh.advertise(p); 28 | } 29 | 30 | //We average the analog reading to elminate some of the noise 31 | int averageAnalog(int pin){ 32 | int v=0; 33 | for(int i=0; i<4; i++) v+= analogRead(pin); 34 | return v/4; 35 | } 36 | 37 | long adc_timer; 38 | 39 | void loop() 40 | { 41 | adc_msg.adc0 = averageAnalog(0); 42 | adc_msg.adc1 = averageAnalog(1); 43 | adc_msg.adc2 = averageAnalog(2); 44 | adc_msg.adc3 = averageAnalog(3); 45 | adc_msg.adc4 = averageAnalog(4); 46 | adc_msg.adc5 = averageAnalog(5); 47 | 48 | p.publish(&adc_msg); 49 | 50 | nh.spinOnce(); 51 | } 52 | 53 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/Blink/Blink.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Subscriber Example 3 | * Blinks an LED on callback 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | ros::NodeHandle nh; 10 | 11 | void messageCb( const std_msgs::Empty& toggle_msg){ 12 | digitalWrite(13, HIGH-digitalRead(13)); // blink the led 13 | } 14 | 15 | ros::Subscriber sub("toggle_led", &messageCb ); 16 | 17 | void setup() 18 | { 19 | pinMode(13, OUTPUT); 20 | nh.initNode(); 21 | nh.subscribe(sub); 22 | } 23 | 24 | void loop() 25 | { 26 | nh.spinOnce(); 27 | delay(1); 28 | } 29 | 30 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/HelloWorld/HelloWorld.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Publisher Example 3 | * Prints "hello world!" 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | ros::NodeHandle nh; 10 | 11 | std_msgs::String str_msg; 12 | ros::Publisher chatter("chatter", &str_msg); 13 | 14 | char hello[13] = "hello world!"; 15 | 16 | void setup() 17 | { 18 | nh.initNode(); 19 | nh.advertise(chatter); 20 | } 21 | 22 | void loop() 23 | { 24 | str_msg.data = hello; 25 | chatter.publish( &str_msg ); 26 | nh.spinOnce(); 27 | delay(1000); 28 | } 29 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/Logging/Logging.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial PubSub Example 3 | * Prints "hello world!" and toggles led 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | ros::NodeHandle nh; 11 | 12 | 13 | std_msgs::String str_msg; 14 | ros::Publisher chatter("chatter", &str_msg); 15 | 16 | char hello[13] = "hello world!"; 17 | 18 | 19 | char debug[]= "debug statements"; 20 | char info[] = "infos"; 21 | char warn[] = "warnings"; 22 | char error[] = "errors"; 23 | char fatal[] = "fatalities"; 24 | 25 | void setup() 26 | { 27 | pinMode(13, OUTPUT); 28 | nh.initNode(); 29 | nh.advertise(chatter); 30 | } 31 | 32 | void loop() 33 | { 34 | str_msg.data = hello; 35 | chatter.publish( &str_msg ); 36 | 37 | nh.logdebug(debug); 38 | nh.loginfo(info); 39 | nh.logwarn(warn); 40 | nh.logerror(error); 41 | nh.logfatal(fatal); 42 | 43 | nh.spinOnce(); 44 | delay(500); 45 | } 46 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/Odom/Odom.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Planar Odometry Example 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | ros::NodeHandle nh; 11 | 12 | geometry_msgs::TransformStamped t; 13 | tf::TransformBroadcaster broadcaster; 14 | 15 | double x = 1.0; 16 | double y = 0.0; 17 | double theta = 1.57; 18 | 19 | char base_link[] = "/base_link"; 20 | char odom[] = "/odom"; 21 | 22 | void setup() 23 | { 24 | nh.initNode(); 25 | broadcaster.init(nh); 26 | } 27 | 28 | void loop() 29 | { 30 | // drive in a circle 31 | double dx = 0.2; 32 | double dtheta = 0.18; 33 | x += cos(theta)*dx*0.1; 34 | y += sin(theta)*dx*0.1; 35 | theta += dtheta*0.1; 36 | if(theta > 3.14) 37 | theta=-3.14; 38 | 39 | // tf odom->base_link 40 | t.header.frame_id = odom; 41 | t.child_frame_id = base_link; 42 | 43 | t.transform.translation.x = x; 44 | t.transform.translation.y = y; 45 | 46 | t.transform.rotation = tf::createQuaternionFromYaw(theta); 47 | t.header.stamp = nh.now(); 48 | 49 | broadcaster.sendTransform(t); 50 | nh.spinOnce(); 51 | 52 | delay(10); 53 | } 54 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/ServiceClient/ServiceClient.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Service Client 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | ros::NodeHandle nh; 10 | using rosserial_arduino::Test; 11 | 12 | ros::ServiceClient client("test_srv"); 13 | 14 | std_msgs::String str_msg; 15 | ros::Publisher chatter("chatter", &str_msg); 16 | 17 | char hello[13] = "hello world!"; 18 | 19 | void setup() 20 | { 21 | nh.initNode(); 22 | nh.serviceClient(client); 23 | nh.advertise(chatter); 24 | while(!nh.connected()) nh.spinOnce(); 25 | nh.loginfo("Startup complete"); 26 | } 27 | 28 | void loop() 29 | { 30 | Test::Request req; 31 | Test::Response res; 32 | req.input = hello; 33 | client.call(req, res); 34 | str_msg.data = res.output; 35 | chatter.publish( &str_msg ); 36 | nh.spinOnce(); 37 | delay(100); 38 | } 39 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/ServiceClient/client.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | """ 4 | Sample code to use with ServiceClient.pde 5 | """ 6 | 7 | import roslib; roslib.load_manifest("rosserial_arduino") 8 | import rospy 9 | 10 | from rosserial_arduino.srv import * 11 | 12 | def callback(req): 13 | print "The arduino is calling! Please send it a message:" 14 | t = TestResponse() 15 | t.output = raw_input() 16 | return t 17 | 18 | rospy.init_node("service_client_test") 19 | rospy.Service("test_srv", Test, callback) 20 | rospy.spin() 21 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/ServiceServer/ServiceServer.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Service Server 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | ros::NodeHandle nh; 10 | using rosserial_arduino::Test; 11 | 12 | int i; 13 | void callback(const Test::Request & req, Test::Response & res){ 14 | if((i++)%2) 15 | res.output = "hello"; 16 | else 17 | res.output = "world"; 18 | } 19 | 20 | ros::ServiceServer server("test_srv",&callback); 21 | 22 | std_msgs::String str_msg; 23 | ros::Publisher chatter("chatter", &str_msg); 24 | 25 | char hello[13] = "hello world!"; 26 | 27 | void setup() 28 | { 29 | nh.initNode(); 30 | nh.advertiseService(server); 31 | nh.advertise(chatter); 32 | } 33 | 34 | void loop() 35 | { 36 | str_msg.data = hello; 37 | chatter.publish( &str_msg ); 38 | nh.spinOnce(); 39 | delay(10); 40 | } 41 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/ServoControl/ServoControl.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Servo Control Example 3 | * 4 | * This sketch demonstrates the control of hobby R/C servos 5 | * using ROS and the arduiono 6 | * 7 | * For the full tutorial write up, visit 8 | * www.ros.org/wiki/rosserial_arduino_demos 9 | * 10 | * For more information on the Arduino Servo Library 11 | * Checkout : 12 | * http://www.arduino.cc/en/Reference/Servo 13 | */ 14 | 15 | #if (ARDUINO >= 100) 16 | #include 17 | #else 18 | #include 19 | #endif 20 | 21 | #include 22 | #include 23 | #include 24 | 25 | ros::NodeHandle nh; 26 | 27 | Servo servo; 28 | 29 | void servo_cb( const std_msgs::UInt16& cmd_msg){ 30 | servo.write(cmd_msg.data); //set servo angle, should be from 0-180 31 | digitalWrite(13, HIGH-digitalRead(13)); //toggle led 32 | } 33 | 34 | 35 | ros::Subscriber sub("servo", servo_cb); 36 | 37 | void setup(){ 38 | pinMode(13, OUTPUT); 39 | 40 | nh.initNode(); 41 | nh.subscribe(sub); 42 | 43 | servo.attach(9); //attach it to pin 9 44 | } 45 | 46 | void loop(){ 47 | nh.spinOnce(); 48 | delay(1); 49 | } 50 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/TimeTF/TimeTF.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Time and TF Example 3 | * Publishes a transform at current time 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | ros::NodeHandle nh; 11 | 12 | geometry_msgs::TransformStamped t; 13 | tf::TransformBroadcaster broadcaster; 14 | 15 | char base_link[] = "/base_link"; 16 | char odom[] = "/odom"; 17 | 18 | void setup() 19 | { 20 | nh.initNode(); 21 | broadcaster.init(nh); 22 | } 23 | 24 | void loop() 25 | { 26 | t.header.frame_id = odom; 27 | t.child_frame_id = base_link; 28 | t.transform.translation.x = 1.0; 29 | t.transform.rotation.x = 0.0; 30 | t.transform.rotation.y = 0.0; 31 | t.transform.rotation.z = 0.0; 32 | t.transform.rotation.w = 1.0; 33 | t.header.stamp = nh.now(); 34 | broadcaster.sendTransform(t); 35 | nh.spinOnce(); 36 | delay(10); 37 | } 38 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/Ultrasound/Ultrasound.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial Ultrasound Example 3 | * 4 | * This example is for the Maxbotix Ultrasound rangers. 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | ros::NodeHandle nh; 12 | 13 | sensor_msgs::Range range_msg; 14 | ros::Publisher pub_range( "/ultrasound", &range_msg); 15 | 16 | const int adc_pin = 0; 17 | 18 | char frameid[] = "/ultrasound"; 19 | 20 | float getRange_Ultrasound(int pin_num){ 21 | int val = 0; 22 | for(int i=0; i<4; i++) val += analogRead(pin_num); 23 | float range = val; 24 | return range /322.519685; // (0.0124023437 /4) ; //cvt to meters 25 | } 26 | 27 | void setup() 28 | { 29 | nh.initNode(); 30 | nh.advertise(pub_range); 31 | 32 | 33 | range_msg.radiation_type = sensor_msgs::Range::ULTRASOUND; 34 | range_msg.header.frame_id = frameid; 35 | range_msg.field_of_view = 0.1; // fake 36 | range_msg.min_range = 0.0; 37 | range_msg.max_range = 6.47; 38 | 39 | pinMode(8,OUTPUT); 40 | digitalWrite(8, LOW); 41 | } 42 | 43 | 44 | long range_time; 45 | 46 | void loop() 47 | { 48 | 49 | //publish the adc value every 50 milliseconds 50 | //since it takes that long for the sensor to stablize 51 | if ( millis() >= range_time ){ 52 | int r =0; 53 | 54 | range_msg.range = getRange_Ultrasound(5); 55 | range_msg.header.stamp = nh.now(); 56 | pub_range.publish(&range_msg); 57 | range_time = millis() + 50; 58 | } 59 | 60 | nh.spinOnce(); 61 | } 62 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/button_example/button_example.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * Button Example for Rosserial 3 | */ 4 | 5 | #include 6 | #include 7 | 8 | 9 | ros::NodeHandle nh; 10 | 11 | std_msgs::Bool pushed_msg; 12 | ros::Publisher pub_button("pushed", &pushed_msg); 13 | 14 | const int button_pin = 7; 15 | const int led_pin = 13; 16 | 17 | bool last_reading; 18 | long last_debounce_time=0; 19 | long debounce_delay=50; 20 | bool published = true; 21 | 22 | void setup() 23 | { 24 | nh.initNode(); 25 | nh.advertise(pub_button); 26 | 27 | //initialize an LED output pin 28 | //and a input pin for our push button 29 | pinMode(led_pin, OUTPUT); 30 | pinMode(button_pin, INPUT); 31 | 32 | //Enable the pullup resistor on the button 33 | digitalWrite(button_pin, HIGH); 34 | 35 | //The button is a normally button 36 | last_reading = ! digitalRead(button_pin); 37 | 38 | } 39 | 40 | void loop() 41 | { 42 | 43 | bool reading = ! digitalRead(button_pin); 44 | 45 | if (last_reading!= reading){ 46 | last_debounce_time = millis(); 47 | published = false; 48 | } 49 | 50 | //if the button value has not changed for the debounce delay, we know its stable 51 | if ( !published && (millis() - last_debounce_time) > debounce_delay) { 52 | digitalWrite(led_pin, reading); 53 | pushed_msg.data = reading; 54 | pub_button.publish(&pushed_msg); 55 | published = true; 56 | } 57 | 58 | last_reading = reading; 59 | 60 | nh.spinOnce(); 61 | } 62 | -------------------------------------------------------------------------------- /embedded/ros_lib/examples/pubsub/pubsub.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial PubSub Example 3 | * Prints "hello world!" and toggles led 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | ros::NodeHandle nh; 11 | 12 | 13 | void messageCb( const std_msgs::Empty& toggle_msg){ 14 | digitalWrite(13, HIGH-digitalRead(13)); // blink the led 15 | } 16 | 17 | ros::Subscriber sub("toggle_led", messageCb ); 18 | 19 | 20 | 21 | std_msgs::String str_msg; 22 | ros::Publisher chatter("chatter", &str_msg); 23 | 24 | char hello[13] = "hello world!"; 25 | 26 | void setup() 27 | { 28 | pinMode(13, OUTPUT); 29 | nh.initNode(); 30 | nh.advertise(chatter); 31 | nh.subscribe(sub); 32 | } 33 | 34 | void loop() 35 | { 36 | str_msg.data = hello; 37 | chatter.publish( &str_msg ); 38 | nh.spinOnce(); 39 | delay(500); 40 | } 41 | -------------------------------------------------------------------------------- /embedded/ros_lib/firebird/Battery.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_firebird_Battery_h 2 | #define _ROS_firebird_Battery_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace firebird 10 | { 11 | 12 | class Battery : public ros::Msg 13 | { 14 | public: 15 | typedef uint16_t _bat_volt_type; 16 | _bat_volt_type bat_volt; 17 | 18 | Battery(): 19 | bat_volt(0) 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | *(outbuffer + offset + 0) = (this->bat_volt >> (8 * 0)) & 0xFF; 27 | *(outbuffer + offset + 1) = (this->bat_volt >> (8 * 1)) & 0xFF; 28 | offset += sizeof(this->bat_volt); 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | this->bat_volt = ((uint16_t) (*(inbuffer + offset))); 36 | this->bat_volt |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); 37 | offset += sizeof(this->bat_volt); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "firebird/Battery"; }; 42 | const char * getMD5(){ return "c6dd4d2dbec322eecca8a2d0d1fdf4d4"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/gateway_msgs/ConnectionType.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_gateway_msgs_ConnectionType_h 2 | #define _ROS_gateway_msgs_ConnectionType_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace gateway_msgs 10 | { 11 | 12 | class ConnectionType : public ros::Msg 13 | { 14 | public: 15 | enum { PUBLISHER = publisher }; 16 | enum { SUBSCRIBER = subscriber }; 17 | enum { SERVICE = service }; 18 | enum { ACTION_CLIENT = action_client }; 19 | enum { ACTION_SERVER = action_server }; 20 | enum { INVALID = invalid }; 21 | 22 | ConnectionType() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | return offset; 36 | } 37 | 38 | const char * getType(){ return "gateway_msgs/ConnectionType"; }; 39 | const char * getMD5(){ return "65d75f1bb32566bfec48966db2073c81"; }; 40 | 41 | }; 42 | 43 | } 44 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geographic_msgs/BoundingBox.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geographic_msgs_BoundingBox_h 2 | #define _ROS_geographic_msgs_BoundingBox_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geographic_msgs/GeoPoint.h" 9 | 10 | namespace geographic_msgs 11 | { 12 | 13 | class BoundingBox : public ros::Msg 14 | { 15 | public: 16 | geographic_msgs::GeoPoint min_pt; 17 | geographic_msgs::GeoPoint max_pt; 18 | 19 | BoundingBox(): 20 | min_pt(), 21 | max_pt() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->min_pt.serialize(outbuffer + offset); 29 | offset += this->max_pt.serialize(outbuffer + offset); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->min_pt.deserialize(inbuffer + offset); 37 | offset += this->max_pt.deserialize(inbuffer + offset); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "geographic_msgs/BoundingBox"; }; 42 | const char * getMD5(){ return "f62e8b5e390a3ac7603250d46e8f8446"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geographic_msgs/GeoPoint.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geographic_msgs_GeoPoint_h 2 | #define _ROS_geographic_msgs_GeoPoint_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace geographic_msgs 10 | { 11 | 12 | class GeoPoint : public ros::Msg 13 | { 14 | public: 15 | float latitude; 16 | float longitude; 17 | float altitude; 18 | 19 | GeoPoint(): 20 | latitude(0), 21 | longitude(0), 22 | altitude(0) 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += serializeAvrFloat64(outbuffer + offset, this->latitude); 30 | offset += serializeAvrFloat64(outbuffer + offset, this->longitude); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->altitude); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->latitude)); 39 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->longitude)); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->altitude)); 41 | return offset; 42 | } 43 | 44 | const char * getType(){ return "geographic_msgs/GeoPoint"; }; 45 | const char * getMD5(){ return "c48027a852aeff972be80478ff38e81a"; }; 46 | 47 | }; 48 | 49 | } 50 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geographic_msgs/GeoPose.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geographic_msgs_GeoPose_h 2 | #define _ROS_geographic_msgs_GeoPose_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geographic_msgs/GeoPoint.h" 9 | #include "geometry_msgs/Quaternion.h" 10 | 11 | namespace geographic_msgs 12 | { 13 | 14 | class GeoPose : public ros::Msg 15 | { 16 | public: 17 | geographic_msgs::GeoPoint position; 18 | geometry_msgs::Quaternion orientation; 19 | 20 | GeoPose(): 21 | position(), 22 | orientation() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->position.serialize(outbuffer + offset); 30 | offset += this->orientation.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->position.deserialize(inbuffer + offset); 38 | offset += this->orientation.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geographic_msgs/GeoPose"; }; 43 | const char * getMD5(){ return "778680b5172de58b7c057d973576c784"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Accel.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Accel_h 2 | #define _ROS_geometry_msgs_Accel_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Vector3.h" 9 | 10 | namespace geometry_msgs 11 | { 12 | 13 | class Accel : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::Vector3 linear; 17 | geometry_msgs::Vector3 angular; 18 | 19 | Accel(): 20 | linear(), 21 | angular() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->linear.serialize(outbuffer + offset); 29 | offset += this->angular.serialize(outbuffer + offset); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->linear.deserialize(inbuffer + offset); 37 | offset += this->angular.deserialize(inbuffer + offset); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "geometry_msgs/Accel"; }; 42 | const char * getMD5(){ return "9f195f881246fdfa2798d1d3eebca84a"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/AccelStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_AccelStamped_h 2 | #define _ROS_geometry_msgs_AccelStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Accel.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class AccelStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Accel accel; 19 | 20 | AccelStamped(): 21 | header(), 22 | accel() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->accel.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->accel.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/AccelStamped"; }; 43 | const char * getMD5(){ return "d8a98a5d81351b6eb0578c78557e7659"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/AccelWithCovariance.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_AccelWithCovariance_h 2 | #define _ROS_geometry_msgs_AccelWithCovariance_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Accel.h" 9 | 10 | namespace geometry_msgs 11 | { 12 | 13 | class AccelWithCovariance : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::Accel accel; 17 | float covariance[36]; 18 | 19 | AccelWithCovariance(): 20 | accel(), 21 | covariance() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->accel.serialize(outbuffer + offset); 29 | for( uint8_t i = 0; i < 36; i++){ 30 | offset += serializeAvrFloat64(outbuffer + offset, this->covariance[i]); 31 | } 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | offset += this->accel.deserialize(inbuffer + offset); 39 | for( uint8_t i = 0; i < 36; i++){ 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->covariance[i])); 41 | } 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "geometry_msgs/AccelWithCovariance"; }; 46 | const char * getMD5(){ return "ad5a718d699c6be72a02b8d6a139f334"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/AccelWithCovarianceStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_AccelWithCovarianceStamped_h 2 | #define _ROS_geometry_msgs_AccelWithCovarianceStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/AccelWithCovariance.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class AccelWithCovarianceStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::AccelWithCovariance accel; 19 | 20 | AccelWithCovarianceStamped(): 21 | header(), 22 | accel() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->accel.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->accel.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/AccelWithCovarianceStamped"; }; 43 | const char * getMD5(){ return "96adb295225031ec8d57fb4251b0a886"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/InertiaStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_InertiaStamped_h 2 | #define _ROS_geometry_msgs_InertiaStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Inertia.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class InertiaStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Inertia inertia; 19 | 20 | InertiaStamped(): 21 | header(), 22 | inertia() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->inertia.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->inertia.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/InertiaStamped"; }; 43 | const char * getMD5(){ return "ddee48caeab5a966c5e8d166654a9ac7"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Point.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Point_h 2 | #define _ROS_geometry_msgs_Point_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace geometry_msgs 10 | { 11 | 12 | class Point : public ros::Msg 13 | { 14 | public: 15 | float x; 16 | float y; 17 | float z; 18 | 19 | Point(): 20 | x(0), 21 | y(0), 22 | z(0) 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += serializeAvrFloat64(outbuffer + offset, this->x); 30 | offset += serializeAvrFloat64(outbuffer + offset, this->y); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->z); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->x)); 39 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->y)); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->z)); 41 | return offset; 42 | } 43 | 44 | const char * getType(){ return "geometry_msgs/Point"; }; 45 | const char * getMD5(){ return "4a842b65f413084dc2b10fb484ea7f17"; }; 46 | 47 | }; 48 | 49 | } 50 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/PointStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_PointStamped_h 2 | #define _ROS_geometry_msgs_PointStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Point.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class PointStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Point point; 19 | 20 | PointStamped(): 21 | header(), 22 | point() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->point.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->point.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/PointStamped"; }; 43 | const char * getMD5(){ return "c63aecb41bfdfd6b7e1fac37c7cbe7bf"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/PolygonStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_PolygonStamped_h 2 | #define _ROS_geometry_msgs_PolygonStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Polygon.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class PolygonStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Polygon polygon; 19 | 20 | PolygonStamped(): 21 | header(), 22 | polygon() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->polygon.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->polygon.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/PolygonStamped"; }; 43 | const char * getMD5(){ return "c6be8f7dc3bee7fe9e8d296070f53340"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Pose.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Pose_h 2 | #define _ROS_geometry_msgs_Pose_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Point.h" 9 | #include "geometry_msgs/Quaternion.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class Pose : public ros::Msg 15 | { 16 | public: 17 | geometry_msgs::Point position; 18 | geometry_msgs::Quaternion orientation; 19 | 20 | Pose(): 21 | position(), 22 | orientation() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->position.serialize(outbuffer + offset); 30 | offset += this->orientation.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->position.deserialize(inbuffer + offset); 38 | offset += this->orientation.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/Pose"; }; 43 | const char * getMD5(){ return "e45d45a5a1ce597b249e23fb30fc871f"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Pose2D.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Pose2D_h 2 | #define _ROS_geometry_msgs_Pose2D_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace geometry_msgs 10 | { 11 | 12 | class Pose2D : public ros::Msg 13 | { 14 | public: 15 | float x; 16 | float y; 17 | float theta; 18 | 19 | Pose2D(): 20 | x(0), 21 | y(0), 22 | theta(0) 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += serializeAvrFloat64(outbuffer + offset, this->x); 30 | offset += serializeAvrFloat64(outbuffer + offset, this->y); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->theta); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->x)); 39 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->y)); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->theta)); 41 | return offset; 42 | } 43 | 44 | const char * getType(){ return "geometry_msgs/Pose2D"; }; 45 | const char * getMD5(){ return "938fa65709584ad8e77d238529be13b8"; }; 46 | 47 | }; 48 | 49 | } 50 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/PoseStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_PoseStamped_h 2 | #define _ROS_geometry_msgs_PoseStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Pose.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class PoseStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Pose pose; 19 | 20 | PoseStamped(): 21 | header(), 22 | pose() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->pose.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->pose.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/PoseStamped"; }; 43 | const char * getMD5(){ return "d3812c3cbc69362b77dc0b19b345f8f5"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/PoseWithCovariance.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_PoseWithCovariance_h 2 | #define _ROS_geometry_msgs_PoseWithCovariance_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Pose.h" 9 | 10 | namespace geometry_msgs 11 | { 12 | 13 | class PoseWithCovariance : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::Pose pose; 17 | float covariance[36]; 18 | 19 | PoseWithCovariance(): 20 | pose(), 21 | covariance() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->pose.serialize(outbuffer + offset); 29 | for( uint8_t i = 0; i < 36; i++){ 30 | offset += serializeAvrFloat64(outbuffer + offset, this->covariance[i]); 31 | } 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | offset += this->pose.deserialize(inbuffer + offset); 39 | for( uint8_t i = 0; i < 36; i++){ 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->covariance[i])); 41 | } 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "geometry_msgs/PoseWithCovariance"; }; 46 | const char * getMD5(){ return "c23e848cf1b7533a8d7c259073a97e6f"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/PoseWithCovarianceStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_PoseWithCovarianceStamped_h 2 | #define _ROS_geometry_msgs_PoseWithCovarianceStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/PoseWithCovariance.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class PoseWithCovarianceStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::PoseWithCovariance pose; 19 | 20 | PoseWithCovarianceStamped(): 21 | header(), 22 | pose() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->pose.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->pose.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/PoseWithCovarianceStamped"; }; 43 | const char * getMD5(){ return "953b798c0f514ff060a53a3498ce6246"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/QuaternionStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_QuaternionStamped_h 2 | #define _ROS_geometry_msgs_QuaternionStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Quaternion.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class QuaternionStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Quaternion quaternion; 19 | 20 | QuaternionStamped(): 21 | header(), 22 | quaternion() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->quaternion.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->quaternion.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/QuaternionStamped"; }; 43 | const char * getMD5(){ return "e57f1e547e0e1fd13504588ffc8334e2"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Transform.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Transform_h 2 | #define _ROS_geometry_msgs_Transform_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Vector3.h" 9 | #include "geometry_msgs/Quaternion.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class Transform : public ros::Msg 15 | { 16 | public: 17 | geometry_msgs::Vector3 translation; 18 | geometry_msgs::Quaternion rotation; 19 | 20 | Transform(): 21 | translation(), 22 | rotation() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->translation.serialize(outbuffer + offset); 30 | offset += this->rotation.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->translation.deserialize(inbuffer + offset); 38 | offset += this->rotation.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/Transform"; }; 43 | const char * getMD5(){ return "ac9eff44abf714214112b05d54a3cf9b"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Twist.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Twist_h 2 | #define _ROS_geometry_msgs_Twist_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Vector3.h" 9 | 10 | namespace geometry_msgs 11 | { 12 | 13 | class Twist : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::Vector3 linear; 17 | geometry_msgs::Vector3 angular; 18 | 19 | Twist(): 20 | linear(), 21 | angular() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->linear.serialize(outbuffer + offset); 29 | offset += this->angular.serialize(outbuffer + offset); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->linear.deserialize(inbuffer + offset); 37 | offset += this->angular.deserialize(inbuffer + offset); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "geometry_msgs/Twist"; }; 42 | const char * getMD5(){ return "9f195f881246fdfa2798d1d3eebca84a"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/TwistStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_TwistStamped_h 2 | #define _ROS_geometry_msgs_TwistStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Twist.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class TwistStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Twist twist; 19 | 20 | TwistStamped(): 21 | header(), 22 | twist() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->twist.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->twist.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/TwistStamped"; }; 43 | const char * getMD5(){ return "98d34b0043a2093cf9d9345ab6eef12e"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/TwistWithCovariance.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_TwistWithCovariance_h 2 | #define _ROS_geometry_msgs_TwistWithCovariance_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Twist.h" 9 | 10 | namespace geometry_msgs 11 | { 12 | 13 | class TwistWithCovariance : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::Twist twist; 17 | float covariance[36]; 18 | 19 | TwistWithCovariance(): 20 | twist(), 21 | covariance() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->twist.serialize(outbuffer + offset); 29 | for( uint8_t i = 0; i < 36; i++){ 30 | offset += serializeAvrFloat64(outbuffer + offset, this->covariance[i]); 31 | } 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | offset += this->twist.deserialize(inbuffer + offset); 39 | for( uint8_t i = 0; i < 36; i++){ 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->covariance[i])); 41 | } 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "geometry_msgs/TwistWithCovariance"; }; 46 | const char * getMD5(){ return "1fe8a28e6890a4cc3ae4c3ca5c7d82e6"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/TwistWithCovarianceStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_TwistWithCovarianceStamped_h 2 | #define _ROS_geometry_msgs_TwistWithCovarianceStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/TwistWithCovariance.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class TwistWithCovarianceStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::TwistWithCovariance twist; 19 | 20 | TwistWithCovarianceStamped(): 21 | header(), 22 | twist() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->twist.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->twist.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/TwistWithCovarianceStamped"; }; 43 | const char * getMD5(){ return "8927a1a12fb2607ceea095b2dc440a96"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Vector3.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Vector3_h 2 | #define _ROS_geometry_msgs_Vector3_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace geometry_msgs 10 | { 11 | 12 | class Vector3 : public ros::Msg 13 | { 14 | public: 15 | float x; 16 | float y; 17 | float z; 18 | 19 | Vector3(): 20 | x(0), 21 | y(0), 22 | z(0) 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += serializeAvrFloat64(outbuffer + offset, this->x); 30 | offset += serializeAvrFloat64(outbuffer + offset, this->y); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->z); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->x)); 39 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->y)); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->z)); 41 | return offset; 42 | } 43 | 44 | const char * getType(){ return "geometry_msgs/Vector3"; }; 45 | const char * getMD5(){ return "4a842b65f413084dc2b10fb484ea7f17"; }; 46 | 47 | }; 48 | 49 | } 50 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Vector3Stamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Vector3Stamped_h 2 | #define _ROS_geometry_msgs_Vector3Stamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Vector3.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class Vector3Stamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Vector3 vector; 19 | 20 | Vector3Stamped(): 21 | header(), 22 | vector() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->vector.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->vector.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/Vector3Stamped"; }; 43 | const char * getMD5(){ return "7b324c7325e683bf02a9b14b01090ec7"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/Wrench.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_Wrench_h 2 | #define _ROS_geometry_msgs_Wrench_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Vector3.h" 9 | 10 | namespace geometry_msgs 11 | { 12 | 13 | class Wrench : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::Vector3 force; 17 | geometry_msgs::Vector3 torque; 18 | 19 | Wrench(): 20 | force(), 21 | torque() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->force.serialize(outbuffer + offset); 29 | offset += this->torque.serialize(outbuffer + offset); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->force.deserialize(inbuffer + offset); 37 | offset += this->torque.deserialize(inbuffer + offset); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "geometry_msgs/Wrench"; }; 42 | const char * getMD5(){ return "4f539cf138b23283b520fd271b567936"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/geometry_msgs/WrenchStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_geometry_msgs_WrenchStamped_h 2 | #define _ROS_geometry_msgs_WrenchStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Wrench.h" 10 | 11 | namespace geometry_msgs 12 | { 13 | 14 | class WrenchStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | geometry_msgs::Wrench wrench; 19 | 20 | WrenchStamped(): 21 | header(), 22 | wrench() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->wrench.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->wrench.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "geometry_msgs/WrenchStamped"; }; 43 | const char * getMD5(){ return "d78d3cb249ce23087ade7e7d0c40cfa7"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/AutoDockingGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_AutoDockingGoal_h 2 | #define _ROS_kobuki_msgs_AutoDockingGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class AutoDockingGoal : public ros::Msg 13 | { 14 | public: 15 | 16 | AutoDockingGoal() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "kobuki_msgs/AutoDockingGoal"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/AutoDockingResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_AutoDockingResult_h 2 | #define _ROS_kobuki_msgs_AutoDockingResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class AutoDockingResult : public ros::Msg 13 | { 14 | public: 15 | const char* text; 16 | 17 | AutoDockingResult(): 18 | text("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_text = strlen(this->text); 26 | memcpy(outbuffer + offset, &length_text, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->text, length_text); 29 | offset += length_text; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_text; 37 | memcpy(&length_text, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_text; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_text-1]=0; 43 | this->text = (char *)(inbuffer + offset-1); 44 | offset += length_text; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "kobuki_msgs/AutoDockingResult"; }; 49 | const char * getMD5(){ return "74697ed3d931f6eede8bf3a8dfeca160"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/BumperEvent.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_BumperEvent_h 2 | #define _ROS_kobuki_msgs_BumperEvent_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class BumperEvent : public ros::Msg 13 | { 14 | public: 15 | uint8_t bumper; 16 | uint8_t state; 17 | enum { LEFT = 0 }; 18 | enum { CENTER = 1 }; 19 | enum { RIGHT = 2 }; 20 | enum { RELEASED = 0 }; 21 | enum { PRESSED = 1 }; 22 | 23 | BumperEvent(): 24 | bumper(0), 25 | state(0) 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | *(outbuffer + offset + 0) = (this->bumper >> (8 * 0)) & 0xFF; 33 | offset += sizeof(this->bumper); 34 | *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF; 35 | offset += sizeof(this->state); 36 | return offset; 37 | } 38 | 39 | virtual int deserialize(unsigned char *inbuffer) 40 | { 41 | int offset = 0; 42 | this->bumper = ((uint8_t) (*(inbuffer + offset))); 43 | offset += sizeof(this->bumper); 44 | this->state = ((uint8_t) (*(inbuffer + offset))); 45 | offset += sizeof(this->state); 46 | return offset; 47 | } 48 | 49 | const char * getType(){ return "kobuki_msgs/BumperEvent"; }; 50 | const char * getMD5(){ return "ffe360cd50f14f9251d9844083e72ac5"; }; 51 | 52 | }; 53 | 54 | } 55 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/ButtonEvent.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_ButtonEvent_h 2 | #define _ROS_kobuki_msgs_ButtonEvent_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class ButtonEvent : public ros::Msg 13 | { 14 | public: 15 | uint8_t button; 16 | uint8_t state; 17 | enum { Button0 = 0 }; 18 | enum { Button1 = 1 }; 19 | enum { Button2 = 2 }; 20 | enum { RELEASED = 0 }; 21 | enum { PRESSED = 1 }; 22 | 23 | ButtonEvent(): 24 | button(0), 25 | state(0) 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | *(outbuffer + offset + 0) = (this->button >> (8 * 0)) & 0xFF; 33 | offset += sizeof(this->button); 34 | *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF; 35 | offset += sizeof(this->state); 36 | return offset; 37 | } 38 | 39 | virtual int deserialize(unsigned char *inbuffer) 40 | { 41 | int offset = 0; 42 | this->button = ((uint8_t) (*(inbuffer + offset))); 43 | offset += sizeof(this->button); 44 | this->state = ((uint8_t) (*(inbuffer + offset))); 45 | offset += sizeof(this->state); 46 | return offset; 47 | } 48 | 49 | const char * getType(){ return "kobuki_msgs/ButtonEvent"; }; 50 | const char * getMD5(){ return "49eca512765dbdec759a79083ffcec8d"; }; 51 | 52 | }; 53 | 54 | } 55 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/KeyboardInput.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_KeyboardInput_h 2 | #define _ROS_kobuki_msgs_KeyboardInput_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class KeyboardInput : public ros::Msg 13 | { 14 | public: 15 | uint8_t pressedKey; 16 | enum { KeyCode_Right = 67 }; 17 | enum { KeyCode_Left = 68 }; 18 | enum { KeyCode_Up = 65 }; 19 | enum { KeyCode_Down = 66 }; 20 | enum { KeyCode_Space = 32 }; 21 | enum { KeyCode_Enable = 101 }; 22 | enum { KeyCode_Disable = 100 }; 23 | 24 | KeyboardInput(): 25 | pressedKey(0) 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | *(outbuffer + offset + 0) = (this->pressedKey >> (8 * 0)) & 0xFF; 33 | offset += sizeof(this->pressedKey); 34 | return offset; 35 | } 36 | 37 | virtual int deserialize(unsigned char *inbuffer) 38 | { 39 | int offset = 0; 40 | this->pressedKey = ((uint8_t) (*(inbuffer + offset))); 41 | offset += sizeof(this->pressedKey); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "kobuki_msgs/KeyboardInput"; }; 46 | const char * getMD5(){ return "9288b95cb32b48719d84d696be253401"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/Led.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_Led_h 2 | #define _ROS_kobuki_msgs_Led_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class Led : public ros::Msg 13 | { 14 | public: 15 | uint8_t value; 16 | enum { BLACK = 0 }; 17 | enum { GREEN = 1 }; 18 | enum { ORANGE = 2 }; 19 | enum { RED = 3 }; 20 | 21 | Led(): 22 | value(0) 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | *(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF; 30 | offset += sizeof(this->value); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | this->value = ((uint8_t) (*(inbuffer + offset))); 38 | offset += sizeof(this->value); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "kobuki_msgs/Led"; }; 43 | const char * getMD5(){ return "4391183b0cf05f8f25d04220401b9f43"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/MotorPower.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_MotorPower_h 2 | #define _ROS_kobuki_msgs_MotorPower_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class MotorPower : public ros::Msg 13 | { 14 | public: 15 | uint8_t state; 16 | enum { OFF = 0 }; 17 | enum { ON = 1 }; 18 | 19 | MotorPower(): 20 | state(0) 21 | { 22 | } 23 | 24 | virtual int serialize(unsigned char *outbuffer) const 25 | { 26 | int offset = 0; 27 | *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF; 28 | offset += sizeof(this->state); 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | this->state = ((uint8_t) (*(inbuffer + offset))); 36 | offset += sizeof(this->state); 37 | return offset; 38 | } 39 | 40 | const char * getType(){ return "kobuki_msgs/MotorPower"; }; 41 | const char * getMD5(){ return "8f77c0161e0f2021493136bb5f3f0e51"; }; 42 | 43 | }; 44 | 45 | } 46 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/PowerSystemEvent.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_PowerSystemEvent_h 2 | #define _ROS_kobuki_msgs_PowerSystemEvent_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class PowerSystemEvent : public ros::Msg 13 | { 14 | public: 15 | uint8_t event; 16 | enum { UNPLUGGED = 0 }; 17 | enum { PLUGGED_TO_ADAPTER = 1 }; 18 | enum { PLUGGED_TO_DOCKBASE = 2 }; 19 | enum { CHARGE_COMPLETED = 3 }; 20 | enum { BATTERY_LOW = 4 }; 21 | enum { BATTERY_CRITICAL = 5 }; 22 | 23 | PowerSystemEvent(): 24 | event(0) 25 | { 26 | } 27 | 28 | virtual int serialize(unsigned char *outbuffer) const 29 | { 30 | int offset = 0; 31 | *(outbuffer + offset + 0) = (this->event >> (8 * 0)) & 0xFF; 32 | offset += sizeof(this->event); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | this->event = ((uint8_t) (*(inbuffer + offset))); 40 | offset += sizeof(this->event); 41 | return offset; 42 | } 43 | 44 | const char * getType(){ return "kobuki_msgs/PowerSystemEvent"; }; 45 | const char * getMD5(){ return "f6464657d6c911b00c7bc7b43a154bf8"; }; 46 | 47 | }; 48 | 49 | } 50 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/RobotStateEvent.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_RobotStateEvent_h 2 | #define _ROS_kobuki_msgs_RobotStateEvent_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class RobotStateEvent : public ros::Msg 13 | { 14 | public: 15 | uint8_t state; 16 | enum { ONLINE = 1 }; 17 | enum { OFFLINE = 0 }; 18 | 19 | RobotStateEvent(): 20 | state(0) 21 | { 22 | } 23 | 24 | virtual int serialize(unsigned char *outbuffer) const 25 | { 26 | int offset = 0; 27 | *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF; 28 | offset += sizeof(this->state); 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | this->state = ((uint8_t) (*(inbuffer + offset))); 36 | offset += sizeof(this->state); 37 | return offset; 38 | } 39 | 40 | const char * getType(){ return "kobuki_msgs/RobotStateEvent"; }; 41 | const char * getMD5(){ return "c6eccd4cb1f95df95635b56d6226ea32"; }; 42 | 43 | }; 44 | 45 | } 46 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/ScanAngle.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_ScanAngle_h 2 | #define _ROS_kobuki_msgs_ScanAngle_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | 10 | namespace kobuki_msgs 11 | { 12 | 13 | class ScanAngle : public ros::Msg 14 | { 15 | public: 16 | std_msgs::Header header; 17 | float scan_angle; 18 | 19 | ScanAngle(): 20 | header(), 21 | scan_angle(0) 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->header.serialize(outbuffer + offset); 29 | offset += serializeAvrFloat64(outbuffer + offset, this->scan_angle); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->header.deserialize(inbuffer + offset); 37 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->scan_angle)); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "kobuki_msgs/ScanAngle"; }; 42 | const char * getMD5(){ return "06e2c839dc5c7f5c13ac09a8b4ff0a6a"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/Sound.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_Sound_h 2 | #define _ROS_kobuki_msgs_Sound_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class Sound : public ros::Msg 13 | { 14 | public: 15 | uint8_t value; 16 | enum { ON = 0 }; 17 | enum { OFF = 1 }; 18 | enum { RECHARGE = 2 }; 19 | enum { BUTTON = 3 }; 20 | enum { ERROR = 4 }; 21 | enum { CLEANINGSTART = 5 }; 22 | enum { CLEANINGEND = 6 }; 23 | 24 | Sound(): 25 | value(0) 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | *(outbuffer + offset + 0) = (this->value >> (8 * 0)) & 0xFF; 33 | offset += sizeof(this->value); 34 | return offset; 35 | } 36 | 37 | virtual int deserialize(unsigned char *inbuffer) 38 | { 39 | int offset = 0; 40 | this->value = ((uint8_t) (*(inbuffer + offset))); 41 | offset += sizeof(this->value); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "kobuki_msgs/Sound"; }; 46 | const char * getMD5(){ return "dfeab0daae67749c426c1db741a4f420"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/kobuki_msgs/WheelDropEvent.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_kobuki_msgs_WheelDropEvent_h 2 | #define _ROS_kobuki_msgs_WheelDropEvent_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace kobuki_msgs 10 | { 11 | 12 | class WheelDropEvent : public ros::Msg 13 | { 14 | public: 15 | uint8_t wheel; 16 | uint8_t state; 17 | enum { LEFT = 0 }; 18 | enum { RIGHT = 1 }; 19 | enum { RAISED = 0 }; 20 | enum { DROPPED = 1 }; 21 | 22 | WheelDropEvent(): 23 | wheel(0), 24 | state(0) 25 | { 26 | } 27 | 28 | virtual int serialize(unsigned char *outbuffer) const 29 | { 30 | int offset = 0; 31 | *(outbuffer + offset + 0) = (this->wheel >> (8 * 0)) & 0xFF; 32 | offset += sizeof(this->wheel); 33 | *(outbuffer + offset + 0) = (this->state >> (8 * 0)) & 0xFF; 34 | offset += sizeof(this->state); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | this->wheel = ((uint8_t) (*(inbuffer + offset))); 42 | offset += sizeof(this->wheel); 43 | this->state = ((uint8_t) (*(inbuffer + offset))); 44 | offset += sizeof(this->state); 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "kobuki_msgs/WheelDropEvent"; }; 49 | const char * getMD5(){ return "e102837d89384d67669a0df86b63f33b"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/manipulation_msgs/ClusterBoundingBox.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_manipulation_msgs_ClusterBoundingBox_h 2 | #define _ROS_manipulation_msgs_ClusterBoundingBox_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/PoseStamped.h" 9 | #include "geometry_msgs/Vector3.h" 10 | 11 | namespace manipulation_msgs 12 | { 13 | 14 | class ClusterBoundingBox : public ros::Msg 15 | { 16 | public: 17 | geometry_msgs::PoseStamped pose_stamped; 18 | geometry_msgs::Vector3 dimensions; 19 | 20 | ClusterBoundingBox(): 21 | pose_stamped(), 22 | dimensions() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->pose_stamped.serialize(outbuffer + offset); 30 | offset += this->dimensions.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->pose_stamped.deserialize(inbuffer + offset); 38 | offset += this->dimensions.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "manipulation_msgs/ClusterBoundingBox"; }; 43 | const char * getMD5(){ return "9bf2b7a44ad666dc3a6a2bbc21782dad"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/map_msgs/ProjectedMap.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_map_msgs_ProjectedMap_h 2 | #define _ROS_map_msgs_ProjectedMap_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "nav_msgs/OccupancyGrid.h" 9 | 10 | namespace map_msgs 11 | { 12 | 13 | class ProjectedMap : public ros::Msg 14 | { 15 | public: 16 | nav_msgs::OccupancyGrid map; 17 | float min_z; 18 | float max_z; 19 | 20 | ProjectedMap(): 21 | map(), 22 | min_z(0), 23 | max_z(0) 24 | { 25 | } 26 | 27 | virtual int serialize(unsigned char *outbuffer) const 28 | { 29 | int offset = 0; 30 | offset += this->map.serialize(outbuffer + offset); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->min_z); 32 | offset += serializeAvrFloat64(outbuffer + offset, this->max_z); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | offset += this->map.deserialize(inbuffer + offset); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->min_z)); 41 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->max_z)); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "map_msgs/ProjectedMap"; }; 46 | const char * getMD5(){ return "7bbe8f96e45089681dc1ea7d023cbfca"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/move_base_msgs/MoveBaseFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_move_base_msgs_MoveBaseFeedback_h 2 | #define _ROS_move_base_msgs_MoveBaseFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/PoseStamped.h" 9 | 10 | namespace move_base_msgs 11 | { 12 | 13 | class MoveBaseFeedback : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::PoseStamped base_position; 17 | 18 | MoveBaseFeedback(): 19 | base_position() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->base_position.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->base_position.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "move_base_msgs/MoveBaseFeedback"; }; 38 | const char * getMD5(){ return "3fb824c456a757373a226f6d08071bf0"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/move_base_msgs/MoveBaseGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_move_base_msgs_MoveBaseGoal_h 2 | #define _ROS_move_base_msgs_MoveBaseGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/PoseStamped.h" 9 | 10 | namespace move_base_msgs 11 | { 12 | 13 | class MoveBaseGoal : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::PoseStamped target_pose; 17 | 18 | MoveBaseGoal(): 19 | target_pose() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->target_pose.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->target_pose.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "move_base_msgs/MoveBaseGoal"; }; 38 | const char * getMD5(){ return "257d089627d7eb7136c24d3593d05a16"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/move_base_msgs/MoveBaseResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_move_base_msgs_MoveBaseResult_h 2 | #define _ROS_move_base_msgs_MoveBaseResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace move_base_msgs 10 | { 11 | 12 | class MoveBaseResult : public ros::Msg 13 | { 14 | public: 15 | 16 | MoveBaseResult() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "move_base_msgs/MoveBaseResult"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/CostSource.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_CostSource_h 2 | #define _ROS_moveit_msgs_CostSource_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Vector3.h" 9 | 10 | namespace moveit_msgs 11 | { 12 | 13 | class CostSource : public ros::Msg 14 | { 15 | public: 16 | float cost_density; 17 | geometry_msgs::Vector3 aabb_min; 18 | geometry_msgs::Vector3 aabb_max; 19 | 20 | CostSource(): 21 | cost_density(0), 22 | aabb_min(), 23 | aabb_max() 24 | { 25 | } 26 | 27 | virtual int serialize(unsigned char *outbuffer) const 28 | { 29 | int offset = 0; 30 | offset += serializeAvrFloat64(outbuffer + offset, this->cost_density); 31 | offset += this->aabb_min.serialize(outbuffer + offset); 32 | offset += this->aabb_max.serialize(outbuffer + offset); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->cost_density)); 40 | offset += this->aabb_min.deserialize(inbuffer + offset); 41 | offset += this->aabb_max.deserialize(inbuffer + offset); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "moveit_msgs/CostSource"; }; 46 | const char * getMD5(){ return "abb7e013237dacaaa8b97e704102f908"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/MoveGroupGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_MoveGroupGoal_h 2 | #define _ROS_moveit_msgs_MoveGroupGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "moveit_msgs/MotionPlanRequest.h" 9 | #include "moveit_msgs/PlanningOptions.h" 10 | 11 | namespace moveit_msgs 12 | { 13 | 14 | class MoveGroupGoal : public ros::Msg 15 | { 16 | public: 17 | moveit_msgs::MotionPlanRequest request; 18 | moveit_msgs::PlanningOptions planning_options; 19 | 20 | MoveGroupGoal(): 21 | request(), 22 | planning_options() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->request.serialize(outbuffer + offset); 30 | offset += this->planning_options.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->request.deserialize(inbuffer + offset); 38 | offset += this->planning_options.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "moveit_msgs/MoveGroupGoal"; }; 43 | const char * getMD5(){ return "a6de2db49c561a49babce1a8172e8906"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/OrientedBoundingBox.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_OrientedBoundingBox_h 2 | #define _ROS_moveit_msgs_OrientedBoundingBox_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/Pose.h" 9 | #include "geometry_msgs/Point32.h" 10 | 11 | namespace moveit_msgs 12 | { 13 | 14 | class OrientedBoundingBox : public ros::Msg 15 | { 16 | public: 17 | geometry_msgs::Pose pose; 18 | geometry_msgs::Point32 extents; 19 | 20 | OrientedBoundingBox(): 21 | pose(), 22 | extents() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->pose.serialize(outbuffer + offset); 30 | offset += this->extents.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->pose.deserialize(inbuffer + offset); 38 | offset += this->extents.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "moveit_msgs/OrientedBoundingBox"; }; 43 | const char * getMD5(){ return "da3bd98e7cb14efa4141367a9d886ee7"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/PickupActionGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_PickupActionGoal_h 2 | #define _ROS_moveit_msgs_PickupActionGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalID.h" 10 | #include "moveit_msgs/PickupGoal.h" 11 | 12 | namespace moveit_msgs 13 | { 14 | 15 | class PickupActionGoal : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalID goal_id; 20 | moveit_msgs::PickupGoal goal; 21 | 22 | PickupActionGoal(): 23 | header(), 24 | goal_id(), 25 | goal() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->goal_id.serialize(outbuffer + offset); 34 | offset += this->goal.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->goal_id.deserialize(inbuffer + offset); 43 | offset += this->goal.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "moveit_msgs/PickupActionGoal"; }; 48 | const char * getMD5(){ return "9e12196da542c9a26bbc43e9655a1906"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/PickupFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_PickupFeedback_h 2 | #define _ROS_moveit_msgs_PickupFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace moveit_msgs 10 | { 11 | 12 | class PickupFeedback : public ros::Msg 13 | { 14 | public: 15 | const char* state; 16 | 17 | PickupFeedback(): 18 | state("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_state = strlen(this->state); 26 | memcpy(outbuffer + offset, &length_state, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->state, length_state); 29 | offset += length_state; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_state; 37 | memcpy(&length_state, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_state; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_state-1]=0; 43 | this->state = (char *)(inbuffer + offset-1); 44 | offset += length_state; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "moveit_msgs/PickupFeedback"; }; 49 | const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/PlaceActionGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_PlaceActionGoal_h 2 | #define _ROS_moveit_msgs_PlaceActionGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalID.h" 10 | #include "moveit_msgs/PlaceGoal.h" 11 | 12 | namespace moveit_msgs 13 | { 14 | 15 | class PlaceActionGoal : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalID goal_id; 20 | moveit_msgs::PlaceGoal goal; 21 | 22 | PlaceActionGoal(): 23 | header(), 24 | goal_id(), 25 | goal() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->goal_id.serialize(outbuffer + offset); 34 | offset += this->goal.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->goal_id.deserialize(inbuffer + offset); 43 | offset += this->goal.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "moveit_msgs/PlaceActionGoal"; }; 48 | const char * getMD5(){ return "facadaee390f685ed5e693ac12f5aa3d"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/PlaceFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_PlaceFeedback_h 2 | #define _ROS_moveit_msgs_PlaceFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace moveit_msgs 10 | { 11 | 12 | class PlaceFeedback : public ros::Msg 13 | { 14 | public: 15 | const char* state; 16 | 17 | PlaceFeedback(): 18 | state("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_state = strlen(this->state); 26 | memcpy(outbuffer + offset, &length_state, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->state, length_state); 29 | offset += length_state; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_state; 37 | memcpy(&length_state, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_state; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_state-1]=0; 43 | this->state = (char *)(inbuffer + offset-1); 44 | offset += length_state; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "moveit_msgs/PlaceFeedback"; }; 49 | const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/moveit_msgs/RobotTrajectory.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_moveit_msgs_RobotTrajectory_h 2 | #define _ROS_moveit_msgs_RobotTrajectory_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "trajectory_msgs/JointTrajectory.h" 9 | #include "trajectory_msgs/MultiDOFJointTrajectory.h" 10 | 11 | namespace moveit_msgs 12 | { 13 | 14 | class RobotTrajectory : public ros::Msg 15 | { 16 | public: 17 | trajectory_msgs::JointTrajectory joint_trajectory; 18 | trajectory_msgs::MultiDOFJointTrajectory multi_dof_joint_trajectory; 19 | 20 | RobotTrajectory(): 21 | joint_trajectory(), 22 | multi_dof_joint_trajectory() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->joint_trajectory.serialize(outbuffer + offset); 30 | offset += this->multi_dof_joint_trajectory.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->joint_trajectory.deserialize(inbuffer + offset); 38 | offset += this->multi_dof_joint_trajectory.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "moveit_msgs/RobotTrajectory"; }; 43 | const char * getMD5(){ return "dfa9556423d709a3729bcef664bddf67"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/nav_msgs/GetMapActionGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_nav_msgs_GetMapActionGoal_h 2 | #define _ROS_nav_msgs_GetMapActionGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalID.h" 10 | #include "nav_msgs/GetMapGoal.h" 11 | 12 | namespace nav_msgs 13 | { 14 | 15 | class GetMapActionGoal : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalID goal_id; 20 | nav_msgs::GetMapGoal goal; 21 | 22 | GetMapActionGoal(): 23 | header(), 24 | goal_id(), 25 | goal() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->goal_id.serialize(outbuffer + offset); 34 | offset += this->goal.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->goal_id.deserialize(inbuffer + offset); 43 | offset += this->goal.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "nav_msgs/GetMapActionGoal"; }; 48 | const char * getMD5(){ return "4b30be6cd12b9e72826df56b481f40e0"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/nav_msgs/GetMapFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_nav_msgs_GetMapFeedback_h 2 | #define _ROS_nav_msgs_GetMapFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace nav_msgs 10 | { 11 | 12 | class GetMapFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | GetMapFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "nav_msgs/GetMapFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/nav_msgs/GetMapGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_nav_msgs_GetMapGoal_h 2 | #define _ROS_nav_msgs_GetMapGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace nav_msgs 10 | { 11 | 12 | class GetMapGoal : public ros::Msg 13 | { 14 | public: 15 | 16 | GetMapGoal() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "nav_msgs/GetMapGoal"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/nav_msgs/GetMapResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_nav_msgs_GetMapResult_h 2 | #define _ROS_nav_msgs_GetMapResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "nav_msgs/OccupancyGrid.h" 9 | 10 | namespace nav_msgs 11 | { 12 | 13 | class GetMapResult : public ros::Msg 14 | { 15 | public: 16 | nav_msgs::OccupancyGrid map; 17 | 18 | GetMapResult(): 19 | map() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->map.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->map.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "nav_msgs/GetMapResult"; }; 38 | const char * getMD5(){ return "6cdd0a18e0aff5b0a3ca2326a89b54ff"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/object_recognition_msgs/ObjectRecognitionFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionFeedback_h 2 | #define _ROS_object_recognition_msgs_ObjectRecognitionFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace object_recognition_msgs 10 | { 11 | 12 | class ObjectRecognitionFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | ObjectRecognitionFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "object_recognition_msgs/ObjectRecognitionFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/object_recognition_msgs/ObjectRecognitionResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_object_recognition_msgs_ObjectRecognitionResult_h 2 | #define _ROS_object_recognition_msgs_ObjectRecognitionResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "object_recognition_msgs/RecognizedObjectArray.h" 9 | 10 | namespace object_recognition_msgs 11 | { 12 | 13 | class ObjectRecognitionResult : public ros::Msg 14 | { 15 | public: 16 | object_recognition_msgs::RecognizedObjectArray recognized_objects; 17 | 18 | ObjectRecognitionResult(): 19 | recognized_objects() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->recognized_objects.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->recognized_objects.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "object_recognition_msgs/ObjectRecognitionResult"; }; 38 | const char * getMD5(){ return "868e41288f9f8636e2b6c51f1af6aa9c"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/octomap_msgs/OctomapWithPose.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_octomap_msgs_OctomapWithPose_h 2 | #define _ROS_octomap_msgs_OctomapWithPose_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "geometry_msgs/Pose.h" 10 | #include "octomap_msgs/Octomap.h" 11 | 12 | namespace octomap_msgs 13 | { 14 | 15 | class OctomapWithPose : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | geometry_msgs::Pose origin; 20 | octomap_msgs::Octomap octomap; 21 | 22 | OctomapWithPose(): 23 | header(), 24 | origin(), 25 | octomap() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->origin.serialize(outbuffer + offset); 34 | offset += this->octomap.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->origin.deserialize(inbuffer + offset); 43 | offset += this->octomap.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "octomap_msgs/OctomapWithPose"; }; 48 | const char * getMD5(){ return "20b380aca6a508a657e95526cddaf618"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/Circle.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_Circle_h 2 | #define _ROS_opencv_apps_Circle_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "opencv_apps/Point2D.h" 9 | 10 | namespace opencv_apps 11 | { 12 | 13 | class Circle : public ros::Msg 14 | { 15 | public: 16 | opencv_apps::Point2D center; 17 | float radius; 18 | 19 | Circle(): 20 | center(), 21 | radius(0) 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->center.serialize(outbuffer + offset); 29 | offset += serializeAvrFloat64(outbuffer + offset, this->radius); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->center.deserialize(inbuffer + offset); 37 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->radius)); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "opencv_apps/Circle"; }; 42 | const char * getMD5(){ return "4f6847051b4fe493b5af8caad66201d5"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/Flow.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_Flow_h 2 | #define _ROS_opencv_apps_Flow_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "opencv_apps/Point2D.h" 9 | 10 | namespace opencv_apps 11 | { 12 | 13 | class Flow : public ros::Msg 14 | { 15 | public: 16 | opencv_apps::Point2D point; 17 | opencv_apps::Point2D velocity; 18 | 19 | Flow(): 20 | point(), 21 | velocity() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->point.serialize(outbuffer + offset); 29 | offset += this->velocity.serialize(outbuffer + offset); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->point.deserialize(inbuffer + offset); 37 | offset += this->velocity.deserialize(inbuffer + offset); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "opencv_apps/Flow"; }; 42 | const char * getMD5(){ return "dd9a9efd88ba39035e78af697593d751"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/FlowStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_FlowStamped_h 2 | #define _ROS_opencv_apps_FlowStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "opencv_apps/Flow.h" 10 | 11 | namespace opencv_apps 12 | { 13 | 14 | class FlowStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | opencv_apps::Flow flow; 19 | 20 | FlowStamped(): 21 | header(), 22 | flow() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->flow.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->flow.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "opencv_apps/FlowStamped"; }; 43 | const char * getMD5(){ return "b55faf909449963372b92417925b68cc"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/Line.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_Line_h 2 | #define _ROS_opencv_apps_Line_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "opencv_apps/Point2D.h" 9 | 10 | namespace opencv_apps 11 | { 12 | 13 | class Line : public ros::Msg 14 | { 15 | public: 16 | opencv_apps::Point2D pt1; 17 | opencv_apps::Point2D pt2; 18 | 19 | Line(): 20 | pt1(), 21 | pt2() 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->pt1.serialize(outbuffer + offset); 29 | offset += this->pt2.serialize(outbuffer + offset); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->pt1.deserialize(inbuffer + offset); 37 | offset += this->pt2.deserialize(inbuffer + offset); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "opencv_apps/Line"; }; 42 | const char * getMD5(){ return "a1419010b3fc4549e3f450018363d000"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/Point2D.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_Point2D_h 2 | #define _ROS_opencv_apps_Point2D_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace opencv_apps 10 | { 11 | 12 | class Point2D : public ros::Msg 13 | { 14 | public: 15 | float x; 16 | float y; 17 | 18 | Point2D(): 19 | x(0), 20 | y(0) 21 | { 22 | } 23 | 24 | virtual int serialize(unsigned char *outbuffer) const 25 | { 26 | int offset = 0; 27 | offset += serializeAvrFloat64(outbuffer + offset, this->x); 28 | offset += serializeAvrFloat64(outbuffer + offset, this->y); 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->x)); 36 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->y)); 37 | return offset; 38 | } 39 | 40 | const char * getType(){ return "opencv_apps/Point2D"; }; 41 | const char * getMD5(){ return "209f516d3eb691f0663e25cb750d67c1"; }; 42 | 43 | }; 44 | 45 | } 46 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/Point2DStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_Point2DStamped_h 2 | #define _ROS_opencv_apps_Point2DStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "opencv_apps/Point2D.h" 10 | 11 | namespace opencv_apps 12 | { 13 | 14 | class Point2DStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | opencv_apps::Point2D point; 19 | 20 | Point2DStamped(): 21 | header(), 22 | point() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->point.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->point.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "opencv_apps/Point2DStamped"; }; 43 | const char * getMD5(){ return "9f7db918fde9989a73131d0d083d049d"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/RotatedRect.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_RotatedRect_h 2 | #define _ROS_opencv_apps_RotatedRect_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "opencv_apps/Point2D.h" 9 | #include "opencv_apps/Size.h" 10 | 11 | namespace opencv_apps 12 | { 13 | 14 | class RotatedRect : public ros::Msg 15 | { 16 | public: 17 | float angle; 18 | opencv_apps::Point2D center; 19 | opencv_apps::Size size; 20 | 21 | RotatedRect(): 22 | angle(0), 23 | center(), 24 | size() 25 | { 26 | } 27 | 28 | virtual int serialize(unsigned char *outbuffer) const 29 | { 30 | int offset = 0; 31 | offset += serializeAvrFloat64(outbuffer + offset, this->angle); 32 | offset += this->center.serialize(outbuffer + offset); 33 | offset += this->size.serialize(outbuffer + offset); 34 | return offset; 35 | } 36 | 37 | virtual int deserialize(unsigned char *inbuffer) 38 | { 39 | int offset = 0; 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->angle)); 41 | offset += this->center.deserialize(inbuffer + offset); 42 | offset += this->size.deserialize(inbuffer + offset); 43 | return offset; 44 | } 45 | 46 | const char * getType(){ return "opencv_apps/RotatedRect"; }; 47 | const char * getMD5(){ return "0ae60505c52f020176686d0689b8d390"; }; 48 | 49 | }; 50 | 51 | } 52 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/RotatedRectStamped.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_RotatedRectStamped_h 2 | #define _ROS_opencv_apps_RotatedRectStamped_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "opencv_apps/RotatedRect.h" 10 | 11 | namespace opencv_apps 12 | { 13 | 14 | class RotatedRectStamped : public ros::Msg 15 | { 16 | public: 17 | std_msgs::Header header; 18 | opencv_apps::RotatedRect rect; 19 | 20 | RotatedRectStamped(): 21 | header(), 22 | rect() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->header.serialize(outbuffer + offset); 30 | offset += this->rect.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->header.deserialize(inbuffer + offset); 38 | offset += this->rect.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "opencv_apps/RotatedRectStamped"; }; 43 | const char * getMD5(){ return "ba2d76a1968e4f77570c01223781fe15"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/opencv_apps/Size.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_opencv_apps_Size_h 2 | #define _ROS_opencv_apps_Size_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace opencv_apps 10 | { 11 | 12 | class Size : public ros::Msg 13 | { 14 | public: 15 | float width; 16 | float height; 17 | 18 | Size(): 19 | width(0), 20 | height(0) 21 | { 22 | } 23 | 24 | virtual int serialize(unsigned char *outbuffer) const 25 | { 26 | int offset = 0; 27 | offset += serializeAvrFloat64(outbuffer + offset, this->width); 28 | offset += serializeAvrFloat64(outbuffer + offset, this->height); 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->width)); 36 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->height)); 37 | return offset; 38 | } 39 | 40 | const char * getType(){ return "opencv_apps/Size"; }; 41 | const char * getMD5(){ return "f86522e647336fb10b55359fe003f673"; }; 42 | 43 | }; 44 | 45 | } 46 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/pano_ros/StitchActionGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_pano_ros_StitchActionGoal_h 2 | #define _ROS_pano_ros_StitchActionGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalID.h" 10 | #include "pano_ros/StitchGoal.h" 11 | 12 | namespace pano_ros 13 | { 14 | 15 | class StitchActionGoal : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalID goal_id; 20 | pano_ros::StitchGoal goal; 21 | 22 | StitchActionGoal(): 23 | header(), 24 | goal_id(), 25 | goal() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->goal_id.serialize(outbuffer + offset); 34 | offset += this->goal.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->goal_id.deserialize(inbuffer + offset); 43 | offset += this->goal.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "pano_ros/StitchActionGoal"; }; 48 | const char * getMD5(){ return "217f9f9dc4d0e3f59b2ca750689ede60"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_app_manager_msgs/Constants.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_app_manager_msgs_Constants_h 2 | #define _ROS_rocon_app_manager_msgs_Constants_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace rocon_app_manager_msgs 10 | { 11 | 12 | class Constants : public ros::Msg 13 | { 14 | public: 15 | enum { NO_REMOTE_CONNECTION = none }; 16 | enum { NO_REMOTE_CONTROLLER = none }; 17 | 18 | Constants() 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | return offset; 26 | } 27 | 28 | virtual int deserialize(unsigned char *inbuffer) 29 | { 30 | int offset = 0; 31 | return offset; 32 | } 33 | 34 | const char * getType(){ return "rocon_app_manager_msgs/Constants"; }; 35 | const char * getMD5(){ return "8dc55825f8d5b0d293568ddca66ef50f"; }; 36 | 37 | }; 38 | 39 | } 40 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_app_manager_msgs/ErrorCodes.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_app_manager_msgs_ErrorCodes_h 2 | #define _ROS_rocon_app_manager_msgs_ErrorCodes_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace rocon_app_manager_msgs 10 | { 11 | 12 | class ErrorCodes : public ros::Msg 13 | { 14 | public: 15 | enum { SUCCESS = 0 }; 16 | enum { UNKNOWN = 1 }; 17 | enum { MULTI_RAPP_NOT_SUPPORTED = 10 }; 18 | enum { RAPP_IS_NOT_RUNNING = 20 }; 19 | enum { RAPP_IS_NOT_AVAILABLE = 21 }; 20 | enum { LOCAL_INVITATIONS_ONLY = 30 }; 21 | enum { NO_LOCAL_GATEWAY = 31 }; 22 | enum { ALREADY_REMOTE_CONTROLLED = 32 }; 23 | enum { NOT_CURRENT_REMOTE_CONTROLLER = 33 }; 24 | enum { INVITING_CONTROLLER_NOT_WHITELISTED = 34 }; 25 | enum { INVITING_CONTROLLER_BLACKLISTED = 35 }; 26 | enum { CLIENT_CONNECTION_DISRUPTED = 36 }; 27 | 28 | ErrorCodes() 29 | { 30 | } 31 | 32 | virtual int serialize(unsigned char *outbuffer) const 33 | { 34 | int offset = 0; 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | return offset; 42 | } 43 | 44 | const char * getType(){ return "rocon_app_manager_msgs/ErrorCodes"; }; 45 | const char * getMD5(){ return "cec38b743e8d5698477f7be4d8bfebb8"; }; 46 | 47 | }; 48 | 49 | } 50 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_interaction_msgs/ErrorCodes.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_interaction_msgs_ErrorCodes_h 2 | #define _ROS_rocon_interaction_msgs_ErrorCodes_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace rocon_interaction_msgs 10 | { 11 | 12 | class ErrorCodes : public ros::Msg 13 | { 14 | public: 15 | enum { SUCCESS = 0 }; 16 | enum { INTERACTION_UNAVAILABLE = 20 }; 17 | enum { INTERACTION_QUOTA_REACHED = 21 }; 18 | enum { START_PAIRED_RAPP_FAILED = 31 }; 19 | enum { ALREADY_PAIRING = 32 }; 20 | enum { MSG_INTERACTION_UNAVAILABLE = "This role-app pair is not available for use." }; 21 | enum { MSG_INTERACTION_QUOTA_REACHED = "More connections of this type not permitted." }; 22 | enum { MSG_START_PAIRED_RAPP_FAILED = "Failed to start the paired rapp." }; 23 | enum { MSG_ALREADY_PAIRING = "Already pairing, cannot start another pairing." }; 24 | 25 | ErrorCodes() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "rocon_interaction_msgs/ErrorCodes"; }; 42 | const char * getMD5(){ return "5137814d1764e0f595e2a0aeb307c101"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_interaction_msgs/Strings.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_interaction_msgs_Strings_h 2 | #define _ROS_rocon_interaction_msgs_Strings_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace rocon_interaction_msgs 10 | { 11 | 12 | class Strings : public ros::Msg 13 | { 14 | public: 15 | enum { REMOCONS_NAMESPACE = /remocons }; 16 | 17 | Strings() 18 | { 19 | } 20 | 21 | virtual int serialize(unsigned char *outbuffer) const 22 | { 23 | int offset = 0; 24 | return offset; 25 | } 26 | 27 | virtual int deserialize(unsigned char *inbuffer) 28 | { 29 | int offset = 0; 30 | return offset; 31 | } 32 | 33 | const char * getType(){ return "rocon_interaction_msgs/Strings"; }; 34 | const char * getMD5(){ return "7279ef1b62bbde7b3bec17766ef2c127"; }; 35 | 36 | }; 37 | 38 | } 39 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_service_pair_msgs/TestiesPair.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_service_pair_msgs_TestiesPair_h 2 | #define _ROS_rocon_service_pair_msgs_TestiesPair_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "rocon_service_pair_msgs/TestiesPairRequest.h" 9 | #include "rocon_service_pair_msgs/TestiesPairResponse.h" 10 | 11 | namespace rocon_service_pair_msgs 12 | { 13 | 14 | class TestiesPair : public ros::Msg 15 | { 16 | public: 17 | rocon_service_pair_msgs::TestiesPairRequest pair_request; 18 | rocon_service_pair_msgs::TestiesPairResponse pair_response; 19 | 20 | TestiesPair(): 21 | pair_request(), 22 | pair_response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->pair_request.serialize(outbuffer + offset); 30 | offset += this->pair_response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->pair_request.deserialize(inbuffer + offset); 38 | offset += this->pair_response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "rocon_service_pair_msgs/TestiesPair"; }; 43 | const char * getMD5(){ return "7b5cb9b4ccdb74840ce04ea92d2a141d"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_service_pair_msgs/TestiesPairRequest.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_service_pair_msgs_TestiesPairRequest_h 2 | #define _ROS_rocon_service_pair_msgs_TestiesPairRequest_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "rocon_service_pair_msgs/TestiesRequest.h" 10 | 11 | namespace rocon_service_pair_msgs 12 | { 13 | 14 | class TestiesPairRequest : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | rocon_service_pair_msgs::TestiesRequest request; 19 | 20 | TestiesPairRequest(): 21 | id(), 22 | request() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->request.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->request.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "rocon_service_pair_msgs/TestiesPairRequest"; }; 43 | const char * getMD5(){ return "71ec95e384ce52aa32491f3b69a62027"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_service_pair_msgs/TestiesPairResponse.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_service_pair_msgs_TestiesPairResponse_h 2 | #define _ROS_rocon_service_pair_msgs_TestiesPairResponse_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "rocon_service_pair_msgs/TestiesResponse.h" 10 | 11 | namespace rocon_service_pair_msgs 12 | { 13 | 14 | class TestiesPairResponse : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | rocon_service_pair_msgs::TestiesResponse response; 19 | 20 | TestiesPairResponse(): 21 | id(), 22 | response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "rocon_service_pair_msgs/TestiesPairResponse"; }; 43 | const char * getMD5(){ return "05404c9fe275eda57650fdfced8cf402"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_std_msgs/StringsPair.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_std_msgs_StringsPair_h 2 | #define _ROS_rocon_std_msgs_StringsPair_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "rocon_std_msgs/StringsPairRequest.h" 9 | #include "rocon_std_msgs/StringsPairResponse.h" 10 | 11 | namespace rocon_std_msgs 12 | { 13 | 14 | class StringsPair : public ros::Msg 15 | { 16 | public: 17 | rocon_std_msgs::StringsPairRequest pair_request; 18 | rocon_std_msgs::StringsPairResponse pair_response; 19 | 20 | StringsPair(): 21 | pair_request(), 22 | pair_response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->pair_request.serialize(outbuffer + offset); 30 | offset += this->pair_response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->pair_request.deserialize(inbuffer + offset); 38 | offset += this->pair_response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "rocon_std_msgs/StringsPair"; }; 43 | const char * getMD5(){ return "d41c9071bd514be249c417a13ec83e65"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_std_msgs/StringsPairRequest.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_std_msgs_StringsPairRequest_h 2 | #define _ROS_rocon_std_msgs_StringsPairRequest_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "rocon_std_msgs/StringsRequest.h" 10 | 11 | namespace rocon_std_msgs 12 | { 13 | 14 | class StringsPairRequest : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | rocon_std_msgs::StringsRequest request; 19 | 20 | StringsPairRequest(): 21 | id(), 22 | request() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->request.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->request.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "rocon_std_msgs/StringsPairRequest"; }; 43 | const char * getMD5(){ return "71ec95e384ce52aa32491f3b69a62027"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_std_msgs/StringsPairResponse.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_std_msgs_StringsPairResponse_h 2 | #define _ROS_rocon_std_msgs_StringsPairResponse_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "uuid_msgs/UniqueID.h" 9 | #include "rocon_std_msgs/StringsResponse.h" 10 | 11 | namespace rocon_std_msgs 12 | { 13 | 14 | class StringsPairResponse : public ros::Msg 15 | { 16 | public: 17 | uuid_msgs::UniqueID id; 18 | rocon_std_msgs::StringsResponse response; 19 | 20 | StringsPairResponse(): 21 | id(), 22 | response() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->id.serialize(outbuffer + offset); 30 | offset += this->response.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->id.deserialize(inbuffer + offset); 38 | offset += this->response.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "rocon_std_msgs/StringsPairResponse"; }; 43 | const char * getMD5(){ return "7b20492548347a7692aa8c5680af8d1b"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_std_msgs/StringsRequest.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_std_msgs_StringsRequest_h 2 | #define _ROS_rocon_std_msgs_StringsRequest_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace rocon_std_msgs 10 | { 11 | 12 | class StringsRequest : public ros::Msg 13 | { 14 | public: 15 | const char* data; 16 | 17 | StringsRequest(): 18 | data("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_data = strlen(this->data); 26 | memcpy(outbuffer + offset, &length_data, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->data, length_data); 29 | offset += length_data; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_data; 37 | memcpy(&length_data, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_data; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_data-1]=0; 43 | this->data = (char *)(inbuffer + offset-1); 44 | offset += length_data; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "rocon_std_msgs/StringsRequest"; }; 49 | const char * getMD5(){ return "992ce8a1687cec8c8bd883ec73ca41d1"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/rocon_std_msgs/StringsResponse.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_rocon_std_msgs_StringsResponse_h 2 | #define _ROS_rocon_std_msgs_StringsResponse_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace rocon_std_msgs 10 | { 11 | 12 | class StringsResponse : public ros::Msg 13 | { 14 | public: 15 | const char* data; 16 | 17 | StringsResponse(): 18 | data("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_data = strlen(this->data); 26 | memcpy(outbuffer + offset, &length_data, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->data, length_data); 29 | offset += length_data; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_data; 37 | memcpy(&length_data, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_data; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_data-1]=0; 43 | this->data = (char *)(inbuffer + offset-1); 44 | offset += length_data; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "rocon_std_msgs/StringsResponse"; }; 49 | const char * getMD5(){ return "992ce8a1687cec8c8bd883ec73ca41d1"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/roscpp/Empty.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_SERVICE_Empty_h 2 | #define _ROS_SERVICE_Empty_h 3 | #include 4 | #include 5 | #include 6 | #include "ros/msg.h" 7 | 8 | namespace roscpp 9 | { 10 | 11 | static const char EMPTY[] = "roscpp/Empty"; 12 | 13 | class EmptyRequest : public ros::Msg 14 | { 15 | public: 16 | 17 | EmptyRequest() 18 | { 19 | } 20 | 21 | virtual int serialize(unsigned char *outbuffer) const 22 | { 23 | int offset = 0; 24 | return offset; 25 | } 26 | 27 | virtual int deserialize(unsigned char *inbuffer) 28 | { 29 | int offset = 0; 30 | return offset; 31 | } 32 | 33 | const char * getType(){ return EMPTY; }; 34 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 35 | 36 | }; 37 | 38 | class EmptyResponse : public ros::Msg 39 | { 40 | public: 41 | 42 | EmptyResponse() 43 | { 44 | } 45 | 46 | virtual int serialize(unsigned char *outbuffer) const 47 | { 48 | int offset = 0; 49 | return offset; 50 | } 51 | 52 | virtual int deserialize(unsigned char *inbuffer) 53 | { 54 | int offset = 0; 55 | return offset; 56 | } 57 | 58 | const char * getType(){ return EMPTY; }; 59 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 60 | 61 | }; 62 | 63 | class Empty { 64 | public: 65 | typedef EmptyRequest Request; 66 | typedef EmptyResponse Response; 67 | }; 68 | 69 | } 70 | #endif 71 | -------------------------------------------------------------------------------- /embedded/ros_lib/sensor_msgs/FluidPressure.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_sensor_msgs_FluidPressure_h 2 | #define _ROS_sensor_msgs_FluidPressure_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | 10 | namespace sensor_msgs 11 | { 12 | 13 | class FluidPressure : public ros::Msg 14 | { 15 | public: 16 | std_msgs::Header header; 17 | float fluid_pressure; 18 | float variance; 19 | 20 | FluidPressure(): 21 | header(), 22 | fluid_pressure(0), 23 | variance(0) 24 | { 25 | } 26 | 27 | virtual int serialize(unsigned char *outbuffer) const 28 | { 29 | int offset = 0; 30 | offset += this->header.serialize(outbuffer + offset); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->fluid_pressure); 32 | offset += serializeAvrFloat64(outbuffer + offset, this->variance); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | offset += this->header.deserialize(inbuffer + offset); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->fluid_pressure)); 41 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->variance)); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "sensor_msgs/FluidPressure"; }; 46 | const char * getMD5(){ return "804dc5cea1c5306d6a2eb80b9833befe"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/sensor_msgs/Illuminance.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_sensor_msgs_Illuminance_h 2 | #define _ROS_sensor_msgs_Illuminance_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | 10 | namespace sensor_msgs 11 | { 12 | 13 | class Illuminance : public ros::Msg 14 | { 15 | public: 16 | std_msgs::Header header; 17 | float illuminance; 18 | float variance; 19 | 20 | Illuminance(): 21 | header(), 22 | illuminance(0), 23 | variance(0) 24 | { 25 | } 26 | 27 | virtual int serialize(unsigned char *outbuffer) const 28 | { 29 | int offset = 0; 30 | offset += this->header.serialize(outbuffer + offset); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->illuminance); 32 | offset += serializeAvrFloat64(outbuffer + offset, this->variance); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | offset += this->header.deserialize(inbuffer + offset); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->illuminance)); 41 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->variance)); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "sensor_msgs/Illuminance"; }; 46 | const char * getMD5(){ return "8cf5febb0952fca9d650c3d11a81a188"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/sensor_msgs/RelativeHumidity.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_sensor_msgs_RelativeHumidity_h 2 | #define _ROS_sensor_msgs_RelativeHumidity_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | 10 | namespace sensor_msgs 11 | { 12 | 13 | class RelativeHumidity : public ros::Msg 14 | { 15 | public: 16 | std_msgs::Header header; 17 | float relative_humidity; 18 | float variance; 19 | 20 | RelativeHumidity(): 21 | header(), 22 | relative_humidity(0), 23 | variance(0) 24 | { 25 | } 26 | 27 | virtual int serialize(unsigned char *outbuffer) const 28 | { 29 | int offset = 0; 30 | offset += this->header.serialize(outbuffer + offset); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->relative_humidity); 32 | offset += serializeAvrFloat64(outbuffer + offset, this->variance); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | offset += this->header.deserialize(inbuffer + offset); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->relative_humidity)); 41 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->variance)); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "sensor_msgs/RelativeHumidity"; }; 46 | const char * getMD5(){ return "8730015b05955b7e992ce29a2678d90f"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/sensor_msgs/Temperature.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_sensor_msgs_Temperature_h 2 | #define _ROS_sensor_msgs_Temperature_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | 10 | namespace sensor_msgs 11 | { 12 | 13 | class Temperature : public ros::Msg 14 | { 15 | public: 16 | std_msgs::Header header; 17 | float temperature; 18 | float variance; 19 | 20 | Temperature(): 21 | header(), 22 | temperature(0), 23 | variance(0) 24 | { 25 | } 26 | 27 | virtual int serialize(unsigned char *outbuffer) const 28 | { 29 | int offset = 0; 30 | offset += this->header.serialize(outbuffer + offset); 31 | offset += serializeAvrFloat64(outbuffer + offset, this->temperature); 32 | offset += serializeAvrFloat64(outbuffer + offset, this->variance); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | offset += this->header.deserialize(inbuffer + offset); 40 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->temperature)); 41 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->variance)); 42 | return offset; 43 | } 44 | 45 | const char * getType(){ return "sensor_msgs/Temperature"; }; 46 | const char * getMD5(){ return "ff71b307acdbe7c871a5a6d7ed359100"; }; 47 | 48 | }; 49 | 50 | } 51 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/shape_msgs/Plane.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_shape_msgs_Plane_h 2 | #define _ROS_shape_msgs_Plane_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace shape_msgs 10 | { 11 | 12 | class Plane : public ros::Msg 13 | { 14 | public: 15 | float coef[4]; 16 | 17 | Plane(): 18 | coef() 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | for( uint8_t i = 0; i < 4; i++){ 26 | offset += serializeAvrFloat64(outbuffer + offset, this->coef[i]); 27 | } 28 | return offset; 29 | } 30 | 31 | virtual int deserialize(unsigned char *inbuffer) 32 | { 33 | int offset = 0; 34 | for( uint8_t i = 0; i < 4; i++){ 35 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->coef[i])); 36 | } 37 | return offset; 38 | } 39 | 40 | const char * getType(){ return "shape_msgs/Plane"; }; 41 | const char * getMD5(){ return "2c1b92ed8f31492f8e73f6a4a44ca796"; }; 42 | 43 | }; 44 | 45 | } 46 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/Bool.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_Bool_h 2 | #define _ROS_std_msgs_Bool_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class Bool : public ros::Msg 13 | { 14 | public: 15 | bool data; 16 | 17 | Bool(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | union { 26 | bool real; 27 | uint8_t base; 28 | } u_data; 29 | u_data.real = this->data; 30 | *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF; 31 | offset += sizeof(this->data); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | union { 39 | bool real; 40 | uint8_t base; 41 | } u_data; 42 | u_data.base = 0; 43 | u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); 44 | this->data = u_data.real; 45 | offset += sizeof(this->data); 46 | return offset; 47 | } 48 | 49 | const char * getType(){ return "std_msgs/Bool"; }; 50 | const char * getMD5(){ return "8b94c1b53db61fb6aed406028ad6332a"; }; 51 | 52 | }; 53 | 54 | } 55 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/Byte.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_Byte_h 2 | #define _ROS_std_msgs_Byte_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class Byte : public ros::Msg 13 | { 14 | public: 15 | int8_t data; 16 | 17 | Byte(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | union { 26 | int8_t real; 27 | uint8_t base; 28 | } u_data; 29 | u_data.real = this->data; 30 | *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF; 31 | offset += sizeof(this->data); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | union { 39 | int8_t real; 40 | uint8_t base; 41 | } u_data; 42 | u_data.base = 0; 43 | u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); 44 | this->data = u_data.real; 45 | offset += sizeof(this->data); 46 | return offset; 47 | } 48 | 49 | const char * getType(){ return "std_msgs/Byte"; }; 50 | const char * getMD5(){ return "ad736a2e8818154c487bb80fe42ce43b"; }; 51 | 52 | }; 53 | 54 | } 55 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/Char.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_Char_h 2 | #define _ROS_std_msgs_Char_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class Char : public ros::Msg 13 | { 14 | public: 15 | uint8_t data; 16 | 17 | Char(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF; 26 | offset += sizeof(this->data); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | this->data = ((uint8_t) (*(inbuffer + offset))); 34 | offset += sizeof(this->data); 35 | return offset; 36 | } 37 | 38 | const char * getType(){ return "std_msgs/Char"; }; 39 | const char * getMD5(){ return "1bf77f25acecdedba0e224b162199717"; }; 40 | 41 | }; 42 | 43 | } 44 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/Empty.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_Empty_h 2 | #define _ROS_std_msgs_Empty_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class Empty : public ros::Msg 13 | { 14 | public: 15 | 16 | Empty() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "std_msgs/Empty"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/Float64.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_Float64_h 2 | #define _ROS_std_msgs_Float64_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class Float64 : public ros::Msg 13 | { 14 | public: 15 | float data; 16 | 17 | Float64(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | offset += serializeAvrFloat64(outbuffer + offset, this->data); 26 | return offset; 27 | } 28 | 29 | virtual int deserialize(unsigned char *inbuffer) 30 | { 31 | int offset = 0; 32 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->data)); 33 | return offset; 34 | } 35 | 36 | const char * getType(){ return "std_msgs/Float64"; }; 37 | const char * getMD5(){ return "fdb28210bfa9d7c91146260178d9a584"; }; 38 | 39 | }; 40 | 41 | } 42 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/Int16.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_Int16_h 2 | #define _ROS_std_msgs_Int16_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class Int16 : public ros::Msg 13 | { 14 | public: 15 | int16_t data; 16 | 17 | Int16(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | union { 26 | int16_t real; 27 | uint16_t base; 28 | } u_data; 29 | u_data.real = this->data; 30 | *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF; 31 | *(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF; 32 | offset += sizeof(this->data); 33 | return offset; 34 | } 35 | 36 | virtual int deserialize(unsigned char *inbuffer) 37 | { 38 | int offset = 0; 39 | union { 40 | int16_t real; 41 | uint16_t base; 42 | } u_data; 43 | u_data.base = 0; 44 | u_data.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0); 45 | u_data.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); 46 | this->data = u_data.real; 47 | offset += sizeof(this->data); 48 | return offset; 49 | } 50 | 51 | const char * getType(){ return "std_msgs/Int16"; }; 52 | const char * getMD5(){ return "8524586e34fbd7cb1c08c5f5f1ca0e57"; }; 53 | 54 | }; 55 | 56 | } 57 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/Int8.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_Int8_h 2 | #define _ROS_std_msgs_Int8_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class Int8 : public ros::Msg 13 | { 14 | public: 15 | int8_t data; 16 | 17 | Int8(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | union { 26 | int8_t real; 27 | uint8_t base; 28 | } u_data; 29 | u_data.real = this->data; 30 | *(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF; 31 | offset += sizeof(this->data); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | union { 39 | int8_t real; 40 | uint8_t base; 41 | } u_data; 42 | u_data.base = 0; 43 | u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); 44 | this->data = u_data.real; 45 | offset += sizeof(this->data); 46 | return offset; 47 | } 48 | 49 | const char * getType(){ return "std_msgs/Int8"; }; 50 | const char * getMD5(){ return "27ffa0c9c4b8fb8492252bcad9e5c57b"; }; 51 | 52 | }; 53 | 54 | } 55 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/String.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_String_h 2 | #define _ROS_std_msgs_String_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class String : public ros::Msg 13 | { 14 | public: 15 | const char* data; 16 | 17 | String(): 18 | data("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_data = strlen(this->data); 26 | memcpy(outbuffer + offset, &length_data, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->data, length_data); 29 | offset += length_data; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_data; 37 | memcpy(&length_data, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_data; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_data-1]=0; 43 | this->data = (char *)(inbuffer + offset-1); 44 | offset += length_data; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "std_msgs/String"; }; 49 | const char * getMD5(){ return "992ce8a1687cec8c8bd883ec73ca41d1"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/UInt16.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_UInt16_h 2 | #define _ROS_std_msgs_UInt16_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class UInt16 : public ros::Msg 13 | { 14 | public: 15 | uint16_t data; 16 | 17 | UInt16(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF; 26 | *(outbuffer + offset + 1) = (this->data >> (8 * 1)) & 0xFF; 27 | offset += sizeof(this->data); 28 | return offset; 29 | } 30 | 31 | virtual int deserialize(unsigned char *inbuffer) 32 | { 33 | int offset = 0; 34 | this->data = ((uint16_t) (*(inbuffer + offset))); 35 | this->data |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); 36 | offset += sizeof(this->data); 37 | return offset; 38 | } 39 | 40 | const char * getType(){ return "std_msgs/UInt16"; }; 41 | const char * getMD5(){ return "1df79edf208b629fe6b81923a544552d"; }; 42 | 43 | }; 44 | 45 | } 46 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/UInt32.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_UInt32_h 2 | #define _ROS_std_msgs_UInt32_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class UInt32 : public ros::Msg 13 | { 14 | public: 15 | uint32_t data; 16 | 17 | UInt32(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF; 26 | *(outbuffer + offset + 1) = (this->data >> (8 * 1)) & 0xFF; 27 | *(outbuffer + offset + 2) = (this->data >> (8 * 2)) & 0xFF; 28 | *(outbuffer + offset + 3) = (this->data >> (8 * 3)) & 0xFF; 29 | offset += sizeof(this->data); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | this->data = ((uint32_t) (*(inbuffer + offset))); 37 | this->data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 38 | this->data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 39 | this->data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 40 | offset += sizeof(this->data); 41 | return offset; 42 | } 43 | 44 | const char * getType(){ return "std_msgs/UInt32"; }; 45 | const char * getMD5(){ return "304a39449588c7f8ce2df6e8001c5fce"; }; 46 | 47 | }; 48 | 49 | } 50 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_msgs/UInt8.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_std_msgs_UInt8_h 2 | #define _ROS_std_msgs_UInt8_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace std_msgs 10 | { 11 | 12 | class UInt8 : public ros::Msg 13 | { 14 | public: 15 | uint8_t data; 16 | 17 | UInt8(): 18 | data(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | *(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF; 26 | offset += sizeof(this->data); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | this->data = ((uint8_t) (*(inbuffer + offset))); 34 | offset += sizeof(this->data); 35 | return offset; 36 | } 37 | 38 | const char * getType(){ return "std_msgs/UInt8"; }; 39 | const char * getMD5(){ return "7c8164229e7d2c17eb95e9231617fdee"; }; 40 | 41 | }; 42 | 43 | } 44 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/std_srvs/Empty.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_SERVICE_Empty_h 2 | #define _ROS_SERVICE_Empty_h 3 | #include 4 | #include 5 | #include 6 | #include "ros/msg.h" 7 | 8 | namespace std_srvs 9 | { 10 | 11 | static const char EMPTY[] = "std_srvs/Empty"; 12 | 13 | class EmptyRequest : public ros::Msg 14 | { 15 | public: 16 | 17 | EmptyRequest() 18 | { 19 | } 20 | 21 | virtual int serialize(unsigned char *outbuffer) const 22 | { 23 | int offset = 0; 24 | return offset; 25 | } 26 | 27 | virtual int deserialize(unsigned char *inbuffer) 28 | { 29 | int offset = 0; 30 | return offset; 31 | } 32 | 33 | const char * getType(){ return EMPTY; }; 34 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 35 | 36 | }; 37 | 38 | class EmptyResponse : public ros::Msg 39 | { 40 | public: 41 | 42 | EmptyResponse() 43 | { 44 | } 45 | 46 | virtual int serialize(unsigned char *outbuffer) const 47 | { 48 | int offset = 0; 49 | return offset; 50 | } 51 | 52 | virtual int deserialize(unsigned char *inbuffer) 53 | { 54 | int offset = 0; 55 | return offset; 56 | } 57 | 58 | const char * getType(){ return EMPTY; }; 59 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 60 | 61 | }; 62 | 63 | class Empty { 64 | public: 65 | typedef EmptyRequest Request; 66 | typedef EmptyResponse Response; 67 | }; 68 | 69 | } 70 | #endif 71 | -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/DeleteRobotFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_DeleteRobotFeedback_h 2 | #define _ROS_stdr_msgs_DeleteRobotFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace stdr_msgs 10 | { 11 | 12 | class DeleteRobotFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | DeleteRobotFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "stdr_msgs/DeleteRobotFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/DeleteRobotGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_DeleteRobotGoal_h 2 | #define _ROS_stdr_msgs_DeleteRobotGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace stdr_msgs 10 | { 11 | 12 | class DeleteRobotGoal : public ros::Msg 13 | { 14 | public: 15 | const char* name; 16 | 17 | DeleteRobotGoal(): 18 | name("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_name = strlen(this->name); 26 | memcpy(outbuffer + offset, &length_name, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->name, length_name); 29 | offset += length_name; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_name; 37 | memcpy(&length_name, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_name; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_name-1]=0; 43 | this->name = (char *)(inbuffer + offset-1); 44 | offset += length_name; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "stdr_msgs/DeleteRobotGoal"; }; 49 | const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/DeleteRobotResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_DeleteRobotResult_h 2 | #define _ROS_stdr_msgs_DeleteRobotResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace stdr_msgs 10 | { 11 | 12 | class DeleteRobotResult : public ros::Msg 13 | { 14 | public: 15 | bool success; 16 | 17 | DeleteRobotResult(): 18 | success(0) 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | union { 26 | bool real; 27 | uint8_t base; 28 | } u_success; 29 | u_success.real = this->success; 30 | *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF; 31 | offset += sizeof(this->success); 32 | return offset; 33 | } 34 | 35 | virtual int deserialize(unsigned char *inbuffer) 36 | { 37 | int offset = 0; 38 | union { 39 | bool real; 40 | uint8_t base; 41 | } u_success; 42 | u_success.base = 0; 43 | u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); 44 | this->success = u_success.real; 45 | offset += sizeof(this->success); 46 | return offset; 47 | } 48 | 49 | const char * getType(){ return "stdr_msgs/DeleteRobotResult"; }; 50 | const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; }; 51 | 52 | }; 53 | 54 | } 55 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/KinematicMsg.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_KinematicMsg_h 2 | #define _ROS_stdr_msgs_KinematicMsg_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace stdr_msgs 10 | { 11 | 12 | class KinematicMsg : public ros::Msg 13 | { 14 | public: 15 | const char* type; 16 | 17 | KinematicMsg(): 18 | type("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_type = strlen(this->type); 26 | memcpy(outbuffer + offset, &length_type, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->type, length_type); 29 | offset += length_type; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_type; 37 | memcpy(&length_type, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_type; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_type-1]=0; 43 | this->type = (char *)(inbuffer + offset-1); 44 | offset += length_type; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "stdr_msgs/KinematicMsg"; }; 49 | const char * getMD5(){ return "dc67331de85cf97091b7d45e5c64ab75"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/RegisterRobotFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_RegisterRobotFeedback_h 2 | #define _ROS_stdr_msgs_RegisterRobotFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace stdr_msgs 10 | { 11 | 12 | class RegisterRobotFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | RegisterRobotFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "stdr_msgs/RegisterRobotFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/RegisterRobotGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_RegisterRobotGoal_h 2 | #define _ROS_stdr_msgs_RegisterRobotGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace stdr_msgs 10 | { 11 | 12 | class RegisterRobotGoal : public ros::Msg 13 | { 14 | public: 15 | const char* name; 16 | 17 | RegisterRobotGoal(): 18 | name("") 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | uint32_t length_name = strlen(this->name); 26 | memcpy(outbuffer + offset, &length_name, sizeof(uint32_t)); 27 | offset += 4; 28 | memcpy(outbuffer + offset, this->name, length_name); 29 | offset += length_name; 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | uint32_t length_name; 37 | memcpy(&length_name, (inbuffer + offset), sizeof(uint32_t)); 38 | offset += 4; 39 | for(unsigned int k= offset; k< offset+length_name; ++k){ 40 | inbuffer[k-1]=inbuffer[k]; 41 | } 42 | inbuffer[offset+length_name-1]=0; 43 | this->name = (char *)(inbuffer + offset-1); 44 | offset += length_name; 45 | return offset; 46 | } 47 | 48 | const char * getType(){ return "stdr_msgs/RegisterRobotGoal"; }; 49 | const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; }; 50 | 51 | }; 52 | 53 | } 54 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/RegisterRobotResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_RegisterRobotResult_h 2 | #define _ROS_stdr_msgs_RegisterRobotResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "stdr_msgs/RobotMsg.h" 9 | 10 | namespace stdr_msgs 11 | { 12 | 13 | class RegisterRobotResult : public ros::Msg 14 | { 15 | public: 16 | stdr_msgs::RobotMsg description; 17 | 18 | RegisterRobotResult(): 19 | description() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->description.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->description.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "stdr_msgs/RegisterRobotResult"; }; 38 | const char * getMD5(){ return "32cb0b3594b0db40abbef43aeb506609"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/SpawnRobotFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_SpawnRobotFeedback_h 2 | #define _ROS_stdr_msgs_SpawnRobotFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace stdr_msgs 10 | { 11 | 12 | class SpawnRobotFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | SpawnRobotFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "stdr_msgs/SpawnRobotFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/stdr_msgs/SpawnRobotGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_stdr_msgs_SpawnRobotGoal_h 2 | #define _ROS_stdr_msgs_SpawnRobotGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "stdr_msgs/RobotMsg.h" 9 | 10 | namespace stdr_msgs 11 | { 12 | 13 | class SpawnRobotGoal : public ros::Msg 14 | { 15 | public: 16 | stdr_msgs::RobotMsg description; 17 | 18 | SpawnRobotGoal(): 19 | description() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->description.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->description.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "stdr_msgs/SpawnRobotGoal"; }; 38 | const char * getMD5(){ return "32cb0b3594b0db40abbef43aeb506609"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/tests/array_test/array_test.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial::geometry_msgs::PoseArray Test 3 | * Sums an array, publishes sum 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | 11 | ros::NodeHandle nh; 12 | 13 | 14 | bool set_; 15 | 16 | 17 | geometry_msgs::Pose sum_msg; 18 | ros::Publisher p("sum", &sum_msg); 19 | 20 | void messageCb(const geometry_msgs::PoseArray& msg){ 21 | sum_msg.position.x = 0; 22 | sum_msg.position.y = 0; 23 | sum_msg.position.z = 0; 24 | for(int i = 0; i < msg.poses_length; i++) 25 | { 26 | sum_msg.position.x += msg.poses[i].position.x; 27 | sum_msg.position.y += msg.poses[i].position.y; 28 | sum_msg.position.z += msg.poses[i].position.z; 29 | } 30 | digitalWrite(13, HIGH-digitalRead(13)); // blink the led 31 | } 32 | 33 | ros::Subscriber s("poses",messageCb); 34 | 35 | void setup() 36 | { 37 | pinMode(13, OUTPUT); 38 | nh.initNode(); 39 | nh.subscribe(s); 40 | nh.advertise(p); 41 | } 42 | 43 | void loop() 44 | { 45 | p.publish(&sum_msg); 46 | nh.spinOnce(); 47 | delay(10); 48 | } 49 | 50 | -------------------------------------------------------------------------------- /embedded/ros_lib/tests/float64_test/float64_test.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial::std_msgs::Float64 Test 3 | * Receives a Float64 input, subtracts 1.0, and publishes it 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | 10 | ros::NodeHandle nh; 11 | 12 | float x; 13 | 14 | void messageCb( const std_msgs::Float64& msg){ 15 | x = msg.data - 1.0; 16 | digitalWrite(13, HIGH-digitalRead(13)); // blink the led 17 | } 18 | 19 | std_msgs::Float64 test; 20 | ros::Subscriber s("your_topic", &messageCb); 21 | ros::Publisher p("my_topic", &test); 22 | 23 | void setup() 24 | { 25 | pinMode(13, OUTPUT); 26 | nh.initNode(); 27 | nh.advertise(p); 28 | nh.subscribe(s); 29 | } 30 | 31 | void loop() 32 | { 33 | test.data = x; 34 | p.publish( &test ); 35 | nh.spinOnce(); 36 | delay(10); 37 | } 38 | 39 | -------------------------------------------------------------------------------- /embedded/ros_lib/tests/time_test/time_test.pde: -------------------------------------------------------------------------------- 1 | /* 2 | * rosserial::std_msgs::Time Test 3 | * Publishes current time 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | 11 | ros::NodeHandle nh; 12 | 13 | std_msgs::Time test; 14 | ros::Publisher p("my_topic", &test); 15 | 16 | void setup() 17 | { 18 | pinMode(13, OUTPUT); 19 | nh.initNode(); 20 | nh.advertise(p); 21 | } 22 | 23 | void loop() 24 | { 25 | test.data = nh.now(); 26 | p.publish( &test ); 27 | nh.spinOnce(); 28 | delay(10); 29 | } 30 | 31 | -------------------------------------------------------------------------------- /embedded/ros_lib/tf2_msgs/LookupTransformFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_tf2_msgs_LookupTransformFeedback_h 2 | #define _ROS_tf2_msgs_LookupTransformFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace tf2_msgs 10 | { 11 | 12 | class LookupTransformFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | LookupTransformFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "tf2_msgs/LookupTransformFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/tf2_msgs/LookupTransformResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_tf2_msgs_LookupTransformResult_h 2 | #define _ROS_tf2_msgs_LookupTransformResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/TransformStamped.h" 9 | #include "tf2_msgs/TF2Error.h" 10 | 11 | namespace tf2_msgs 12 | { 13 | 14 | class LookupTransformResult : public ros::Msg 15 | { 16 | public: 17 | geometry_msgs::TransformStamped transform; 18 | tf2_msgs::TF2Error error; 19 | 20 | LookupTransformResult(): 21 | transform(), 22 | error() 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | offset += this->transform.serialize(outbuffer + offset); 30 | offset += this->error.serialize(outbuffer + offset); 31 | return offset; 32 | } 33 | 34 | virtual int deserialize(unsigned char *inbuffer) 35 | { 36 | int offset = 0; 37 | offset += this->transform.deserialize(inbuffer + offset); 38 | offset += this->error.deserialize(inbuffer + offset); 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "tf2_msgs/LookupTransformResult"; }; 43 | const char * getMD5(){ return "3fe5db6a19ca9cfb675418c5ad875c36"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/turtle_actionlib/ShapeFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_turtle_actionlib_ShapeFeedback_h 2 | #define _ROS_turtle_actionlib_ShapeFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace turtle_actionlib 10 | { 11 | 12 | class ShapeFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | ShapeFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "turtle_actionlib/ShapeFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/turtlebot_actions/FindFiducialFeedback.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_turtlebot_actions_FindFiducialFeedback_h 2 | #define _ROS_turtlebot_actions_FindFiducialFeedback_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace turtlebot_actions 10 | { 11 | 12 | class FindFiducialFeedback : public ros::Msg 13 | { 14 | public: 15 | 16 | FindFiducialFeedback() 17 | { 18 | } 19 | 20 | virtual int serialize(unsigned char *outbuffer) const 21 | { 22 | int offset = 0; 23 | return offset; 24 | } 25 | 26 | virtual int deserialize(unsigned char *inbuffer) 27 | { 28 | int offset = 0; 29 | return offset; 30 | } 31 | 32 | const char * getType(){ return "turtlebot_actions/FindFiducialFeedback"; }; 33 | const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; }; 34 | 35 | }; 36 | 37 | } 38 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/turtlebot_actions/FindFiducialResult.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_turtlebot_actions_FindFiducialResult_h 2 | #define _ROS_turtlebot_actions_FindFiducialResult_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "geometry_msgs/PoseStamped.h" 9 | 10 | namespace turtlebot_actions 11 | { 12 | 13 | class FindFiducialResult : public ros::Msg 14 | { 15 | public: 16 | geometry_msgs::PoseStamped pose; 17 | 18 | FindFiducialResult(): 19 | pose() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | offset += this->pose.serialize(outbuffer + offset); 27 | return offset; 28 | } 29 | 30 | virtual int deserialize(unsigned char *inbuffer) 31 | { 32 | int offset = 0; 33 | offset += this->pose.deserialize(inbuffer + offset); 34 | return offset; 35 | } 36 | 37 | const char * getType(){ return "turtlebot_actions/FindFiducialResult"; }; 38 | const char * getMD5(){ return "3f8930d968a3e84d471dff917bb1cdae"; }; 39 | 40 | }; 41 | 42 | } 43 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/turtlebot_calibration/ScanAngle.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_turtlebot_calibration_ScanAngle_h 2 | #define _ROS_turtlebot_calibration_ScanAngle_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | 10 | namespace turtlebot_calibration 11 | { 12 | 13 | class ScanAngle : public ros::Msg 14 | { 15 | public: 16 | std_msgs::Header header; 17 | float scan_angle; 18 | 19 | ScanAngle(): 20 | header(), 21 | scan_angle(0) 22 | { 23 | } 24 | 25 | virtual int serialize(unsigned char *outbuffer) const 26 | { 27 | int offset = 0; 28 | offset += this->header.serialize(outbuffer + offset); 29 | offset += serializeAvrFloat64(outbuffer + offset, this->scan_angle); 30 | return offset; 31 | } 32 | 33 | virtual int deserialize(unsigned char *inbuffer) 34 | { 35 | int offset = 0; 36 | offset += this->header.deserialize(inbuffer + offset); 37 | offset += deserializeAvrFloat64(inbuffer + offset, &(this->scan_angle)); 38 | return offset; 39 | } 40 | 41 | const char * getType(){ return "turtlebot_calibration/ScanAngle"; }; 42 | const char * getMD5(){ return "06e2c839dc5c7f5c13ac09a8b4ff0a6a"; }; 43 | 44 | }; 45 | 46 | } 47 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/turtlesim/Color.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_turtlesim_Color_h 2 | #define _ROS_turtlesim_Color_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace turtlesim 10 | { 11 | 12 | class Color : public ros::Msg 13 | { 14 | public: 15 | uint8_t r; 16 | uint8_t g; 17 | uint8_t b; 18 | 19 | Color(): 20 | r(0), 21 | g(0), 22 | b(0) 23 | { 24 | } 25 | 26 | virtual int serialize(unsigned char *outbuffer) const 27 | { 28 | int offset = 0; 29 | *(outbuffer + offset + 0) = (this->r >> (8 * 0)) & 0xFF; 30 | offset += sizeof(this->r); 31 | *(outbuffer + offset + 0) = (this->g >> (8 * 0)) & 0xFF; 32 | offset += sizeof(this->g); 33 | *(outbuffer + offset + 0) = (this->b >> (8 * 0)) & 0xFF; 34 | offset += sizeof(this->b); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | this->r = ((uint8_t) (*(inbuffer + offset))); 42 | offset += sizeof(this->r); 43 | this->g = ((uint8_t) (*(inbuffer + offset))); 44 | offset += sizeof(this->g); 45 | this->b = ((uint8_t) (*(inbuffer + offset))); 46 | offset += sizeof(this->b); 47 | return offset; 48 | } 49 | 50 | const char * getType(){ return "turtlesim/Color"; }; 51 | const char * getMD5(){ return "353891e354491c51aabe32df673fb446"; }; 52 | 53 | }; 54 | 55 | } 56 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/uuid_msgs/UniqueID.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_uuid_msgs_UniqueID_h 2 | #define _ROS_uuid_msgs_UniqueID_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace uuid_msgs 10 | { 11 | 12 | class UniqueID : public ros::Msg 13 | { 14 | public: 15 | uint8_t uuid[16]; 16 | 17 | UniqueID(): 18 | uuid() 19 | { 20 | } 21 | 22 | virtual int serialize(unsigned char *outbuffer) const 23 | { 24 | int offset = 0; 25 | for( uint8_t i = 0; i < 16; i++){ 26 | *(outbuffer + offset + 0) = (this->uuid[i] >> (8 * 0)) & 0xFF; 27 | offset += sizeof(this->uuid[i]); 28 | } 29 | return offset; 30 | } 31 | 32 | virtual int deserialize(unsigned char *inbuffer) 33 | { 34 | int offset = 0; 35 | for( uint8_t i = 0; i < 16; i++){ 36 | this->uuid[i] = ((uint8_t) (*(inbuffer + offset))); 37 | offset += sizeof(this->uuid[i]); 38 | } 39 | return offset; 40 | } 41 | 42 | const char * getType(){ return "uuid_msgs/UniqueID"; }; 43 | const char * getMD5(){ return "fec2a93b6f5367ee8112c9c0b41ff310"; }; 44 | 45 | }; 46 | 47 | } 48 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/yocs_msgs/LocalizeActionGoal.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_yocs_msgs_LocalizeActionGoal_h 2 | #define _ROS_yocs_msgs_LocalizeActionGoal_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | #include "std_msgs/Header.h" 9 | #include "actionlib_msgs/GoalID.h" 10 | #include "yocs_msgs/LocalizeGoal.h" 11 | 12 | namespace yocs_msgs 13 | { 14 | 15 | class LocalizeActionGoal : public ros::Msg 16 | { 17 | public: 18 | std_msgs::Header header; 19 | actionlib_msgs::GoalID goal_id; 20 | yocs_msgs::LocalizeGoal goal; 21 | 22 | LocalizeActionGoal(): 23 | header(), 24 | goal_id(), 25 | goal() 26 | { 27 | } 28 | 29 | virtual int serialize(unsigned char *outbuffer) const 30 | { 31 | int offset = 0; 32 | offset += this->header.serialize(outbuffer + offset); 33 | offset += this->goal_id.serialize(outbuffer + offset); 34 | offset += this->goal.serialize(outbuffer + offset); 35 | return offset; 36 | } 37 | 38 | virtual int deserialize(unsigned char *inbuffer) 39 | { 40 | int offset = 0; 41 | offset += this->header.deserialize(inbuffer + offset); 42 | offset += this->goal_id.deserialize(inbuffer + offset); 43 | offset += this->goal.deserialize(inbuffer + offset); 44 | return offset; 45 | } 46 | 47 | const char * getType(){ return "yocs_msgs/LocalizeActionGoal"; }; 48 | const char * getMD5(){ return "c021f63ac13aafbf2154fcd41de29d1e"; }; 49 | 50 | }; 51 | 52 | } 53 | #endif -------------------------------------------------------------------------------- /embedded/ros_lib/zeroconf_msgs/Protocols.h: -------------------------------------------------------------------------------- 1 | #ifndef _ROS_zeroconf_msgs_Protocols_h 2 | #define _ROS_zeroconf_msgs_Protocols_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include "ros/msg.h" 8 | 9 | namespace zeroconf_msgs 10 | { 11 | 12 | class Protocols : public ros::Msg 13 | { 14 | public: 15 | enum { UNSPECIFIED = 0 }; 16 | enum { IPV4 = 1 }; 17 | enum { IPV6 = 2 }; 18 | 19 | Protocols() 20 | { 21 | } 22 | 23 | virtual int serialize(unsigned char *outbuffer) const 24 | { 25 | int offset = 0; 26 | return offset; 27 | } 28 | 29 | virtual int deserialize(unsigned char *inbuffer) 30 | { 31 | int offset = 0; 32 | return offset; 33 | } 34 | 35 | const char * getType(){ return "zeroconf_msgs/Protocols"; }; 36 | const char * getMD5(){ return "6e173730dc50e42e6497a38ee52e9e4d"; }; 37 | 38 | }; 39 | 40 | } 41 | #endif -------------------------------------------------------------------------------- /launch/firebird.launch: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /msg/Aux.msg: -------------------------------------------------------------------------------- 1 | uint16 aux1 2 | uint16 aux2 -------------------------------------------------------------------------------- /msg/Battery.msg: -------------------------------------------------------------------------------- 1 | uint16 bat_volt -------------------------------------------------------------------------------- /msg/IR.msg: -------------------------------------------------------------------------------- 1 | uint16 ir1 2 | uint16 ir2 3 | uint16 ir3 4 | uint16 ir4 5 | uint16 ir5 6 | uint16 ir6 7 | uint16 ir7 8 | uint16 ir8 -------------------------------------------------------------------------------- /msg/Lcd.msg: -------------------------------------------------------------------------------- 1 | uint8 row 2 | uint8 col 3 | string val -------------------------------------------------------------------------------- /msg/Sensor.msg: -------------------------------------------------------------------------------- 1 | WLS wls 2 | Sharp sharp 3 | IR ir 4 | Battery battery 5 | Aux aux -------------------------------------------------------------------------------- /msg/Sharp.msg: -------------------------------------------------------------------------------- 1 | uint16 sharp1 2 | uint16 sharp2 3 | uint16 sharp3 4 | uint16 sharp4 5 | uint16 sharp5 -------------------------------------------------------------------------------- /msg/WLS.msg: -------------------------------------------------------------------------------- 1 | uint16 wls1 2 | uint16 wls2 3 | uint16 wls3 -------------------------------------------------------------------------------- /package.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | firebird 4 | 0.0.0 5 | The firebird package 6 | 7 | vikrant 8 | 9 | BSD 10 | 11 | 12 | https://github.com/badrobot15/firebird_ros 13 | 14 | 15 | Vikrant Fernandes 16 | 17 | 18 | message_generation 19 | message_runtime 20 | 21 | catkin 22 | roscpp 23 | rospy 24 | std_msgs 25 | roscpp 26 | rospy 27 | std_msgs 28 | roscpp 29 | rospy 30 | std_msgs 31 | 32 | 33 | 34 | 35 | --------------------------------------------------------------------------------