小乌龟控制完成

devel/.built_by

@@ -0,0 +1 @@
+catkin_make

devel/.catkin

@@ -0,0 +1 @@
+/home/zmn/下载/ros_turtlecontrol/src

devel/.rosinstall

@@ -0,0 +1,2 @@
+- setup-file:
+    local-name: /home/zmn/下载/ros_turtlecontrol/devel/setup.sh

devel/_setup_util.py

@@ -0,0 +1,304 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# Software License Agreement (BSD License)
+#
+# Copyright (c) 2012, Willow Garage, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above
+#    copyright notice, this list of conditions and the following
+#    disclaimer in the documentation and/or other materials provided
+#    with the distribution.
+#  * Neither the name of Willow Garage, Inc. nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""This file generates shell code for the setup.SHELL scripts to set environment variables."""
+
+from __future__ import print_function
+
+import argparse
+import copy
+import errno
+import os
+import platform
+import sys
+
+CATKIN_MARKER_FILE = '.catkin'
+
+system = platform.system()
+IS_DARWIN = (system == 'Darwin')
+IS_WINDOWS = (system == 'Windows')
+
+PATH_TO_ADD_SUFFIX = ['bin']
+if IS_WINDOWS:
+    # while catkin recommends putting dll's into bin, 3rd party packages often put dll's into lib
+    # since Windows finds dll's via the PATH variable, prepend it with path to lib
+    PATH_TO_ADD_SUFFIX.extend([['lib', os.path.join('lib', 'x86_64-linux-gnu')]])
+
+# subfolder of workspace prepended to CMAKE_PREFIX_PATH
+ENV_VAR_SUBFOLDERS = {
+    'CMAKE_PREFIX_PATH': '',
+    'LD_LIBRARY_PATH' if not IS_DARWIN else 'DYLD_LIBRARY_PATH': ['lib', os.path.join('lib', 'x86_64-linux-gnu')],
+    'PATH': PATH_TO_ADD_SUFFIX,
+    'PKG_CONFIG_PATH': [os.path.join('lib', 'pkgconfig'), os.path.join('lib', 'x86_64-linux-gnu', 'pkgconfig')],
+    'PYTHONPATH': 'lib/python3/dist-packages',
+}
+
+
+def rollback_env_variables(environ, env_var_subfolders):
+    """
+    Generate shell code to reset environment variables.
+
+    by unrolling modifications based on all workspaces in CMAKE_PREFIX_PATH.
+    This does not cover modifications performed by environment hooks.
+    """
+    lines = []
+    unmodified_environ = copy.copy(environ)
+    for key in sorted(env_var_subfolders.keys()):
+        subfolders = env_var_subfolders[key]
+        if not isinstance(subfolders, list):
+            subfolders = [subfolders]
+        value = _rollback_env_variable(unmodified_environ, key, subfolders)
+        if value is not None:
+            environ[key] = value
+            lines.append(assignment(key, value))
+    if lines:
+        lines.insert(0, comment('reset environment variables by unrolling modifications based on all workspaces in CMAKE_PREFIX_PATH'))
+    return lines
+
+
+def _rollback_env_variable(environ, name, subfolders):
+    """
+    For each catkin workspace in CMAKE_PREFIX_PATH remove the first entry from env[NAME] matching workspace + subfolder.
+
+    :param subfolders: list of str '' or subfoldername that may start with '/'
+    :returns: the updated value of the environment variable.
+    """
+    value = environ[name] if name in environ else ''
+    env_paths = [path for path in value.split(os.pathsep) if path]
+    value_modified = False
+    for subfolder in subfolders:
+        if subfolder:
+            if subfolder.startswith(os.path.sep) or (os.path.altsep and subfolder.startswith(os.path.altsep)):
+                subfolder = subfolder[1:]
+            if subfolder.endswith(os.path.sep) or (os.path.altsep and subfolder.endswith(os.path.altsep)):
+                subfolder = subfolder[:-1]
+        for ws_path in _get_workspaces(environ, include_fuerte=True, include_non_existing=True):
+            path_to_find = os.path.join(ws_path, subfolder) if subfolder else ws_path
+            path_to_remove = None
+            for env_path in env_paths:
+                env_path_clean = env_path[:-1] if env_path and env_path[-1] in [os.path.sep, os.path.altsep] else env_path
+                if env_path_clean == path_to_find:
+                    path_to_remove = env_path
+                    break
+            if path_to_remove:
+                env_paths.remove(path_to_remove)
+                value_modified = True
+    new_value = os.pathsep.join(env_paths)
+    return new_value if value_modified else None
+
+
+def _get_workspaces(environ, include_fuerte=False, include_non_existing=False):
+    """
+    Based on CMAKE_PREFIX_PATH return all catkin workspaces.
+
+    :param include_fuerte: The flag if paths starting with '/opt/ros/fuerte' should be considered workspaces, ``bool``
+    """
+    # get all cmake prefix paths
+    env_name = 'CMAKE_PREFIX_PATH'
+    value = environ[env_name] if env_name in environ else ''
+    paths = [path for path in value.split(os.pathsep) if path]
+    # remove non-workspace paths
+    workspaces = [path for path in paths if os.path.isfile(os.path.join(path, CATKIN_MARKER_FILE)) or (include_fuerte and path.startswith('/opt/ros/fuerte')) or (include_non_existing and not os.path.exists(path))]
+    return workspaces
+
+
+def prepend_env_variables(environ, env_var_subfolders, workspaces):
+    """Generate shell code to prepend environment variables for the all workspaces."""
+    lines = []
+    lines.append(comment('prepend folders of workspaces to environment variables'))
+
+    paths = [path for path in workspaces.split(os.pathsep) if path]
+
+    prefix = _prefix_env_variable(environ, 'CMAKE_PREFIX_PATH', paths, '')
+    lines.append(prepend(environ, 'CMAKE_PREFIX_PATH', prefix))
+
+    for key in sorted(key for key in env_var_subfolders.keys() if key != 'CMAKE_PREFIX_PATH'):
+        subfolder = env_var_subfolders[key]
+        prefix = _prefix_env_variable(environ, key, paths, subfolder)
+        lines.append(prepend(environ, key, prefix))
+    return lines
+
+
+def _prefix_env_variable(environ, name, paths, subfolders):
+    """
+    Return the prefix to prepend to the environment variable NAME.
+
+    Adding any path in NEW_PATHS_STR without creating duplicate or empty items.
+    """
+    value = environ[name] if name in environ else ''
+    environ_paths = [path for path in value.split(os.pathsep) if path]
+    checked_paths = []
+    for path in paths:
+        if not isinstance(subfolders, list):
+            subfolders = [subfolders]
+        for subfolder in subfolders:
+            path_tmp = path
+            if subfolder:
+                path_tmp = os.path.join(path_tmp, subfolder)
+            # skip nonexistent paths
+            if not os.path.exists(path_tmp):
+                continue
+            # exclude any path already in env and any path we already added
+            if path_tmp not in environ_paths and path_tmp not in checked_paths:
+                checked_paths.append(path_tmp)
+    prefix_str = os.pathsep.join(checked_paths)
+    if prefix_str != '' and environ_paths:
+        prefix_str += os.pathsep
+    return prefix_str
+
+
+def assignment(key, value):
+    if not IS_WINDOWS:
+        return 'export %s="%s"' % (key, value)
+    else:
+        return 'set %s=%s' % (key, value)
+
+
+def comment(msg):
+    if not IS_WINDOWS:
+        return '# %s' % msg
+    else:
+        return 'REM %s' % msg
+
+
+def prepend(environ, key, prefix):
+    if key not in environ or not environ[key]:
+        return assignment(key, prefix)
+    if not IS_WINDOWS:
+        return 'export %s="%s$%s"' % (key, prefix, key)
+    else:
+        return 'set %s=%s%%%s%%' % (key, prefix, key)
+
+
+def find_env_hooks(environ, cmake_prefix_path):
+    """Generate shell code with found environment hooks for the all workspaces."""
+    lines = []
+    lines.append(comment('found environment hooks in workspaces'))
+
+    generic_env_hooks = []
+    generic_env_hooks_workspace = []
+    specific_env_hooks = []
+    specific_env_hooks_workspace = []
+    generic_env_hooks_by_filename = {}
+    specific_env_hooks_by_filename = {}
+    generic_env_hook_ext = 'bat' if IS_WINDOWS else 'sh'
+    specific_env_hook_ext = environ['CATKIN_SHELL'] if not IS_WINDOWS and 'CATKIN_SHELL' in environ and environ['CATKIN_SHELL'] else None
+    # remove non-workspace paths
+    workspaces = [path for path in cmake_prefix_path.split(os.pathsep) if path and os.path.isfile(os.path.join(path, CATKIN_MARKER_FILE))]
+    for workspace in reversed(workspaces):
+        env_hook_dir = os.path.join(workspace, 'etc', 'catkin', 'profile.d')
+        if os.path.isdir(env_hook_dir):
+            for filename in sorted(os.listdir(env_hook_dir)):
+                if filename.endswith('.%s' % generic_env_hook_ext):
+                    # remove previous env hook with same name if present
+                    if filename in generic_env_hooks_by_filename:
+                        i = generic_env_hooks.index(generic_env_hooks_by_filename[filename])
+                        generic_env_hooks.pop(i)
+                        generic_env_hooks_workspace.pop(i)
+                    # append env hook
+                    generic_env_hooks.append(os.path.join(env_hook_dir, filename))
+                    generic_env_hooks_workspace.append(workspace)
+                    generic_env_hooks_by_filename[filename] = generic_env_hooks[-1]
+                elif specific_env_hook_ext is not None and filename.endswith('.%s' % specific_env_hook_ext):
+                    # remove previous env hook with same name if present
+                    if filename in specific_env_hooks_by_filename:
+                        i = specific_env_hooks.index(specific_env_hooks_by_filename[filename])
+                        specific_env_hooks.pop(i)
+                        specific_env_hooks_workspace.pop(i)
+                    # append env hook
+                    specific_env_hooks.append(os.path.join(env_hook_dir, filename))
+                    specific_env_hooks_workspace.append(workspace)
+                    specific_env_hooks_by_filename[filename] = specific_env_hooks[-1]
+    env_hooks = generic_env_hooks + specific_env_hooks
+    env_hooks_workspace = generic_env_hooks_workspace + specific_env_hooks_workspace
+    count = len(env_hooks)
+    lines.append(assignment('_CATKIN_ENVIRONMENT_HOOKS_COUNT', count))
+    for i in range(count):
+        lines.append(assignment('_CATKIN_ENVIRONMENT_HOOKS_%d' % i, env_hooks[i]))
+        lines.append(assignment('_CATKIN_ENVIRONMENT_HOOKS_%d_WORKSPACE' % i, env_hooks_workspace[i]))
+    return lines
+
+
+def _parse_arguments(args=None):
+    parser = argparse.ArgumentParser(description='Generates code blocks for the setup.SHELL script.')
+    parser.add_argument('--extend', action='store_true', help='Skip unsetting previous environment variables to extend context')
+    parser.add_argument('--local', action='store_true', help='Only consider this prefix path and ignore other prefix path in the environment')
+    return parser.parse_known_args(args=args)[0]
+
+
+if __name__ == '__main__':
+    try:
+        try:
+            args = _parse_arguments()
+        except Exception as e:
+            print(e, file=sys.stderr)
+            sys.exit(1)
+
+        if not args.local:
+            # environment at generation time
+            CMAKE_PREFIX_PATH = r'/opt/ros/noetic'.split(';')
+        else:
+            # don't consider any other prefix path than this one
+            CMAKE_PREFIX_PATH = []
+        # prepend current workspace if not already part of CPP
+        base_path = os.path.dirname(__file__)
+        # CMAKE_PREFIX_PATH uses forward slash on all platforms, but __file__ is platform dependent
+        # base_path on Windows contains backward slashes, need to be converted to forward slashes before comparison
+        if os.path.sep != '/':
+            base_path = base_path.replace(os.path.sep, '/')
+
+        if base_path not in CMAKE_PREFIX_PATH:
+            CMAKE_PREFIX_PATH.insert(0, base_path)
+        CMAKE_PREFIX_PATH = os.pathsep.join(CMAKE_PREFIX_PATH)
+
+        environ = dict(os.environ)
+        lines = []
+        if not args.extend:
+            lines += rollback_env_variables(environ, ENV_VAR_SUBFOLDERS)
+        lines += prepend_env_variables(environ, ENV_VAR_SUBFOLDERS, CMAKE_PREFIX_PATH)
+        lines += find_env_hooks(environ, CMAKE_PREFIX_PATH)
+        print('\n'.join(lines))
+
+        # need to explicitly flush the output
+        sys.stdout.flush()
+    except IOError as e:
+        # and catch potential "broken pipe" if stdout is not writable
+        # which can happen when piping the output to a file but the disk is full
+        if e.errno == errno.EPIPE:
+            print(e, file=sys.stderr)
+            sys.exit(2)
+        raise
+
+    sys.exit(0)

devel/env.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env sh
+# generated from catkin/cmake/templates/env.sh.in
+
+if [ $# -eq 0 ] ; then
+  /bin/echo "Usage: env.sh COMMANDS"
+  /bin/echo "Calling env.sh without arguments is not supported anymore. Instead spawn a subshell and source a setup file manually."
+  exit 1
+fi
+
+# ensure to not use different shell type which was set before
+CATKIN_SHELL=sh
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(cd "`dirname "$0"`" > /dev/null && pwd)
+. "$_CATKIN_SETUP_DIR/setup.sh"
+exec "$@"

devel/include/Aee1220310013/ProcessID.h

@@ -0,0 +1,123 @@
+// Generated by gencpp from file Aee1220310013/ProcessID.msg
+// DO NOT EDIT!
+
+
+#ifndef AEE1220310013_MESSAGE_PROCESSID_H
+#define AEE1220310013_MESSAGE_PROCESSID_H
+
+#include <ros/service_traits.h>
+
+
+#include <Aee1220310013/ProcessIDRequest.h>
+#include <Aee1220310013/ProcessIDResponse.h>
+
+
+namespace Aee1220310013
+{
+
+struct ProcessID
+{
+
+typedef ProcessIDRequest Request;
+typedef ProcessIDResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct ProcessID
+} // namespace Aee1220310013
+
+
+namespace ros
+{
+namespace service_traits
+{
+
+
+template<>
+struct MD5Sum< ::Aee1220310013::ProcessID > {
+  static const char* value()
+  {
+    return "e7263169494a43b7a316d7ec3753d546";
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessID&) { return value(); }
+};
+
+template<>
+struct DataType< ::Aee1220310013::ProcessID > {
+  static const char* value()
+  {
+    return "Aee1220310013/ProcessID";
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessID&) { return value(); }
+};
+
+
+// service_traits::MD5Sum< ::Aee1220310013::ProcessIDRequest> should match
+// service_traits::MD5Sum< ::Aee1220310013::ProcessID >
+template<>
+struct MD5Sum< ::Aee1220310013::ProcessIDRequest>
+{
+  static const char* value()
+  {
+    return MD5Sum< ::Aee1220310013::ProcessID >::value();
+  }
+  static const char* value(const ::Aee1220310013::ProcessIDRequest&)
+  {
+    return value();
+  }
+};
+
+// service_traits::DataType< ::Aee1220310013::ProcessIDRequest> should match
+// service_traits::DataType< ::Aee1220310013::ProcessID >
+template<>
+struct DataType< ::Aee1220310013::ProcessIDRequest>
+{
+  static const char* value()
+  {
+    return DataType< ::Aee1220310013::ProcessID >::value();
+  }
+  static const char* value(const ::Aee1220310013::ProcessIDRequest&)
+  {
+    return value();
+  }
+};
+
+// service_traits::MD5Sum< ::Aee1220310013::ProcessIDResponse> should match
+// service_traits::MD5Sum< ::Aee1220310013::ProcessID >
+template<>
+struct MD5Sum< ::Aee1220310013::ProcessIDResponse>
+{
+  static const char* value()
+  {
+    return MD5Sum< ::Aee1220310013::ProcessID >::value();
+  }
+  static const char* value(const ::Aee1220310013::ProcessIDResponse&)
+  {
+    return value();
+  }
+};
+
+// service_traits::DataType< ::Aee1220310013::ProcessIDResponse> should match
+// service_traits::DataType< ::Aee1220310013::ProcessID >
+template<>
+struct DataType< ::Aee1220310013::ProcessIDResponse>
+{
+  static const char* value()
+  {
+    return DataType< ::Aee1220310013::ProcessID >::value();
+  }
+  static const char* value(const ::Aee1220310013::ProcessIDResponse&)
+  {
+    return value();
+  }
+};
+
+} // namespace service_traits
+} // namespace ros
+
+#endif // AEE1220310013_MESSAGE_PROCESSID_H

devel/include/Aee1220310013/ProcessIDRequest.h

@@ -0,0 +1,197 @@
+// Generated by gencpp from file Aee1220310013/ProcessIDRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef AEE1220310013_MESSAGE_PROCESSIDREQUEST_H
+#define AEE1220310013_MESSAGE_PROCESSIDREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace Aee1220310013
+{
+template <class ContainerAllocator>
+struct ProcessIDRequest_
+{
+  typedef ProcessIDRequest_<ContainerAllocator> Type;
+
+  ProcessIDRequest_()
+    : student_id()  {
+    }
+  ProcessIDRequest_(const ContainerAllocator& _alloc)
+    : student_id(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _student_id_type;
+  _student_id_type student_id;
+
+
+
+
+
+  typedef boost::shared_ptr< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct ProcessIDRequest_
+
+typedef ::Aee1220310013::ProcessIDRequest_<std::allocator<void> > ProcessIDRequest;
+
+typedef boost::shared_ptr< ::Aee1220310013::ProcessIDRequest > ProcessIDRequestPtr;
+typedef boost::shared_ptr< ::Aee1220310013::ProcessIDRequest const> ProcessIDRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator1> & lhs, const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.student_id == rhs.student_id;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator1> & lhs, const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace Aee1220310013
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "372af5010cb802275110c9bd017544b8";
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x372af5010cb80227ULL;
+  static const uint64_t static_value2 = 0x5110c9bd017544b8ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "Aee1220310013/ProcessIDRequest";
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "string student_id\n"
+;
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.student_id);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct ProcessIDRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::Aee1220310013::ProcessIDRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::Aee1220310013::ProcessIDRequest_<ContainerAllocator>& v)
+  {
+    if (false || !indent.empty())
+      s << std::endl;
+    s << indent << "student_id: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.student_id);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // AEE1220310013_MESSAGE_PROCESSIDREQUEST_H

devel/include/Aee1220310013/ProcessIDResponse.h

@@ -0,0 +1,233 @@
+// Generated by gencpp from file Aee1220310013/ProcessIDResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef AEE1220310013_MESSAGE_PROCESSIDRESPONSE_H
+#define AEE1220310013_MESSAGE_PROCESSIDRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace Aee1220310013
+{
+template <class ContainerAllocator>
+struct ProcessIDResponse_
+{
+  typedef ProcessIDResponse_<ContainerAllocator> Type;
+
+  ProcessIDResponse_()
+    : x(0.0)
+    , y(0.0)
+    , radius(0.0)
+    , direction(0)  {
+    }
+  ProcessIDResponse_(const ContainerAllocator& _alloc)
+    : x(0.0)
+    , y(0.0)
+    , radius(0.0)
+    , direction(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef float _x_type;
+  _x_type x;
+
+   typedef float _y_type;
+  _y_type y;
+
+   typedef float _radius_type;
+  _radius_type radius;
+
+   typedef int32_t _direction_type;
+  _direction_type direction;
+
+
+
+
+
+  typedef boost::shared_ptr< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct ProcessIDResponse_
+
+typedef ::Aee1220310013::ProcessIDResponse_<std::allocator<void> > ProcessIDResponse;
+
+typedef boost::shared_ptr< ::Aee1220310013::ProcessIDResponse > ProcessIDResponsePtr;
+typedef boost::shared_ptr< ::Aee1220310013::ProcessIDResponse const> ProcessIDResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator1> & lhs, const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.x == rhs.x &&
+    lhs.y == rhs.y &&
+    lhs.radius == rhs.radius &&
+    lhs.direction == rhs.direction;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator1> & lhs, const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace Aee1220310013
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "deec39c810656f01d6b1be82e15bf4e7";
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xdeec39c810656f01ULL;
+  static const uint64_t static_value2 = 0xd6b1be82e15bf4e7ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "Aee1220310013/ProcessIDResponse";
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "float32 x\n"
+"float32 y\n"
+"float32 radius\n"
+"int32 direction\n"
+;
+  }
+
+  static const char* value(const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.x);
+      stream.next(m.y);
+      stream.next(m.radius);
+      stream.next(m.direction);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct ProcessIDResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::Aee1220310013::ProcessIDResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::Aee1220310013::ProcessIDResponse_<ContainerAllocator>& v)
+  {
+    if (false || !indent.empty())
+      s << std::endl;
+    s << indent << "x: ";
+    Printer<float>::stream(s, indent + "  ", v.x);
+    if (true || !indent.empty())
+      s << std::endl;
+    s << indent << "y: ";
+    Printer<float>::stream(s, indent + "  ", v.y);
+    if (true || !indent.empty())
+      s << std::endl;
+    s << indent << "radius: ";
+    Printer<float>::stream(s, indent + "  ", v.radius);
+    if (true || !indent.empty())
+      s << std::endl;
+    s << indent << "direction: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.direction);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // AEE1220310013_MESSAGE_PROCESSIDRESPONSE_H

devel/lib/pkgconfig/Aee1220310013.pc

@@ -0,0 +1,8 @@
+prefix=/home/zmn/下载/ros_turtlecontrol/devel
+
+Name: Aee1220310013
+Description: Description of Aee1220310013
+Version: 0.0.0
+Cflags: -I/home/zmn/下载/ros_turtlecontrol/devel/include
+Libs: -L${prefix}/lib 
+Requires: 

devel/lib/python3/dist-packages/Aee1220310013/srv/_ProcessID.py

@@ -0,0 +1,259 @@
+# This Python file uses the following encoding: utf-8
+"""autogenerated by genpy from Aee1220310013/ProcessIDRequest.msg. Do not edit."""
+import codecs
+import sys
+python3 = True if sys.hexversion > 0x03000000 else False
+import genpy
+import struct
+
+
+class ProcessIDRequest(genpy.Message):
+  _md5sum = "372af5010cb802275110c9bd017544b8"
+  _type = "Aee1220310013/ProcessIDRequest"
+  _has_header = False  # flag to mark the presence of a Header object
+  _full_text = """string student_id
+"""
+  __slots__ = ['student_id']
+  _slot_types = ['string']
+
+  def __init__(self, *args, **kwds):
+    """
+    Constructor. Any message fields that are implicitly/explicitly
+    set to None will be assigned a default value. The recommend
+    use is keyword arguments as this is more robust to future message
+    changes.  You cannot mix in-order arguments and keyword arguments.
+
+    The available fields are:
+       student_id
+
+    :param args: complete set of field values, in .msg order
+    :param kwds: use keyword arguments corresponding to message field names
+    to set specific fields.
+    """
+    if args or kwds:
+      super(ProcessIDRequest, self).__init__(*args, **kwds)
+      # message fields cannot be None, assign default values for those that are
+      if self.student_id is None:
+        self.student_id = ''
+    else:
+      self.student_id = ''
+
+  def _get_types(self):
+    """
+    internal API method
+    """
+    return self._slot_types
+
+  def serialize(self, buff):
+    """
+    serialize message into buffer
+    :param buff: buffer, ``StringIO``
+    """
+    try:
+      _x = self.student_id
+      length = len(_x)
+      if python3 or type(_x) == unicode:
+        _x = _x.encode('utf-8')
+        length = len(_x)
+      buff.write(struct.Struct('<I%ss'%length).pack(length, _x))
+    except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
+    except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
+
+  def deserialize(self, str):
+    """
+    unpack serialized message in str into this message instance
+    :param str: byte array of serialized message, ``str``
+    """
+    if python3:
+      codecs.lookup_error("rosmsg").msg_type = self._type
+    try:
+      end = 0
+      start = end
+      end += 4
+      (length,) = _struct_I.unpack(str[start:end])
+      start = end
+      end += length
+      if python3:
+        self.student_id = str[start:end].decode('utf-8', 'rosmsg')
+      else:
+        self.student_id = str[start:end]
+      return self
+    except struct.error as e:
+      raise genpy.DeserializationError(e)  # most likely buffer underfill
+
+
+  def serialize_numpy(self, buff, numpy):
+    """
+    serialize message with numpy array types into buffer
+    :param buff: buffer, ``StringIO``
+    :param numpy: numpy python module
+    """
+    try:
+      _x = self.student_id
+      length = len(_x)
+      if python3 or type(_x) == unicode:
+        _x = _x.encode('utf-8')
+        length = len(_x)
+      buff.write(struct.Struct('<I%ss'%length).pack(length, _x))
+    except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
+    except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
+
+  def deserialize_numpy(self, str, numpy):
+    """
+    unpack serialized message in str into this message instance using numpy for array types
+    :param str: byte array of serialized message, ``str``
+    :param numpy: numpy python module
+    """
+    if python3:
+      codecs.lookup_error("rosmsg").msg_type = self._type
+    try:
+      end = 0
+      start = end
+      end += 4
+      (length,) = _struct_I.unpack(str[start:end])
+      start = end
+      end += length
+      if python3:
+        self.student_id = str[start:end].decode('utf-8', 'rosmsg')
+      else:
+        self.student_id = str[start:end]
+      return self
+    except struct.error as e:
+      raise genpy.DeserializationError(e)  # most likely buffer underfill
+
+_struct_I = genpy.struct_I
+def _get_struct_I():
+    global _struct_I
+    return _struct_I
+# This Python file uses the following encoding: utf-8
+"""autogenerated by genpy from Aee1220310013/ProcessIDResponse.msg. Do not edit."""
+import codecs
+import sys
+python3 = True if sys.hexversion > 0x03000000 else False
+import genpy
+import struct
+
+
+class ProcessIDResponse(genpy.Message):
+  _md5sum = "deec39c810656f01d6b1be82e15bf4e7"
+  _type = "Aee1220310013/ProcessIDResponse"
+  _has_header = False  # flag to mark the presence of a Header object
+  _full_text = """float32 x
+float32 y
+float32 radius
+int32 direction
+"""
+  __slots__ = ['x','y','radius','direction']
+  _slot_types = ['float32','float32','float32','int32']
+
+  def __init__(self, *args, **kwds):
+    """
+    Constructor. Any message fields that are implicitly/explicitly
+    set to None will be assigned a default value. The recommend
+    use is keyword arguments as this is more robust to future message
+    changes.  You cannot mix in-order arguments and keyword arguments.
+
+    The available fields are:
+       x,y,radius,direction
+
+    :param args: complete set of field values, in .msg order
+    :param kwds: use keyword arguments corresponding to message field names
+    to set specific fields.
+    """
+    if args or kwds:
+      super(ProcessIDResponse, self).__init__(*args, **kwds)
+      # message fields cannot be None, assign default values for those that are
+      if self.x is None:
+        self.x = 0.
+      if self.y is None:
+        self.y = 0.
+      if self.radius is None:
+        self.radius = 0.
+      if self.direction is None:
+        self.direction = 0
+    else:
+      self.x = 0.
+      self.y = 0.
+      self.radius = 0.
+      self.direction = 0
+
+  def _get_types(self):
+    """
+    internal API method
+    """
+    return self._slot_types
+
+  def serialize(self, buff):
+    """
+    serialize message into buffer
+    :param buff: buffer, ``StringIO``
+    """
+    try:
+      _x = self
+      buff.write(_get_struct_3fi().pack(_x.x, _x.y, _x.radius, _x.direction))
+    except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
+    except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
+
+  def deserialize(self, str):
+    """
+    unpack serialized message in str into this message instance
+    :param str: byte array of serialized message, ``str``
+    """
+    if python3:
+      codecs.lookup_error("rosmsg").msg_type = self._type
+    try:
+      end = 0
+      _x = self
+      start = end
+      end += 16
+      (_x.x, _x.y, _x.radius, _x.direction,) = _get_struct_3fi().unpack(str[start:end])
+      return self
+    except struct.error as e:
+      raise genpy.DeserializationError(e)  # most likely buffer underfill
+
+
+  def serialize_numpy(self, buff, numpy):
+    """
+    serialize message with numpy array types into buffer
+    :param buff: buffer, ``StringIO``
+    :param numpy: numpy python module
+    """
+    try:
+      _x = self
+      buff.write(_get_struct_3fi().pack(_x.x, _x.y, _x.radius, _x.direction))
+    except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
+    except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
+
+  def deserialize_numpy(self, str, numpy):
+    """
+    unpack serialized message in str into this message instance using numpy for array types
+    :param str: byte array of serialized message, ``str``
+    :param numpy: numpy python module
+    """
+    if python3:
+      codecs.lookup_error("rosmsg").msg_type = self._type
+    try:
+      end = 0
+      _x = self
+      start = end
+      end += 16
+      (_x.x, _x.y, _x.radius, _x.direction,) = _get_struct_3fi().unpack(str[start:end])
+      return self
+    except struct.error as e:
+      raise genpy.DeserializationError(e)  # most likely buffer underfill
+
+_struct_I = genpy.struct_I
+def _get_struct_I():
+    global _struct_I
+    return _struct_I
+_struct_3fi = None
+def _get_struct_3fi():
+    global _struct_3fi
+    if _struct_3fi is None:
+        _struct_3fi = struct.Struct("<3fi")
+    return _struct_3fi
+class ProcessID(object):
+  _type          = 'Aee1220310013/ProcessID'
+  _md5sum = 'e7263169494a43b7a316d7ec3753d546'
+  _request_class  = ProcessIDRequest
+  _response_class = ProcessIDResponse

devel/lib/python3/dist-packages/Aee1220310013/srv/__init__.py

@@ -0,0 +1 @@
+from ._ProcessID import *

devel/local_setup.bash

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# generated from catkin/cmake/templates/local_setup.bash.in
+
+CATKIN_SHELL=bash
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd "`dirname "${BASH_SOURCE[0]}"`" > /dev/null && pwd)
+. "$_CATKIN_SETUP_DIR/setup.sh" --extend --local

devel/local_setup.fish

@@ -0,0 +1,14 @@
+#!/usr/bin/env fish
+# generated from catkin/cmake/template/local_setup.fish.in
+
+# since this file is sourced either use the provided _CATKIN_SETUP_DIR
+# or fall back to the destination set at configure time
+
+if test -z $_CATKIN_SETUP_DIR
+    set _CATKIN_SETUP_DIR /home/zmn/下载/ros_turtlecontrol/devel
+end
+
+set CATKIN_SETUP_UTIL_ARGS "--extend --local"
+source "$_CATKIN_SETUP_DIR/setup.fish"
+
+set -e CATKIN_SETUP_UTIL_ARGS

devel/local_setup.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+# generated from catkin/cmake/template/local_setup.sh.in
+
+# since this file is sourced either use the provided _CATKIN_SETUP_DIR
+# or fall back to the destination set at configure time
+: ${_CATKIN_SETUP_DIR:=/home/zmn/下载/ros_turtlecontrol/devel}
+CATKIN_SETUP_UTIL_ARGS="--extend --local"
+. "$_CATKIN_SETUP_DIR/setup.sh"
+unset CATKIN_SETUP_UTIL_ARGS

devel/local_setup.zsh

@@ -0,0 +1,8 @@
+#!/usr/bin/env zsh
+# generated from catkin/cmake/templates/local_setup.zsh.in
+
+CATKIN_SHELL=zsh
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd -q "`dirname "$0"`" > /dev/null && pwd)
+emulate -R zsh -c 'source "$_CATKIN_SETUP_DIR/setup.sh" --extend --local'

devel/setup.bash

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# generated from catkin/cmake/templates/setup.bash.in
+
+CATKIN_SHELL=bash
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd "`dirname "${BASH_SOURCE[0]}"`" > /dev/null && pwd)
+. "$_CATKIN_SETUP_DIR/setup.sh"

devel/setup.fish

@@ -0,0 +1,129 @@
+#!/usr/bin/env fish
+# generated from catkin/cmake/template/setup.fish.in
+
+# Sets various environment variables and sources additional environment hooks.
+# It tries it's best to undo changes from a previously sourced setup file before.
+# Supported command line options:
+# --extend: skips the undoing of changes from a previously sourced setup file
+# --local: only considers this workspace but not the chained ones
+# In plain sh shell which doesn't support arguments for sourced scripts you can
+# set the environment variable `CATKIN_SETUP_UTIL_ARGS=--extend/--local` instead.
+
+# since this file is sourced either use the provided _CATKIN_SETUP_DIR
+# or fall back to the destination set at configure time
+
+if not type -q bass
+    echo "Missing required fish plugin: bass. See https://github.com/edc/bass"
+    exit 22
+end
+
+if test -z $_CATKIN_SETUP_DIR
+    set _CATKIN_SETUP_DIR /home/zmn/下载/ros_turtlecontrol/devel
+end
+
+set _SETUP_UTIL "$_CATKIN_SETUP_DIR/_setup_util.py"
+set -e _CATKIN_SETUP_DIR
+
+if not test -f "$_SETUP_UTIL"
+    echo "Missing Python script: $_SETUP_UTIL"
+    exit 22
+end
+
+# detect if running on Darwin platform
+set _UNAME (uname -s)
+set _IS_DARWIN 0
+
+if test "$_UNAME" = Darwin
+    set _IS_DARWIN 1
+end
+
+set -e _UNAME
+
+# make sure to export all environment variables
+set -x CMAKE_PREFIX_PATH $CMAKE_PREFIX_PATH
+if test $_IS_DARWIN -eq 0
+    set -x LD_LIBRARY_PATH $LD_LIBRARY_PATH
+else
+    set -x DYLD_LIBRARY_PATH $DYLD_LIBRARY_PATH
+end
+
+set -e _IS_DARWIN
+set -x PATH $PATH
+set -x PKG_CONFIG_PATH $PKG_CONFIG_PATH
+set -x PYTHONPATH $PYTHONPATH
+
+# remember type of shell if not already set
+if test -z "$CATKIN_SHELL"
+    set CATKIN_SHELL fish
+end
+
+# invoke Python script to generate necessary exports of environment variables
+# use TMPDIR if it exists, otherwise fall back to /tmp
+if test -d "$TMPDIR"
+    set _TMPDIR "$TMPDIR"
+else
+    set _TMPDIR /tmp
+end
+
+set _SETUP_TMP (mktemp "$_TMPDIR/setup.fish.XXXXXXXXXX")
+set -e _TMPDIR
+
+if test $status -ne 0 -o ! -f "$_SETUP_TMP"
+    echo "Could not create temporary file: $_SETUP_TMP"
+    exit 1
+end
+
+CATKIN_SHELL=$CATKIN_SHELL "$_SETUP_UTIL" "$argv" "$CATKIN_SETUP_UTIL_ARGS" >> "$_SETUP_TMP"
+set _RC $status
+
+if test $_RC -ne 0
+    if test $_RC -eq 2
+        then
+        echo "Could not write the output of '$_SETUP_UTIL' to temporary file '$_SETUP_TMP': maybe the disk is full?"
+    else
+        echo "Failed to run '\"$_SETUP_UTIL\" $argv': return code $_RC"
+    end
+    set -e _RC
+    set -e _SETUP_UTIL
+    rm -f "$_SETUP_TMP"
+    set -e _SETUP_TMP
+    exit 1
+end
+
+set -e _RC
+set -e _SETUP_UTIL
+source "$_SETUP_TMP"
+rm -f "$_SETUP_TMP"
+set -e _SETUP_TMP
+
+# source all environment hooks
+set _i 0
+while test $_i -lt $_CATKIN_ENVIRONMENT_HOOKS_COUNT
+    # fish doesn't allow use of ${} to delimit variables within a string
+    set _i_WORKSPACE (string join "" "$i" "_WORKSPACE")
+
+    eval set _envfile \$_CATKIN_ENVIRONMENT_HOOKS_$_i
+    set -e _CATKIN_ENVIRONMENT_HOOKS_$_i
+    eval set _envfile_workspace \$_CATKIN_ENVIRONMENT_HOOKS_$_i_WORKSPACE
+    set -e _CATKIN_ENVIRONMENT_HOOKS_$_i_WORKSPACE
+
+    # set workspace for environment hook
+    set CATKIN_ENV_HOOK_WORKSPACE $_envfile_workspace
+
+    # non ideal: some packages register bash scripts as fish env hooks
+    # it is needed to perform an extension check for backwards compatibility
+    # if the script ends with .sh, .bash or .zsh, run it with bass
+    set IS_SH_SCRIPT (string match -r '\.(sh|bash|zsh)$' "$_envfile")
+    if test -n "$IS_SH_SCRIPT"
+        bass source "$_envfile"
+    else
+        source "$_envfile"
+    end
+
+    set -e IS_SH_SCRIPT
+    set -e CATKIN_ENV_HOOK_WORKSPACE
+    set _i (math $_i + 1)
+end
+set -e _i
+
+set -e _CATKIN_ENVIRONMENT_HOOKS_COUNT

devel/setup.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env sh
+# generated from catkin/cmake/template/setup.sh.in
+
+# Sets various environment variables and sources additional environment hooks.
+# It tries it's best to undo changes from a previously sourced setup file before.
+# Supported command line options:
+# --extend: skips the undoing of changes from a previously sourced setup file
+# --local: only considers this workspace but not the chained ones
+# In plain sh shell which doesn't support arguments for sourced scripts you can
+# set the environment variable `CATKIN_SETUP_UTIL_ARGS=--extend/--local` instead.
+
+# since this file is sourced either use the provided _CATKIN_SETUP_DIR
+# or fall back to the destination set at configure time
+: ${_CATKIN_SETUP_DIR:=/home/zmn/下载/ros_turtlecontrol/devel}
+_SETUP_UTIL="$_CATKIN_SETUP_DIR/_setup_util.py"
+unset _CATKIN_SETUP_DIR
+
+if [ ! -f "$_SETUP_UTIL" ]; then
+  echo "Missing Python script: $_SETUP_UTIL"
+  return 22
+fi
+
+# detect if running on Darwin platform
+_UNAME=`uname -s`
+_IS_DARWIN=0
+if [ "$_UNAME" = "Darwin" ]; then
+  _IS_DARWIN=1
+fi
+unset _UNAME
+
+# make sure to export all environment variables
+export CMAKE_PREFIX_PATH
+if [ $_IS_DARWIN -eq 0 ]; then
+  export LD_LIBRARY_PATH
+else
+  export DYLD_LIBRARY_PATH
+fi
+unset _IS_DARWIN
+export PATH
+export PKG_CONFIG_PATH
+export PYTHONPATH
+
+# remember type of shell if not already set
+if [ -z "$CATKIN_SHELL" ]; then
+  CATKIN_SHELL=sh
+fi
+
+# invoke Python script to generate necessary exports of environment variables
+# use TMPDIR if it exists, otherwise fall back to /tmp
+if [ -d "${TMPDIR:-}" ]; then
+  _TMPDIR="${TMPDIR}"
+else
+  _TMPDIR=/tmp
+fi
+_SETUP_TMP=`mktemp "${_TMPDIR}/setup.sh.XXXXXXXXXX"`
+unset _TMPDIR
+if [ $? -ne 0 -o ! -f "$_SETUP_TMP" ]; then
+  echo "Could not create temporary file: $_SETUP_TMP"
+  return 1
+fi
+CATKIN_SHELL=$CATKIN_SHELL "$_SETUP_UTIL" $@ ${CATKIN_SETUP_UTIL_ARGS:-} >> "$_SETUP_TMP"
+_RC=$?
+if [ $_RC -ne 0 ]; then
+  if [ $_RC -eq 2 ]; then
+    echo "Could not write the output of '$_SETUP_UTIL' to temporary file '$_SETUP_TMP': maybe the disk is full?"
+  else
+    echo "Failed to run '\"$_SETUP_UTIL\" $@': return code $_RC"
+  fi
+  unset _RC
+  unset _SETUP_UTIL
+  rm -f "$_SETUP_TMP"
+  unset _SETUP_TMP
+  return 1
+fi
+unset _RC
+unset _SETUP_UTIL
+. "$_SETUP_TMP"
+rm -f "$_SETUP_TMP"
+unset _SETUP_TMP
+
+# source all environment hooks
+_i=0
+while [ $_i -lt $_CATKIN_ENVIRONMENT_HOOKS_COUNT ]; do
+  eval _envfile=\$_CATKIN_ENVIRONMENT_HOOKS_$_i
+  unset _CATKIN_ENVIRONMENT_HOOKS_$_i
+  eval _envfile_workspace=\$_CATKIN_ENVIRONMENT_HOOKS_${_i}_WORKSPACE
+  unset _CATKIN_ENVIRONMENT_HOOKS_${_i}_WORKSPACE
+  # set workspace for environment hook
+  CATKIN_ENV_HOOK_WORKSPACE=$_envfile_workspace
+  . "$_envfile"
+  unset CATKIN_ENV_HOOK_WORKSPACE
+  _i=$((_i + 1))
+done
+unset _i
+
+unset _CATKIN_ENVIRONMENT_HOOKS_COUNT

devel/setup.zsh

@@ -0,0 +1,8 @@
+#!/usr/bin/env zsh
+# generated from catkin/cmake/templates/setup.zsh.in
+
+CATKIN_SHELL=zsh
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd -q "`dirname "$0"`" > /dev/null && pwd)
+emulate -R zsh -c 'source "$_CATKIN_SETUP_DIR/setup.sh"'

devel/share/Aee1220310013/cmake/Aee1220310013-msg-extras.cmake

@@ -0,0 +1,2 @@
+set(Aee1220310013_MESSAGE_FILES "")
+set(Aee1220310013_SERVICE_FILES "/home/zmn/下载/ros_turtlecontrol/src/Aee1220310013/srv/ProcessID.srv")

devel/share/Aee1220310013/cmake/Aee1220310013-msg-paths.cmake

@@ -0,0 +1,4 @@
+# generated from genmsg/cmake/pkg-msg-paths.cmake.develspace.in
+
+set(Aee1220310013_MSG_INCLUDE_DIRS "")
+set(Aee1220310013_MSG_DEPENDENCIES std_msgs)

devel/share/Aee1220310013/cmake/Aee1220310013Config-version.cmake

@@ -0,0 +1,14 @@
+# generated from catkin/cmake/template/pkgConfig-version.cmake.in
+set(PACKAGE_VERSION "0.0.0")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if("${PACKAGE_FIND_VERSION}" VERSION_LESS "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()

devel/share/Aee1220310013/cmake/Aee1220310013Config.cmake

@@ -0,0 +1,225 @@
+# generated from catkin/cmake/template/pkgConfig.cmake.in
+
+# append elements to a list and remove existing duplicates from the list
+# copied from catkin/cmake/list_append_deduplicate.cmake to keep pkgConfig
+# self contained
+macro(_list_append_deduplicate listname)
+  if(NOT "${ARGN}" STREQUAL "")
+    if(${listname})
+      list(REMOVE_ITEM ${listname} ${ARGN})
+    endif()
+    list(APPEND ${listname} ${ARGN})
+  endif()
+endmacro()
+
+# append elements to a list if they are not already in the list
+# copied from catkin/cmake/list_append_unique.cmake to keep pkgConfig
+# self contained
+macro(_list_append_unique listname)
+  foreach(_item ${ARGN})
+    list(FIND ${listname} ${_item} _index)
+    if(_index EQUAL -1)
+      list(APPEND ${listname} ${_item})
+    endif()
+  endforeach()
+endmacro()
+
+# pack a list of libraries with optional build configuration keywords
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_pack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  set(_argn ${ARGN})
+  list(LENGTH _argn _count)
+  set(_index 0)
+  while(${_index} LESS ${_count})
+    list(GET _argn ${_index} lib)
+    if("${lib}" MATCHES "^(debug|optimized|general)$")
+      math(EXPR _index "${_index} + 1")
+      if(${_index} EQUAL ${_count})
+        message(FATAL_ERROR "_pack_libraries_with_build_configuration() the list of libraries '${ARGN}' ends with '${lib}' which is a build configuration keyword and must be followed by a library")
+      endif()
+      list(GET _argn ${_index} library)
+      list(APPEND ${VAR} "${lib}${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}${library}")
+    else()
+      list(APPEND ${VAR} "${lib}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+  endwhile()
+endmacro()
+
+# unpack a list of libraries with optional build configuration keyword prefixes
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_unpack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  foreach(lib ${ARGN})
+    string(REGEX REPLACE "^(debug|optimized|general)${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}(.+)$" "\\1;\\2" lib "${lib}")
+    list(APPEND ${VAR} "${lib}")
+  endforeach()
+endmacro()
+
+
+if(Aee1220310013_CONFIG_INCLUDED)
+  return()
+endif()
+set(Aee1220310013_CONFIG_INCLUDED TRUE)
+
+# set variables for source/devel/install prefixes
+if("TRUE" STREQUAL "TRUE")
+  set(Aee1220310013_SOURCE_PREFIX /home/zmn/下载/ros_turtlecontrol/src/Aee1220310013)
+  set(Aee1220310013_DEVEL_PREFIX /home/zmn/下载/ros_turtlecontrol/devel)
+  set(Aee1220310013_INSTALL_PREFIX "")
+  set(Aee1220310013_PREFIX ${Aee1220310013_DEVEL_PREFIX})
+else()
+  set(Aee1220310013_SOURCE_PREFIX "")
+  set(Aee1220310013_DEVEL_PREFIX "")
+  set(Aee1220310013_INSTALL_PREFIX /home/zmn/下载/ros_turtlecontrol/install)
+  set(Aee1220310013_PREFIX ${Aee1220310013_INSTALL_PREFIX})
+endif()
+
+# warn when using a deprecated package
+if(NOT "" STREQUAL "")
+  set(_msg "WARNING: package 'Aee1220310013' is deprecated")
+  # append custom deprecation text if available
+  if(NOT "" STREQUAL "TRUE")
+    set(_msg "${_msg} ()")
+  endif()
+  message("${_msg}")
+endif()
+
+# flag project as catkin-based to distinguish if a find_package()-ed project is a catkin project
+set(Aee1220310013_FOUND_CATKIN_PROJECT TRUE)
+
+if(NOT "/home/zmn/下载/ros_turtlecontrol/devel/include " STREQUAL " ")
+  set(Aee1220310013_INCLUDE_DIRS "")
+  set(_include_dirs "/home/zmn/下载/ros_turtlecontrol/devel/include")
+  if(NOT " " STREQUAL " ")
+    set(_report "Check the issue tracker '' and consider creating a ticket if the problem has not been reported yet.")
+  elseif(NOT " " STREQUAL " ")
+    set(_report "Check the website '' for information and consider reporting the problem.")
+  else()
+    set(_report "Report the problem to the maintainer 'root <root@todo.todo>' and request to fix the problem.")
+  endif()
+  foreach(idir ${_include_dirs})
+    if(IS_ABSOLUTE ${idir} AND IS_DIRECTORY ${idir})
+      set(include ${idir})
+    elseif("${idir} " STREQUAL "include ")
+      get_filename_component(include "${Aee1220310013_DIR}/../../../include" ABSOLUTE)
+      if(NOT IS_DIRECTORY ${include})
+        message(FATAL_ERROR "Project 'Aee1220310013' specifies '${idir}' as an include dir, which is not found.  It does not exist in '${include}'.  ${_report}")
+      endif()
+    else()
+      message(FATAL_ERROR "Project 'Aee1220310013' specifies '${idir}' as an include dir, which is not found.  It does neither exist as an absolute directory nor in '/home/zmn/下载/ros_turtlecontrol/src/Aee1220310013/${idir}'.  ${_report}")
+    endif()
+    _list_append_unique(Aee1220310013_INCLUDE_DIRS ${include})
+  endforeach()
+endif()
+
+set(libraries "")
+foreach(library ${libraries})
+  # keep build configuration keywords, generator expressions, target names, and absolute libraries as-is
+  if("${library}" MATCHES "^(debug|optimized|general)$")
+    list(APPEND Aee1220310013_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-l")
+    list(APPEND Aee1220310013_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-")
+    # This is a linker flag/option (like -pthread)
+    # There's no standard variable for these, so create an interface library to hold it
+    if(NOT Aee1220310013_NUM_DUMMY_TARGETS)
+      set(Aee1220310013_NUM_DUMMY_TARGETS 0)
+    endif()
+    # Make sure the target name is unique
+    set(interface_target_name "catkin::Aee1220310013::wrapped-linker-option${Aee1220310013_NUM_DUMMY_TARGETS}")
+    while(TARGET "${interface_target_name}")
+      math(EXPR Aee1220310013_NUM_DUMMY_TARGETS "${Aee1220310013_NUM_DUMMY_TARGETS}+1")
+      set(interface_target_name "catkin::Aee1220310013::wrapped-linker-option${Aee1220310013_NUM_DUMMY_TARGETS}")
+    endwhile()
+    add_library("${interface_target_name}" INTERFACE IMPORTED)
+    if("${CMAKE_VERSION}" VERSION_LESS "3.13.0")
+      set_property(
+        TARGET
+        "${interface_target_name}"
+        APPEND PROPERTY
+        INTERFACE_LINK_LIBRARIES "${library}")
+    else()
+      target_link_options("${interface_target_name}" INTERFACE "${library}")
+    endif()
+    list(APPEND Aee1220310013_LIBRARIES "${interface_target_name}")
+  elseif(${library} MATCHES "^\\$<")
+    list(APPEND Aee1220310013_LIBRARIES ${library})
+  elseif(TARGET ${library})
+    list(APPEND Aee1220310013_LIBRARIES ${library})
+  elseif(IS_ABSOLUTE ${library})
+    list(APPEND Aee1220310013_LIBRARIES ${library})
+  else()
+    set(lib_path "")
+    set(lib "${library}-NOTFOUND")
+    # since the path where the library is found is returned we have to iterate over the paths manually
+    foreach(path /home/zmn/下载/ros_turtlecontrol/devel/lib;/opt/ros/noetic/lib)
+      find_library(lib ${library}
+        PATHS ${path}
+        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+      if(lib)
+        set(lib_path ${path})
+        break()
+      endif()
+    endforeach()
+    if(lib)
+      _list_append_unique(Aee1220310013_LIBRARY_DIRS ${lib_path})
+      list(APPEND Aee1220310013_LIBRARIES ${lib})
+    else()
+      # as a fall back for non-catkin libraries try to search globally
+      find_library(lib ${library})
+      if(NOT lib)
+        message(FATAL_ERROR "Project '${PROJECT_NAME}' tried to find library '${library}'.  The library is neither a target nor built/installed properly.  Did you compile project 'Aee1220310013'?  Did you find_package() it before the subdirectory containing its code is included?")
+      endif()
+      list(APPEND Aee1220310013_LIBRARIES ${lib})
+    endif()
+  endif()
+endforeach()
+
+set(Aee1220310013_EXPORTED_TARGETS "Aee1220310013_generate_messages_cpp;Aee1220310013_generate_messages_eus;Aee1220310013_generate_messages_lisp;Aee1220310013_generate_messages_nodejs;Aee1220310013_generate_messages_py")
+# create dummy targets for exported code generation targets to make life of users easier
+foreach(t ${Aee1220310013_EXPORTED_TARGETS})
+  if(NOT TARGET ${t})
+    add_custom_target(${t})
+  endif()
+endforeach()
+
+set(depends "")
+foreach(depend ${depends})
+  string(REPLACE " " ";" depend_list ${depend})
+  # the package name of the dependency must be kept in a unique variable so that it is not overwritten in recursive calls
+  list(GET depend_list 0 Aee1220310013_dep)
+  list(LENGTH depend_list count)
+  if(${count} EQUAL 1)
+    # simple dependencies must only be find_package()-ed once
+    if(NOT ${Aee1220310013_dep}_FOUND)
+      find_package(${Aee1220310013_dep} REQUIRED NO_MODULE)
+    endif()
+  else()
+    # dependencies with components must be find_package()-ed again
+    list(REMOVE_AT depend_list 0)
+    find_package(${Aee1220310013_dep} REQUIRED NO_MODULE ${depend_list})
+  endif()
+  _list_append_unique(Aee1220310013_INCLUDE_DIRS ${${Aee1220310013_dep}_INCLUDE_DIRS})
+
+  # merge build configuration keywords with library names to correctly deduplicate
+  _pack_libraries_with_build_configuration(Aee1220310013_LIBRARIES ${Aee1220310013_LIBRARIES})
+  _pack_libraries_with_build_configuration(_libraries ${${Aee1220310013_dep}_LIBRARIES})
+  _list_append_deduplicate(Aee1220310013_LIBRARIES ${_libraries})
+  # undo build configuration keyword merging after deduplication
+  _unpack_libraries_with_build_configuration(Aee1220310013_LIBRARIES ${Aee1220310013_LIBRARIES})
+
+  _list_append_unique(Aee1220310013_LIBRARY_DIRS ${${Aee1220310013_dep}_LIBRARY_DIRS})
+  _list_append_deduplicate(Aee1220310013_EXPORTED_TARGETS ${${Aee1220310013_dep}_EXPORTED_TARGETS})
+endforeach()
+
+set(pkg_cfg_extras "Aee1220310013-msg-extras.cmake")
+foreach(extra ${pkg_cfg_extras})
+  if(NOT IS_ABSOLUTE ${extra})
+    set(extra ${Aee1220310013_DIR}/${extra})
+  endif()
+  include(${extra})
+endforeach()

devel/share/common-lisp/ros/Aee1220310013/srv/Aee1220310013-srv.asd

@@ -0,0 +1,9 @@
+
+(cl:in-package :asdf)
+
+(defsystem "Aee1220310013-srv"
+  :depends-on (:roslisp-msg-protocol :roslisp-utils )
+  :components ((:file "_package")
+    (:file "ProcessID" :depends-on ("_package_ProcessID"))
+    (:file "_package_ProcessID" :depends-on ("_package"))
+  ))

devel/share/common-lisp/ros/Aee1220310013/srv/ProcessID.lisp

@@ -0,0 +1,220 @@
+; Auto-generated. Do not edit!
+
+
+(cl:in-package Aee1220310013-srv)
+
+
+;//! \htmlinclude ProcessID-request.msg.html
+
+(cl:defclass <ProcessID-request> (roslisp-msg-protocol:ros-message)
+  ((student_id
+    :reader student_id
+    :initarg :student_id
+    :type cl:string
+    :initform ""))
+)
+
+(cl:defclass ProcessID-request (<ProcessID-request>)
+  ())
+
+(cl:defmethod cl:initialize-instance :after ((m <ProcessID-request>) cl:&rest args)
+  (cl:declare (cl:ignorable args))
+  (cl:unless (cl:typep m 'ProcessID-request)
+    (roslisp-msg-protocol:msg-deprecation-warning "using old message class name Aee1220310013-srv:<ProcessID-request> is deprecated: use Aee1220310013-srv:ProcessID-request instead.")))
+
+(cl:ensure-generic-function 'student_id-val :lambda-list '(m))
+(cl:defmethod student_id-val ((m <ProcessID-request>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader Aee1220310013-srv:student_id-val is deprecated.  Use Aee1220310013-srv:student_id instead.")
+  (student_id m))
+(cl:defmethod roslisp-msg-protocol:serialize ((msg <ProcessID-request>) ostream)
+  "Serializes a message object of type '<ProcessID-request>"
+  (cl:let ((__ros_str_len (cl:length (cl:slot-value msg 'student_id))))
+    (cl:write-byte (cl:ldb (cl:byte 8 0) __ros_str_len) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 8) __ros_str_len) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 16) __ros_str_len) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 24) __ros_str_len) ostream))
+  (cl:map cl:nil #'(cl:lambda (c) (cl:write-byte (cl:char-code c) ostream)) (cl:slot-value msg 'student_id))
+)
+(cl:defmethod roslisp-msg-protocol:deserialize ((msg <ProcessID-request>) istream)
+  "Deserializes a message object of type '<ProcessID-request>"
+    (cl:let ((__ros_str_len 0))
+      (cl:setf (cl:ldb (cl:byte 8 0) __ros_str_len) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 8) __ros_str_len) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 16) __ros_str_len) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 24) __ros_str_len) (cl:read-byte istream))
+      (cl:setf (cl:slot-value msg 'student_id) (cl:make-string __ros_str_len))
+      (cl:dotimes (__ros_str_idx __ros_str_len msg)
+        (cl:setf (cl:char (cl:slot-value msg 'student_id) __ros_str_idx) (cl:code-char (cl:read-byte istream)))))
+  msg
+)
+(cl:defmethod roslisp-msg-protocol:ros-datatype ((msg (cl:eql '<ProcessID-request>)))
+  "Returns string type for a service object of type '<ProcessID-request>"
+  "Aee1220310013/ProcessIDRequest")
+(cl:defmethod roslisp-msg-protocol:ros-datatype ((msg (cl:eql 'ProcessID-request)))
+  "Returns string type for a service object of type 'ProcessID-request"
+  "Aee1220310013/ProcessIDRequest")
+(cl:defmethod roslisp-msg-protocol:md5sum ((type (cl:eql '<ProcessID-request>)))
+  "Returns md5sum for a message object of type '<ProcessID-request>"
+  "e7263169494a43b7a316d7ec3753d546")
+(cl:defmethod roslisp-msg-protocol:md5sum ((type (cl:eql 'ProcessID-request)))
+  "Returns md5sum for a message object of type 'ProcessID-request"
+  "e7263169494a43b7a316d7ec3753d546")
+(cl:defmethod roslisp-msg-protocol:message-definition ((type (cl:eql '<ProcessID-request>)))
+  "Returns full string definition for message of type '<ProcessID-request>"
+  (cl:format cl:nil "string student_id~%~%~%"))
+(cl:defmethod roslisp-msg-protocol:message-definition ((type (cl:eql 'ProcessID-request)))
+  "Returns full string definition for message of type 'ProcessID-request"
+  (cl:format cl:nil "string student_id~%~%~%"))
+(cl:defmethod roslisp-msg-protocol:serialization-length ((msg <ProcessID-request>))
+  (cl:+ 0
+     4 (cl:length (cl:slot-value msg 'student_id))
+))
+(cl:defmethod roslisp-msg-protocol:ros-message-to-list ((msg <ProcessID-request>))
+  "Converts a ROS message object to a list"
+  (cl:list 'ProcessID-request
+    (cl:cons ':student_id (student_id msg))
+))
+;//! \htmlinclude ProcessID-response.msg.html
+
+(cl:defclass <ProcessID-response> (roslisp-msg-protocol:ros-message)
+  ((x
+    :reader x
+    :initarg :x
+    :type cl:float
+    :initform 0.0)
+   (y
+    :reader y
+    :initarg :y
+    :type cl:float
+    :initform 0.0)
+   (radius
+    :reader radius
+    :initarg :radius
+    :type cl:float
+    :initform 0.0)
+   (direction
+    :reader direction
+    :initarg :direction
+    :type cl:integer
+    :initform 0))
+)
+
+(cl:defclass ProcessID-response (<ProcessID-response>)
+  ())
+
+(cl:defmethod cl:initialize-instance :after ((m <ProcessID-response>) cl:&rest args)
+  (cl:declare (cl:ignorable args))
+  (cl:unless (cl:typep m 'ProcessID-response)
+    (roslisp-msg-protocol:msg-deprecation-warning "using old message class name Aee1220310013-srv:<ProcessID-response> is deprecated: use Aee1220310013-srv:ProcessID-response instead.")))
+
+(cl:ensure-generic-function 'x-val :lambda-list '(m))
+(cl:defmethod x-val ((m <ProcessID-response>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader Aee1220310013-srv:x-val is deprecated.  Use Aee1220310013-srv:x instead.")
+  (x m))
+
+(cl:ensure-generic-function 'y-val :lambda-list '(m))
+(cl:defmethod y-val ((m <ProcessID-response>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader Aee1220310013-srv:y-val is deprecated.  Use Aee1220310013-srv:y instead.")
+  (y m))
+
+(cl:ensure-generic-function 'radius-val :lambda-list '(m))
+(cl:defmethod radius-val ((m <ProcessID-response>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader Aee1220310013-srv:radius-val is deprecated.  Use Aee1220310013-srv:radius instead.")
+  (radius m))
+
+(cl:ensure-generic-function 'direction-val :lambda-list '(m))
+(cl:defmethod direction-val ((m <ProcessID-response>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader Aee1220310013-srv:direction-val is deprecated.  Use Aee1220310013-srv:direction instead.")
+  (direction m))
+(cl:defmethod roslisp-msg-protocol:serialize ((msg <ProcessID-response>) ostream)
+  "Serializes a message object of type '<ProcessID-response>"
+  (cl:let ((bits (roslisp-utils:encode-single-float-bits (cl:slot-value msg 'x))))
+    (cl:write-byte (cl:ldb (cl:byte 8 0) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 8) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 16) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 24) bits) ostream))
+  (cl:let ((bits (roslisp-utils:encode-single-float-bits (cl:slot-value msg 'y))))
+    (cl:write-byte (cl:ldb (cl:byte 8 0) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 8) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 16) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 24) bits) ostream))
+  (cl:let ((bits (roslisp-utils:encode-single-float-bits (cl:slot-value msg 'radius))))
+    (cl:write-byte (cl:ldb (cl:byte 8 0) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 8) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 16) bits) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 24) bits) ostream))
+  (cl:let* ((signed (cl:slot-value msg 'direction)) (unsigned (cl:if (cl:< signed 0) (cl:+ signed 4294967296) signed)))
+    (cl:write-byte (cl:ldb (cl:byte 8 0) unsigned) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 8) unsigned) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 16) unsigned) ostream)
+    (cl:write-byte (cl:ldb (cl:byte 8 24) unsigned) ostream)
+    )
+)
+(cl:defmethod roslisp-msg-protocol:deserialize ((msg <ProcessID-response>) istream)
+  "Deserializes a message object of type '<ProcessID-response>"
+    (cl:let ((bits 0))
+      (cl:setf (cl:ldb (cl:byte 8 0) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 8) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 16) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 24) bits) (cl:read-byte istream))
+    (cl:setf (cl:slot-value msg 'x) (roslisp-utils:decode-single-float-bits bits)))
+    (cl:let ((bits 0))
+      (cl:setf (cl:ldb (cl:byte 8 0) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 8) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 16) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 24) bits) (cl:read-byte istream))
+    (cl:setf (cl:slot-value msg 'y) (roslisp-utils:decode-single-float-bits bits)))
+    (cl:let ((bits 0))
+      (cl:setf (cl:ldb (cl:byte 8 0) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 8) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 16) bits) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 24) bits) (cl:read-byte istream))
+    (cl:setf (cl:slot-value msg 'radius) (roslisp-utils:decode-single-float-bits bits)))
+    (cl:let ((unsigned 0))
+      (cl:setf (cl:ldb (cl:byte 8 0) unsigned) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 8) unsigned) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 16) unsigned) (cl:read-byte istream))
+      (cl:setf (cl:ldb (cl:byte 8 24) unsigned) (cl:read-byte istream))
+      (cl:setf (cl:slot-value msg 'direction) (cl:if (cl:< unsigned 2147483648) unsigned (cl:- unsigned 4294967296))))
+  msg
+)
+(cl:defmethod roslisp-msg-protocol:ros-datatype ((msg (cl:eql '<ProcessID-response>)))
+  "Returns string type for a service object of type '<ProcessID-response>"
+  "Aee1220310013/ProcessIDResponse")
+(cl:defmethod roslisp-msg-protocol:ros-datatype ((msg (cl:eql 'ProcessID-response)))
+  "Returns string type for a service object of type 'ProcessID-response"
+  "Aee1220310013/ProcessIDResponse")
+(cl:defmethod roslisp-msg-protocol:md5sum ((type (cl:eql '<ProcessID-response>)))
+  "Returns md5sum for a message object of type '<ProcessID-response>"
+  "e7263169494a43b7a316d7ec3753d546")
+(cl:defmethod roslisp-msg-protocol:md5sum ((type (cl:eql 'ProcessID-response)))
+  "Returns md5sum for a message object of type 'ProcessID-response"
+  "e7263169494a43b7a316d7ec3753d546")
+(cl:defmethod roslisp-msg-protocol:message-definition ((type (cl:eql '<ProcessID-response>)))
+  "Returns full string definition for message of type '<ProcessID-response>"
+  (cl:format cl:nil "float32 x~%float32 y~%float32 radius~%int32 direction~%~%~%"))
+(cl:defmethod roslisp-msg-protocol:message-definition ((type (cl:eql 'ProcessID-response)))
+  "Returns full string definition for message of type 'ProcessID-response"
+  (cl:format cl:nil "float32 x~%float32 y~%float32 radius~%int32 direction~%~%~%"))
+(cl:defmethod roslisp-msg-protocol:serialization-length ((msg <ProcessID-response>))
+  (cl:+ 0
+     4
+     4
+     4
+     4
+))
+(cl:defmethod roslisp-msg-protocol:ros-message-to-list ((msg <ProcessID-response>))
+  "Converts a ROS message object to a list"
+  (cl:list 'ProcessID-response
+    (cl:cons ':x (x msg))
+    (cl:cons ':y (y msg))
+    (cl:cons ':radius (radius msg))
+    (cl:cons ':direction (direction msg))
+))
+(cl:defmethod roslisp-msg-protocol:service-request-type ((msg (cl:eql 'ProcessID)))
+  'ProcessID-request)
+(cl:defmethod roslisp-msg-protocol:service-response-type ((msg (cl:eql 'ProcessID)))
+  'ProcessID-response)
+(cl:defmethod roslisp-msg-protocol:ros-datatype ((msg (cl:eql 'ProcessID)))
+  "Returns string type for a service object of type '<ProcessID>"
+  "Aee1220310013/ProcessID")

devel/share/common-lisp/ros/Aee1220310013/srv/_package.lisp

@@ -0,0 +1,10 @@
+(cl:defpackage Aee1220310013-srv
+  (:use )
+  (:export
+   "PROCESSID"
+   "<PROCESSID-REQUEST>"
+   "PROCESSID-REQUEST"
+   "<PROCESSID-RESPONSE>"
+   "PROCESSID-RESPONSE"
+  ))
+

devel/share/common-lisp/ros/Aee1220310013/srv/_package_ProcessID.lisp

@@ -0,0 +1,12 @@
+(cl:in-package Aee1220310013-srv)
+(cl:export '(STUDENT_ID-VAL
+          STUDENT_ID
+          X-VAL
+          X
+          Y-VAL
+          Y
+          RADIUS-VAL
+          RADIUS
+          DIRECTION-VAL
+          DIRECTION
+))

devel/share/gennodejs/ros/Aee1220310013/_index.js

@@ -0,0 +1,6 @@
+
+"use strict";
+
+module.exports = {
+  srv: require('./srv/_index.js')
+};

devel/share/gennodejs/ros/Aee1220310013/srv/ProcessID.js

@@ -0,0 +1,226 @@
+// Auto-generated. Do not edit!
+
+// (in-package Aee1220310013.srv)
+
+
+"use strict";
+
+const _serializer = _ros_msg_utils.Serialize;
+const _arraySerializer = _serializer.Array;
+const _deserializer = _ros_msg_utils.Deserialize;
+const _arrayDeserializer = _deserializer.Array;
+const _finder = _ros_msg_utils.Find;
+const _getByteLength = _ros_msg_utils.getByteLength;
+
+//-----------------------------------------------------------
+
+
+//-----------------------------------------------------------
+
+class ProcessIDRequest {
+  constructor(initObj={}) {
+    if (initObj === null) {
+      // initObj === null is a special case for deserialization where we don't initialize fields
+      this.student_id = null;
+    }
+    else {
+      if (initObj.hasOwnProperty('student_id')) {
+        this.student_id = initObj.student_id
+      }
+      else {
+        this.student_id = '';
+      }
+    }
+  }
+
+  static serialize(obj, buffer, bufferOffset) {
+    // Serializes a message object of type ProcessIDRequest
+    // Serialize message field [student_id]
+    bufferOffset = _serializer.string(obj.student_id, buffer, bufferOffset);
+    return bufferOffset;
+  }
+
+  static deserialize(buffer, bufferOffset=[0]) {
+    //deserializes a message object of type ProcessIDRequest
+    let len;
+    let data = new ProcessIDRequest(null);
+    // Deserialize message field [student_id]
+    data.student_id = _deserializer.string(buffer, bufferOffset);
+    return data;
+  }
+
+  static getMessageSize(object) {
+    let length = 0;
+    length += _getByteLength(object.student_id);
+    return length + 4;
+  }
+
+  static datatype() {
+    // Returns string type for a service object
+    return 'Aee1220310013/ProcessIDRequest';
+  }
+
+  static md5sum() {
+    //Returns md5sum for a message object
+    return '372af5010cb802275110c9bd017544b8';
+  }
+
+  static messageDefinition() {
+    // Returns full string definition for message
+    return `
+    string student_id
+    
+    `;
+  }
+
+  static Resolve(msg) {
+    // deep-construct a valid message object instance of whatever was passed in
+    if (typeof msg !== 'object' || msg === null) {
+      msg = {};
+    }
+    const resolved = new ProcessIDRequest(null);
+    if (msg.student_id !== undefined) {
+      resolved.student_id = msg.student_id;
+    }
+    else {
+      resolved.student_id = ''
+    }
+
+    return resolved;
+    }
+};
+
+class ProcessIDResponse {
+  constructor(initObj={}) {
+    if (initObj === null) {
+      // initObj === null is a special case for deserialization where we don't initialize fields
+      this.x = null;
+      this.y = null;
+      this.radius = null;
+      this.direction = null;
+    }
+    else {
+      if (initObj.hasOwnProperty('x')) {
+        this.x = initObj.x
+      }
+      else {
+        this.x = 0.0;
+      }
+      if (initObj.hasOwnProperty('y')) {
+        this.y = initObj.y
+      }
+      else {
+        this.y = 0.0;
+      }
+      if (initObj.hasOwnProperty('radius')) {
+        this.radius = initObj.radius
+      }
+      else {
+        this.radius = 0.0;
+      }
+      if (initObj.hasOwnProperty('direction')) {
+        this.direction = initObj.direction
+      }
+      else {
+        this.direction = 0;
+      }
+    }
+  }
+
+  static serialize(obj, buffer, bufferOffset) {
+    // Serializes a message object of type ProcessIDResponse
+    // Serialize message field [x]
+    bufferOffset = _serializer.float32(obj.x, buffer, bufferOffset);
+    // Serialize message field [y]
+    bufferOffset = _serializer.float32(obj.y, buffer, bufferOffset);
+    // Serialize message field [radius]
+    bufferOffset = _serializer.float32(obj.radius, buffer, bufferOffset);
+    // Serialize message field [direction]
+    bufferOffset = _serializer.int32(obj.direction, buffer, bufferOffset);
+    return bufferOffset;
+  }
+
+  static deserialize(buffer, bufferOffset=[0]) {
+    //deserializes a message object of type ProcessIDResponse
+    let len;
+    let data = new ProcessIDResponse(null);
+    // Deserialize message field [x]
+    data.x = _deserializer.float32(buffer, bufferOffset);
+    // Deserialize message field [y]
+    data.y = _deserializer.float32(buffer, bufferOffset);
+    // Deserialize message field [radius]
+    data.radius = _deserializer.float32(buffer, bufferOffset);
+    // Deserialize message field [direction]
+    data.direction = _deserializer.int32(buffer, bufferOffset);
+    return data;
+  }
+
+  static getMessageSize(object) {
+    return 16;
+  }
+
+  static datatype() {
+    // Returns string type for a service object
+    return 'Aee1220310013/ProcessIDResponse';
+  }
+
+  static md5sum() {
+    //Returns md5sum for a message object
+    return 'deec39c810656f01d6b1be82e15bf4e7';
+  }
+
+  static messageDefinition() {
+    // Returns full string definition for message
+    return `
+    float32 x
+    float32 y
+    float32 radius
+    int32 direction
+    
+    `;
+  }
+
+  static Resolve(msg) {
+    // deep-construct a valid message object instance of whatever was passed in
+    if (typeof msg !== 'object' || msg === null) {
+      msg = {};
+    }
+    const resolved = new ProcessIDResponse(null);
+    if (msg.x !== undefined) {
+      resolved.x = msg.x;
+    }
+    else {
+      resolved.x = 0.0
+    }
+
+    if (msg.y !== undefined) {
+      resolved.y = msg.y;
+    }
+    else {
+      resolved.y = 0.0
+    }
+
+    if (msg.radius !== undefined) {
+      resolved.radius = msg.radius;
+    }
+    else {
+      resolved.radius = 0.0
+    }
+
+    if (msg.direction !== undefined) {
+      resolved.direction = msg.direction;
+    }
+    else {
+      resolved.direction = 0
+    }
+
+    return resolved;
+    }
+};
+
+module.exports = {
+  Request: ProcessIDRequest,
+  Response: ProcessIDResponse,
+  md5sum() { return 'e7263169494a43b7a316d7ec3753d546'; },
+  datatype() { return 'Aee1220310013/ProcessID'; }
+};

devel/share/gennodejs/ros/Aee1220310013/srv/_index.js

@@ -0,0 +1,8 @@
+
+"use strict";
+
+let ProcessID = require('./ProcessID.js')
+
+module.exports = {
+  ProcessID: ProcessID,
+};

devel/share/roseus/ros/Aee1220310013/manifest.l

@@ -0,0 +1,13 @@
+;;
+;; DO NOT EDIT THIS FILE
+;;
+;; THIS FILE IS AUTOMATICALLY GENERATED
+;;  FROM /home/zmn/下载/ros_turtlecontrol/src/Aee1220310013/package.xml (0.0.0)
+;; USING /opt/ros/noetic/lib/python3/dist-packages/geneus/geneus_main.py /opt/ros/noetic/share/geneus/package.xml (3.0.0)
+;;
+(ros::load-ros-package "geometry_msgs")
+(ros::load-ros-package "roscpp")
+(ros::load-ros-package "rosgraph_msgs")
+(ros::load-ros-package "std_msgs")
+(ros::load-ros-package "visualization_msgs")
+(ros::load-ros-package "Aee1220310013")

devel/share/roseus/ros/Aee1220310013/srv/ProcessID.l

@@ -0,0 +1,166 @@
+;; Auto-generated. Do not edit!
+
+
+(when (boundp 'Aee1220310013::ProcessID)
+  (if (not (find-package "AEE1220310013"))
+    (make-package "AEE1220310013"))
+  (shadow 'ProcessID (find-package "AEE1220310013")))
+(unless (find-package "AEE1220310013::PROCESSID")
+  (make-package "AEE1220310013::PROCESSID"))
+(unless (find-package "AEE1220310013::PROCESSIDREQUEST")
+  (make-package "AEE1220310013::PROCESSIDREQUEST"))
+(unless (find-package "AEE1220310013::PROCESSIDRESPONSE")
+  (make-package "AEE1220310013::PROCESSIDRESPONSE"))
+
+(in-package "ROS")
+
+
+
+
+
+(defclass Aee1220310013::ProcessIDRequest
+  :super ros::object
+  :slots (_student_id ))
+
+(defmethod Aee1220310013::ProcessIDRequest
+  (:init
+   (&key
+    ((:student_id __student_id) "")
+    )
+   (send-super :init)
+   (setq _student_id (string __student_id))
+   self)
+  (:student_id
+   (&optional __student_id)
+   (if __student_id (setq _student_id __student_id)) _student_id)
+  (:serialization-length
+   ()
+   (+
+    ;; string _student_id
+    4 (length _student_id)
+    ))
+  (:serialize
+   (&optional strm)
+   (let ((s (if strm strm
+              (make-string-output-stream (send self :serialization-length)))))
+     ;; string _student_id
+       (write-long (length _student_id) s) (princ _student_id s)
+     ;;
+     (if (null strm) (get-output-stream-string s))))
+  (:deserialize
+   (buf &optional (ptr- 0))
+   ;; string _student_id
+     (let (n) (setq n (sys::peek buf ptr- :integer)) (incf ptr- 4) (setq _student_id (subseq buf ptr- (+ ptr- n))) (incf ptr- n))
+   ;;
+   self)
+  )
+
+(defclass Aee1220310013::ProcessIDResponse
+  :super ros::object
+  :slots (_x _y _radius _direction ))
+
+(defmethod Aee1220310013::ProcessIDResponse
+  (:init
+   (&key
+    ((:x __x) 0.0)
+    ((:y __y) 0.0)
+    ((:radius __radius) 0.0)
+    ((:direction __direction) 0)
+    )
+   (send-super :init)
+   (setq _x (float __x))
+   (setq _y (float __y))
+   (setq _radius (float __radius))
+   (setq _direction (round __direction))
+   self)
+  (:x
+   (&optional __x)
+   (if __x (setq _x __x)) _x)
+  (:y
+   (&optional __y)
+   (if __y (setq _y __y)) _y)
+  (:radius
+   (&optional __radius)
+   (if __radius (setq _radius __radius)) _radius)
+  (:direction
+   (&optional __direction)
+   (if __direction (setq _direction __direction)) _direction)
+  (:serialization-length
+   ()
+   (+
+    ;; float32 _x
+    4
+    ;; float32 _y
+    4
+    ;; float32 _radius
+    4
+    ;; int32 _direction
+    4
+    ))
+  (:serialize
+   (&optional strm)
+   (let ((s (if strm strm
+              (make-string-output-stream (send self :serialization-length)))))
+     ;; float32 _x
+       (sys::poke _x (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
+     ;; float32 _y
+       (sys::poke _y (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
+     ;; float32 _radius
+       (sys::poke _radius (send s :buffer) (send s :count) :float) (incf (stream-count s) 4)
+     ;; int32 _direction
+       (write-long _direction s)
+     ;;
+     (if (null strm) (get-output-stream-string s))))
+  (:deserialize
+   (buf &optional (ptr- 0))
+   ;; float32 _x
+     (setq _x (sys::peek buf ptr- :float)) (incf ptr- 4)
+   ;; float32 _y
+     (setq _y (sys::peek buf ptr- :float)) (incf ptr- 4)
+   ;; float32 _radius
+     (setq _radius (sys::peek buf ptr- :float)) (incf ptr- 4)
+   ;; int32 _direction
+     (setq _direction (sys::peek buf ptr- :integer)) (incf ptr- 4)
+   ;;
+   self)
+  )
+
+(defclass Aee1220310013::ProcessID
+  :super ros::object
+  :slots ())
+
+(setf (get Aee1220310013::ProcessID :md5sum-) "e7263169494a43b7a316d7ec3753d546")
+(setf (get Aee1220310013::ProcessID :datatype-) "Aee1220310013/ProcessID")
+(setf (get Aee1220310013::ProcessID :request) Aee1220310013::ProcessIDRequest)
+(setf (get Aee1220310013::ProcessID :response) Aee1220310013::ProcessIDResponse)
+
+(defmethod Aee1220310013::ProcessIDRequest
+  (:response () (instance Aee1220310013::ProcessIDResponse :init)))
+
+(setf (get Aee1220310013::ProcessIDRequest :md5sum-) "e7263169494a43b7a316d7ec3753d546")
+(setf (get Aee1220310013::ProcessIDRequest :datatype-) "Aee1220310013/ProcessIDRequest")
+(setf (get Aee1220310013::ProcessIDRequest :definition-)
+      "string student_id
+---
+float32 x
+float32 y
+float32 radius
+int32 direction
+")
+
+(setf (get Aee1220310013::ProcessIDResponse :md5sum-) "e7263169494a43b7a316d7ec3753d546")
+(setf (get Aee1220310013::ProcessIDResponse :datatype-) "Aee1220310013/ProcessIDResponse")
+(setf (get Aee1220310013::ProcessIDResponse :definition-)
+      "string student_id
+---
+float32 x
+float32 y
+float32 radius
+int32 direction
+")
+
+
+
+(provide :Aee1220310013/ProcessID "e7263169494a43b7a316d7ec3753d546")
+
+