学习ROS机器人编程的系统方法

4星 · 超过85%的资源需积分: 14 85 浏览量更新于2024-07-19 1 收藏 25.67MB PDF 举报

"A Systematic Approach to Learning Robot Programming with ROS 是一本关于机器人编程的无水印英文PDF教材。这本书由Wyatt S. Newman撰写，由CRC Press（Taylor & Francis Group的一个印记）出版。" 《A Systematic Approach to Learning Robot Programming with ROS》这本书详细介绍了如何系统地学习使用Robot Operating System (ROS)进行机器人编程。ROS是一个开源操作系统，专门用于机器人技术，它提供了一个框架来处理硬件抽象、设备驱动、通信、包管理和开发工具。在书中，作者Wyatt S. Newman深入浅出地引导读者理解ROS的核心概念和工作原理，包括节点、消息、服务、参数服务器以及图模型等。他将复杂的ROS概念与实际的机器人应用相结合，使读者能够逐步掌握ROS的编程实践。内容涵盖了从安装和配置ROS环境开始，到创建和运行ROS节点，再到开发复杂的机器人系统。书中可能还涉及了如何使用ROS的工具进行调试、映射、导航和感知等任务。此外，作者可能会讨论ROS中的各种包，如tf（时间戳和变换管理）、rviz（可视化工具）和roslaunch（启动脚本管理）等，这些对于实际的ROS项目是至关重要的。通过本书的学习，读者可以了解到如何利用ROS来实现机器人感知、决策和行动，这包括传感器数据的处理、算法的实现和机器人的运动控制。作者可能还强调了ROS的模块化设计，使得不同组件之间的通信变得高效且灵活。这本书适合机器人学的学生、研究人员以及对ROS感兴趣的工程师阅读。不论你是初学者还是有一定经验的开发者，都能从中获得有价值的知识和实践经验，提升你在机器人编程领域的能力。不过，由于是英文版，阅读时可能需要一定的英语基础，但对于深入理解ROS的技术细节来说，这是一个非常宝贵的资源。如果你在使用过程中发现任何版权问题，或者未得到授权的内容，作者和出版社建议你及时联系他们以确保合规性。这是一本全面、系统的ROS学习指南，对于想要在机器人领域深入探索的人来说，是一本不可或缺的参考书籍。

10.5
10.6
10.7
10.8
10.9
11.1
11.2
11.3
11.4
11.5
11.6
11.7
11.8
11.9
12.1
12.2
12.3
12.4
12.5
12.6
12.7
12.8
13.1
13.2
13.3
13.4
13.5
Map state as robot first enters exit hallway
Global costmap of starting pen
Global plan (blue trace) to specified 2dNavGoal (triad)
Global and local costmaps with unexpected obstacle (construction barrel)
Example move-base client interaction. Destination is sent as goal
message to move-base action server that plans a route (blue trace) to the
destination (triad goal marker).
Servo tuning process for one-DOF robot
Servo tuning process for one-DOF robotzoom on position response
Servo tuning process for one-DOF robot20 rad/sec sinusoidal command
Velocity controller tuning process for one-DOF robot
Force sensor and actuator effort due to dropping 10 kg weight on one-
DOF robot
NAC controller response to dropping 10 kg weight on one-DOF robot
Seven-DOF arm catching and holding weight using NAC
Coarse trajectory published at irregularly sampled points of sine wave
Action-server linear interpolation of coarse trajectory
Gazebo and rviz views of rrbot
Gazebo, tf_echo and fk test nodes with rrbot
rviz, tf_echo and fk test of ABB IRB120
Two IK solutions for rrbotelbow up and elbow down
Example of eight IK solutions for ABB IRB120
Proposed NASA satellite-servicer arm, Gazebo view
Proposed NASA satellite-servicer arm, rviz view with frames displayed
Approximation of proposed NASA satellite-servicer arm
Conceptualization of a feed-forward network dynamic-programming
problem
Simple numerical example of dynamic programming consisting of five
layers with transition costs assigned to each allowed transition
First step of solution process. Minimum cost to go is computed for nodes
H and I. Two of the four links from layer four to layer five are removed
because they are provably suboptimal
Second step of solution process. Minimum cost to go is computed for
nodes E, F and G in layer 3 (costs 2, 3 and 2, respectively). Three of the
six links have been pruned, leaving only the single optimal option for
each node in layer three. It can be seen at this point that node I will not be
involved in the optimal solution.
Third step of solution process. Minimum cost to go is computed for nodes
B, C and D in layer two (costs 4, 4 and 3, respectively). Six of the nine
links have been pruned, leaving only the single optimal option for each

13.6
14.1
14.2
14.3
14.4
14.5
14.6
14.7
15.1
15.2
15.3
15.4
15.5
15.6
15.7
15.8
15.9
15.10
15.11
15.12
15.13
16.1
16.2
16.3
16.4
16.5
16.6
16.7
16.8
17.1
17.2
17.3
node in layer two.
Final step of solution process. Minimum cost to go is computed from
node A. Only a single path through the network constituting the optimal
solution survives.
Gazebo view of Baxter simulator in empty world
Gazebo view of Baxter in tuck pose
rviz view of Baxter simulator model illustrating right-arm frames
rostopic echo of robot/joint_states for Baxter
Result of running pre_pose action client of Baxter arm servers
Result of running baxter_playback with pre_pose_right.jsp and
pre_pose_left.jsp motion files
Result of running baxter_playback with motion file shy.jsp
Code hierarchy for object-grabber system
Torso frame and right_gripper frame for Baxter
Model coordinates obtained from Gazebo
rviz view of Baxter simulator in pre-pose, illustrating right hand and right
gripper frames
Approach pose from action client object_grabber_action_client, with pre-
positioned block at known precise coordinates
Grasp pose used by action client object_grabber_action_client
Depart pose used by action client object_grabber_action_client
Drop-off pose used by action client object_grabber_action_client
Initial state after launching UR10 object-grabber nodes
UR10 block approach pose
Grasp pose used by action client object_grabber_action_client
UR10 depart pose
Drop-off pose used by action client object_grabber_action_client
Point cloud including Kinect’s partial view of robot’s right arm
Offset perception of arm due to Kinect transform inaccuracy
Result of launching baxter_on_pedestal_w_kinect.launch
Result of launching coord_vision_manip.launch
Result of coordinator action service invoking perception of block
Result of coordinator action service invoking move to grasp pose
Result of coordinator action service invoking move to depart pose
Result of coordinator action server invoking object drop-off
Gazebo view of a mobile manipulator model
rviz and Gazebo views of mobile manipulator immediately after launch
rviz and Gazebo views of mobile manipulator stacking fetched block

 
Preface
 
The Robot Operating System (ROS) is becoming the de facto standard programming
approach for modern robotics. The ROS wiki (https://www.ros.org/history/) claims:
The  ROS  ecosystem  now  consists  of  tens  of  thousands  of  users  worldwide,
working  in  domains  ranging  from  tabletop  hobby  projects  to  large  industrial
automation systems.
Why ROS? In 1956, Joseph Engelberger founded Unimation, Inc., the world's first
robotics company[7]. Over the last half century, however, advances in robotics have
been disappointing.
Robotics  research  around  the  world  has  largely  produced  demonstrations  and
curiosities that died  in the  lab.  New researchers  in the  field  typically started  from
scratch, buildingnew robots from the ground up, tackling the problems of actuator
and sensor interfacing, building low-level servo controls, and typically running out
of  resources  before  achieving  higher  levels  of  robot  competence.  These  custom
machines and custom software were seldom re-used for follow-on work.
It was recognized that this pattern of building Towers of Babel was unproductive,
and  that  the  task  of  building  more  intelligent  robots  would  require  a  sustained,
collaborative  effort  that  could  build  on  foundations  to  reach  higher  levels  of
competence. In 1984, Vincent Hayward and Richard Paul introduced RCCL (Robot
Control  C  Library)  [15]  as  an  approach  to  address  this  long-standing  problem.
Unfortunately, RCCL did not gain sufficient acceptance among robotics researchers.
Both  National  Instruments  [24]  and  Microsoft  [39],  [40]  introduced  products  to
attempt to bring standardization to robot programming. However, researchers found
these approaches burdensome and/or expensive.
The origins of the ROS were initiated at the Stanford Artificial Intelligence Lab in
2007 [26]. This attempt to unify fragmented approaches to robotics was adopted by
Google and supported via Willow Garage from 2008 to 2013 [12], and subsequently
by Google's Open Source Robotics Foundation [10] (OSRF) from 2013 to present.
The  ROS  approach  followed  the  modern  trend  of  open-source  software  and
distributed  collaboration.  Further,  it  bridged  to  and  leveraged  parallel  open-source

efforts, including OpenCV [28], PointCloudLibrary [21], Open Dynamics Engine

[8], Gazebo [19], and Eigen [20]. While ROS may be similar to RCCL in its

openness and accessibility to researchers, Google's 7 years of ongoing support may

be credited with ROS surviving a crucial incubation period.

ROS is now used throughout the world in academia, industry and research

institutions.

Developers have contributed thousands of packages, including solutions from

some of the world's leading experts in targeted areas. New robot companies are

offering ROS interfaces with their products, and established industrial robot

companies are introducing ROS interfaces as well. With widespread adoption of

ROS as the de facto standard approach to robot programming, there is new hope for

accelerating the capabilities of robots. In the recent DARPA Robotics Challenge,

most of the teams that qualified used ROS. Developers of new self-driving cars are

exploiting ROS. New robot companies are springing up with leaps in capability, in

part driven by ROS resources. Given the momentum and track record of ROS, it is

clear that today's robotics engineer must be skilled in ROS programming.

What is ROS? The name \robot operating system" is arguably a misnomer.

Defining ROS succinctly is dificult, since it encompasses myriad aspects, including

style of programming (notably, relying on loosely-coupled, distributed nodes);

interface definitions and paradigms for communications among nodes; interface

definitions for incorporation of libraries and packages; a collection of tools for

visualization, debugging, data logging and system diagnostics; a repository of shared

source code; and bridges to multiple useful, independent open-source libraries. ROS

is thus more of a way of life for robot programmers than simply an operating system.

Definitions of ROS are drawn from the following sources.

From the ROS wiki (https://wiki.ros.org/ROS/Introduction):

ROS is an open-source, meta-operating system for your robot. It provides the

services you would expect from an operating system, including hardware

abstraction, low-level device control, implementation of commonly-used

functionality, message-passing between processes, and package management. It

also provides tools and libraries for obtaining, building, writing, and running

code across multiple computers.

The primary goal of ROS is to support code reuse in robotics research and

development. ROS is a distributed framework of processes (aka nodes) that

enables executables to be individually designed and loosely coupled at runtime.

These processes can be grouped into Packages, which can be easily shared and

distributed. ROS also supports a federated system of code Repositories that

enable collaboration to be distributed as well. This design, from the file system

level to the community level, enables independent decisions about development

and implementation, but all can be brought together with ROS infrastructure

tools.

Online comment by Brian Gerkey:

I usually explain ROS in the following way:

1. plumbing: ROS provides publish-subscribe messaging infrastructure

designed to support the quick and easy construction of distributed

computing systems.

2. tools: ROS provides an extensive set of tools for configuring, starting,

introspecting, debugging, visualizing, logging, testing, and stopping

distributed computing systems.

3. capabilities: ROS provides a broad collection of libraries that implement

useful robot functionality, with a focus on mobility, manipulation, and

perception.

4. ecosystem: ROS is supported and improved by a large community, with a

strong focus on integration and documentation. ros.org is a one-stop-shop

for finding and learning about the thousands of ROS packages that are

available from developers around the world.

From the text ROS by Example [13]:

The primary goal of ROS (pronounced \Ross") is to provide a unified and open

source programming framework for controlling robots in a variety of real world and

simulated environments.

Regarding ROS plumbing (from ROS by Example [13]):

The core entity in ROS is called a node. A node is generally a small program

written in Python or C++ that executes some relatively simple task or process.Nodes

can be started and stopped independently of one another and they communicate by

passing messages. A node can publish messages on certain topics or provide services

to other nodes.

For example, a publisher node might report data from sensors attached to your

robot's microcontroller. A message on the /head/sonar topic with a value of 0.5

would mean that the sensor is currently detecting an object 0.5 meters away.Any

node that wants to know the reading from this sensor need only subscribe to the

/head/sonar topic. To make use of these values, the subscriber node defines a

callback function that gets executed whenever a new message arrives on the

subscribed topic. How often this happens depends on the rate at which the publisher

node updates its messages.

A node can also define one or more services. A ROS service produces some

behavior or sends back a reply when sent a request from another node. A simple

example would be a service that turns an LED on or off. A more complex example

剩余630页未读，继续阅读

yinkaisheng-nj

粉丝: 762
资源: 6231

学习ROS机器人编程的系统方法

Learning Scientific Programming with Python 无水印原版pdf

ros机器人编程（从基本概念到机器人应用程序编程实战）中英文两版ROS_Robot_Programming_CN

A Systematic Approach to Learning Robot Programming with ROS 无水印 英文高清完整.pdf版下载

A Systematic Approach to Learning Robot Programming with ROS

A Systematic Approach to Learning Robot Programming with ROS epub

A Systematic Approach to Learning Robot Programming with ROS pdf epub azw3 格式

A Systematic Approach to Learning Robot Programming with ROS azw3

A systematic approach to learning robot_programming with ROS Dec1 2016

a systematic approach learning robot programming ros

Programming Robots with ROS

最新资源

A Systematic Approach to Learning Robot Programming with ROS 无水印英文高清完整.pdf版下载