Index
A
- ABB robot model
- visualizing, in RViz / Visualizing the ABB robot model in RViz
- actionlib applications / Applications of topics, services, and actionlib
- Adaptive Monte Carlo Localization (AMCL) / Why we prefer ROS for robots, Configuring the Navigation stack for Chefbot, Understanding AMCL
- Allowed Collision Matrix (ACM) / MoveIt! collision checking, Collision checking with a robot arm using MoveIt!
- Apache 2.0 / Understanding ROS-Industrial packages
- AprilTag
- using, with ROS / Using AprilTag with ROS
- video stream / Using AprilTag with ROS
- camera calibration / Using AprilTag with ROS
- tag description / Using AprilTag with ROS
- tags / Using AprilTag with ROS
- Arduino-ROS interface
- about / Understanding the Arduino-ROS interface, What is the Arduino-ROS interface?
- rosserial package, in ROS / Understanding the rosserial package in ROS
- ROS node APIs, in Arduino / Understanding ROS node APIs in Arduino
- Arduino subscriber, example / ROS - Arduino Publisher and Subscriber example
- Arduino publisher, example / ROS - Arduino Publisher and Subscriber example
- blink LED / Arduino-ROS, example - blink LED and push button
- push button / Arduino-ROS, example - blink LED and push button
- Accelerometer ADXL 335 / Arduino-ROS, example - Accelerometer ADXL 335
- ultrasonic distance sensor / Arduino-ROS, example - ultrasonic distance sensor
- Odometry Publisher / Arduino-ROS example - Odometry Publisher
- AR Marker detection
- working, for object pose estimation / Working with AR Marker detection for object pose estimation
- Arm specification
- joints / Type of joints
- ASIMOV Robotics
- Asus Xtion Pro
- about / Including other xacro files
- interfacing, in ROS / Interfacing Kinect and Asus Xtion Pro in ROS
B
- bloom
- reference link / Releasing your ROS package
- BSD / Understanding ROS-Industrial packages
C
- Caffe framework
- reference link / Calculating grasp poses with GPD
- camera_calibration package
- reference link / Working with ROS camera calibration
- Chefbot
- hardware configuration / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- DIY mobile robot / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- Chefbot, components
- Pololu DC Gear motor, with Quadrature encoder / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- Pololu motor drivers / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- Tiva C Launchpad Controller / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- MPU 6050 IMU / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- Xbox Kinect/Asus Xtion Pro / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- Intel NUC PC / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- Chefbot, requisites
- odometry source / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- sensor source / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- sensor transform, using tf / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- base controller / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- Chefbot firmware
- flashing, Energia IDE used / Flashing Chefbot firmware using Energia IDE
- serial data sending protocol, from LaunchPad to PC / Serial data sending protocol from LaunchPad to PC
- serial data sending protocol, from PC to Launchpad / Serial data sending protocol from PC to Launchpad
- Chefbot interface packages
- discussing, on ROS / Discussing Chefbot interface packages on ROS
- Chefbot simulation
- working / Working with Chefbot simulation
- Gazebo, room building / Building a room in Gazebo
- model files, adding to Gazebo model folder / Adding model files to the Gazebo model folder
- Child link / Understanding robot modeling using URDF
- classes
- creating, with RoboWare tools / Creating ROS nodes and classes with RoboWare tools
- CMake (Cross Platform Make) / Creating a ROS package
- CMakeLists.txt
- updating / Step 7 – Updating CMakeLists.txt
- code license agreement
- reference link / Code license agreement
- COLLADA file of robot
- creating, for OpenRave / Creating the COLLADA file of a robot to work with OpenRave
- collision checking
- with robot arm, MoveIt! used / Collision checking with a robot arm using MoveIt!
- collision object
- adding, to MoveIt! / Adding a collision object to MoveIt!
- removing, from planning scene / Removing a collision object from the planning scene
- attaching, to robot link / Attaching a collision object to a robot link
- collision properties
- adding, to URDF model / Adding physical and collision properties to a URDF model
- Collision section / Understanding robot modeling using URDF
- continuous joint / Understanding robot modeling using URDF
- controller
- building / Step 8 – Building the controller
- launch file, writing / Step 10 – Writing the launch file for the controller
- executing, with seven dof arm in Gazebo / Step 11 – Running the controller along with the seven dof arm in Gazebo
- controller configuration file
- controller header file
- creating / Step 2 – Creating the controller header file
- controller package
- creating / Step 1 - Creating the controller package
- creating, for COOL arm robot / Creating a controller package for a COOL arm robot
- controller source file
- creating / Step 3 – Creating the controller source file
- explaining / Step 4 – Explaining the controller source file
- controller_interface package
- about / The controller_interface package
- controller, initializing / Initializating the controller
- ROS controller, starting / Starting the ROS controller
- ROS controller, updating / Updating the ROS controller
- controller, stopping / Stopping the controller
- controller_manager / The controller_manager
- control system
- developing, in Simulink / Developing a simple control system in Simulink
- COOL arm-5000 / Interfacing 7 DOF DYNAMIXEL-based robotic arm to ROS MoveIt!
- Coppelia Robotics
- reference link / Setting up V-REP with ROS
- costmap
- reference link / Common configuration local_costmap and global_costmap
- custom msg
- adding / Adding custom msg and srv files
D
- 3D robot model
- visualizing, in RViz / Visualizing the 3D robot model in RViz
- 3D vision sensor
- adding, to V-REP / Adding a 3D vision sensor to V-REP
- 7 DOF DYNAMIXEL-based robotic arm
- interfacing, to ROS MoveIt! / Interfacing 7 DOF DYNAMIXEL-based robotic arm to ROS MoveIt!
- design
- developing / Creating a URDF for an industrial robot
- differential drive mobile robot
- robot model, creating / Creating a robot model for the differential drive mobile robot
- differential wheeled robot
- simulating, in Gazebo / Simulating a differential wheeled robot in Gazebo
- Digital Motion Processer (DMP) / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- disk dump (dd) / Installation in Linux
- DOF
- arm specification / Arm specification
- dynamic link libraries (.DLL) / Understanding pluginlib
- Dynamic Reconfigure / Interfacing Kinect and Asus Xtion Pro in ROS
- dynamic_reconfigure package
- reference link / Using the ROS parameter
- DYNAMIXEL-ROS interface / DYNAMIXEL-ROS interface
- DYNAMIXEL actuators
- interfacing, to ROS / Interfacing DYNAMIXEL actuators to ROS
- DYNAMIXEL ROS Servo controllers
- for robot hardware interfacing / Understanding DYNAMIXEL ROS Servo controllers for robot hardware interfacing
- DYNAMIXEL servos / The DYNAMIXEL servos
E
- Eclipse
- edge-detected-images
- visualizing / Visualizing raw and edge-detected-images
- edges
- finding, on image / Finding edges on the image
- Energia IDE
- reference link / Flashing Chefbot firmware using Energia IDE
- used, for flashing Chefbot firmware / Flashing Chefbot firmware using Energia IDE
- equations
- used, to find distance with ultrasonic range sensor / Equations to find distance using the ultrasonic range sensor
- Ethernet hotspot
- configuring, for Odroid-XU4 / Configuring an Ethernet hotspot for Odroid-XU4 and Raspberry Pi 2
- configuring, for Raspberry Pi 2 / Configuring an Ethernet hotspot for Odroid-XU4 and Raspberry Pi 2
F
- Fast SLAM / Understanding the move_base node
- fixed joint / Understanding robot modeling using URDF
- Flexible Collision Library (FCL)
- floating
- with URDF / Understanding robot modeling using URDF
- floating joint / Understanding robot modeling using URDF
G
- Gazebo
- used, for simulating robotic arm / Simulating the robotic arm using Gazebo and ROS
- used, for creating robotic arm simulation model / Creating the robotic arm simulation model for Gazebo
- robot joints moving, ROS controller used / Moving robot joints using ROS controllers in Gazebo
- differential wheeled robot, simulating / Simulating a differential wheeled robot in Gazebo
- laser scanner, adding / Adding the laser scanner to Gazebo
- mobile robot, moving / Moving the mobile robot in Gazebo
- joint state publishers, adding in launch file / Adding joint state publishers in the launch file
- controller, executing with seven dof arm / Step 11 – Running the controller along with the seven dof arm in Gazebo
- controller, executing controller, executing with seven dof arm / Step 11 – Running the controller along with the seven dof arm in Gazebo
- used, for working with perception / Working with perception using MoveIt! and Gazebo
- pick action / Pick and place action in Gazebo and real robot
- place action / Pick and place action in Gazebo and real robot
- Gazebo plugins
- about / Understanding the Gazebo plugins
- world plugin / Understanding the Gazebo plugins
- model plugin / Understanding the Gazebo plugins
- sensor plugin / Understanding the Gazebo plugins
- system plugin / Understanding the Gazebo plugins
- visual plugin / Understanding the Gazebo plugins
- gmapping node
- configuring / Configuring the gmapping node
- reference link / Configuring the gmapping node
- Grasp Pose Detector
- about / Calculating grasp poses with GPD
- reference link / Calculating grasp poses with GPD
- grasp poses
- calculating, with GPD / Calculating grasp poses with GPD
H
- Hard Kernel / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- Hokuyo Laser scanner
- interfacing, in ROS / Interfacing Hokuyo Laser in ROS
- reference link / Interfacing Hokuyo Laser in ROS
I
- IDEs
- reference link / Setting up RoboWare Studio in Ubuntu
- IKFast CPP file
- generating, for IRB 6640 robot / Generating the IKFast CPP file for the IRB 6640 robot
- IK Fast modules
- about / OpenRave and IK Fast modules
- types / OpenRave and IK Fast modules
- image processing
- OpenCV, used / Image processing using ROS and OpenCV
- ROS, used / Image processing using ROS and OpenCV
- ROS package, creating for experiment / Step 1 – Creating a ROS package for the experiment
- source files, creating / Step 2 – Creating source files
- code, explanation / Step 3 – Explanation of the code
- CMakeLists.txt file, editing / Step 4 – Editing the CMakeLists.txt file
- example, executing / Step 5 – Building and running an example
- example, building / Step 5 – Building and running an example
- images
- converting, between ROS and OpenCV using cv_bridge / Converting images between ROS and OpenCV using cv_bridge
- publishing, image_transport used / Publishing and subscribing images using image_transport
- subscribing, image_transport used / Publishing and subscribing images using image_transport
- industrial robot client APIs / Designing industrial robot client nodes
- industrial robot client nodes
- designing / Designing industrial robot client nodes
- robot_state node / Designing industrial robot client nodes
- joint_trajectory node / Designing industrial robot client nodes
- about / Designing industrial robot client nodes
- Intel Real Sense camera
- interfacing, with ROS / Interfacing Intel Real Sense camera with ROS
- IRB 2400 robot / Working with MoveIt! configuration of ABB robots, Understanding the ROS-Industrial robot support packages
- IRB 6640 robot / Working with MoveIt! configuration of ABB robots
J
- joint controller
- writing, in ROS / Writing a basic joint controller in ROS
- joint state publisher / Understanding joint state publisher
K
- Kinect
- about / Understanding the ROS Navigation stack
- interfacing, in ROS / Interfacing Kinect and Asus Xtion Pro in ROS
- Kinematic and Dynamics Library (KDL) / ROS packages for robot modeling
L
- laser sensor
- adding, to V-REP / Adding a laser sensor to V-REP
- launch file
- creating / Creating launch files
- writing, for controller / Step 10 – Writing the launch file for the controller
- licensing schemes, in ROS
- reference link / Code license agreement
M
- map
- building, SLAM used / Building a map using SLAM
- about / Running SLAM on the differential drive robot
- MATLAB (MATrix LABoratory) / Getting started with MATLAB and MATLAB-ROS
- MATLAB-ROS / Getting started with MATLAB and MATLAB-ROS
- MATLAB callback functions / Starting with ROS topics and MATLAB callback functions
- MeshLab
- reference link / Creating a URDF for an industrial robot
- motion planning
- move_group C++ interface, used / Motion planning using the move_group C++ interface
- random path, MoveIt! C++ APIs used / Motion planning a random path using MoveIt! C++ APIs
- custom path, MoveIt! C++ APIs used / Motion planning a custom path using MoveIt! C++ APIs
- motion planning of robot
- in RViz, MoveIt! configuration package used / Motion planning of robot in RViz using MoveIt! configuration package
- motor velocities
- computing, from ROS twist message / Computing motor velocities from ROS twist message
- MoveIt!
- installing / Installing MoveIt!
- architecture / MoveIt! architecture
- move_group node / The move_group node
- used, for motion planning / Motion planning using MoveIt!
- position constraints / Motion planning using MoveIt!
- orientation constraints / Motion planning using MoveIt!
- visibility constraints / Motion planning using MoveIt!
- joint constraints / Motion planning using MoveIt!
- user-specified constraints / Motion planning using MoveIt!
- motion planning request adapters / Motion planning request adapters
- FixStartStateBounds / Motion planning request adapters
- FixWorkspaceBounds / Motion planning request adapters
- FixStartStateCollision / Motion planning request adapters
- FixStartStatePathConstraints / Motion planning request adapters
- AddTimeParameterization / Motion planning request adapters
- planning scene / MoveIt! planning scene
- kinematics handling / MoveIt! kinematics handling
- collision checking / MoveIt! collision checking
- used, for collision checking with robot arm / Collision checking with a robot arm using MoveIt!
- collision object, adding / Adding a collision object to MoveIt!
- used, for working with perception / Working with perception using MoveIt! and Gazebo
- objects, manipulating / Manipulating objects with MoveIt!
- used, for working robot pick-and-place task / Working with a robot pick-and-place task using MoveIt!
- pickup / Working with a robot pick-and-place task using MoveIt!
- place / Working with a robot pick-and-place task using MoveIt!
- configuring, of COOL arm / MoveIt! configuration of the COOL Arm
- MoveIt!, concepts
- reference link / MoveIt! architecture
- Moveit! configuration
- of Universal Robot arm / Understanding the Moveit! configuration of a Universal Robot arm
- MoveIt! configuration files
- updating / Updating the MoveIt! configuration files
- testing / Testing the MoveIt! configuration
- MoveIt! configuration of ABB robots
- MoveIt! configuration package
- generating, Setup Assistant tool used / Generating MoveIt! configuration package using the Setup Assistant tool
- Setup Assistant tool, launching / Step 1 – Launching the Setup Assistant tool
- Self-Collision matrix, generating / Step 2 – Generating the Self-Collision matrix
- virtual joints, adding / Step 3 – Adding virtual joints
- planning groups, adding / Step 4 – Adding planning groups
- robot poses, adding / Step 5 – Adding the robot poses
- robot end effector, setting up / Step 6 – Setting up the robot end effector
- passive joints, adding / Step 7 – Adding passive joints
- author information / Step 8 – Author information
- configuration files, generating / Step 9 – Generating configuration files
- used, for motion planning of robot in RViz / Motion planning of robot in RViz using MoveIt! configuration package
- RViz Motion Planning plugin, used / Using the RViz Motion Planning plugin
- interfacing, to Gazebo / Interfacing the MoveIt! configuration package to Gazebo
- controller configuration file, writing for MoveIt! / Step 1 – Writing the controller configuration file for MoveIt!
- controller launch files, creating / Step 2 – Creating the controller launch files
- controller configuration file, creating for Gazebo / Step 3 – Creating the controller configuration file for Gazebo
- controller configuration file, creating, for Gazebo / Step 3 – Creating the controller configuration file for Gazebo
- launch file, creating for Gazebo trajectory controllers / Step 4 – Creating the launch file for Gazebo trajectory controllers
- Gazebo- MoveIt! interface, debugging / Step 5 – Debugging the Gazebo- MoveIt! interface
- creating, for industrial robot / Creating the MoveIt! configuration for an industrial robot
- MoveIt! IKFast package
- about / MoveIt! IKFast
- installing / Installing the MoveIt! IKFast package
- MoveIt! IKFast plugin
- about / Understanding the MoveIt! IKFast plugin
- creating, for ABB IRB 6640 robot / Creating the MoveIt! IKFast plugin for the ABB IRB 6640 robot
- prerequisites, for developing / Prerequisites for developing the MoveIt! IKFast plugin
- OpenRave / OpenRave and IK Fast modules
- IK Fast modules / OpenRave and IK Fast modules
- creating / Creating the MoveIt! IKFast plugin
- MoveIt! RViz motion planning plugin / Motion planning using the move_group C++ interface
- move_base node
- about / Understanding the move_base node
- global-planner / Understanding the move_base node
- local-planner / Understanding the move_base node
- rotate-recovery / Understanding the move_base node
- clear-costmap-recovery / Understanding the move_base node
- costmap-2D / Understanding the move_base node
- map-server / Understanding the move_base node
- AMCL / Understanding the move_base node
- gmapping / Understanding the move_base node
- MPU 6050 / Introducing to Chefbot – a DIY mobile robot and its hardware configuration
- MX-106 / The DYNAMIXEL servos
N
- Navigation packages
- working / Working with Navigation packages
- move_base node / Understanding the move_base node
- map, localizing / Localizing on the map
- path planning / Sending a goal and path planning
- goal position, sending / Sending a goal and path planning
- collision recovery behavior / Collision recovery behavior
- command velocity, sending / Sending the command velocity
- Navigation stack
- working / Working of Navigation stack
- configuring, for Chefbot / Configuring the Navigation stack for Chefbot
- RViz, working / Understanding RViz for working with the Navigation stack
- used, for obstacle avoidance / Obstacle avoidance using the Navigation stack
- goal, sending from ROS node / Sending a goal to the Navigation stack from a ROS node
- Navigation stack packages
- configuring / Configuring the Navigation stack packages
- configuration local_costmap / Common configuration local_costmap and global_costmap
- global_costmap / Common configuration local_costmap and global_costmap
- global costmap parameters, configuring / Configuring global costmap parameters
- local costmap parameters, configuring / Configuring local costmap parameters
- base local planner parameters, configuring / Configuring base local planner parameters
- DWA local planner parameters, configuring / Configuring DWA local planner parameters
- move_base node parameters, configuring / Configuring move_base node parameters
- Net Beans
- nodelet
- creating / Creating a nodelet
- package, creating / Step 1 - Creating a package for a nodelet
- hello_world.cpp nodelet, creating / Step 2 - Creating the hello_world.cpp nodelet
- hello_world.cpp, explaining / Step 3 - Explanation of hello_world.cpp
- hello_world.cpp, RViz plugin / Step 3 - Explanation of hello_world.cpp
- plugin description file, creating / Step 4 - Creating the plugin description file
- export tag, adding in package.xml / Step 5 - Adding the export tag in package.xml
- CMakeLists.txt, editing / Step 6 - Editing CMakeLists.txt
- building / Step 7 - Building and running nodelets
- executing / Step 7 - Building and running nodelets
- launch files, creating / Step 8 - Creating launch files for nodelets
- nodes
- building / Building the nodes
- non-Arduino boards
- interfacing, to ROS / Interfacing non-Arduino boards to ROS
O
- obstacle avoidance system
- implementing, for Turtlebot robot / Implementing an obstacle avoidance system for a Turtlebot robot
- Occupany Map Updator plugin / Working with perception using MoveIt! and Gazebo
- OctoMap
- octree
- about / Collision checking with a robot arm using MoveIt!
- reference link / Working with perception using MoveIt! and Gazebo
- odometry
- computing, from encoder ticks / Computing odometry from encoder ticks
- Odroid-XU4
- ROS, setting up / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- OS image, installing / How to install an OS image to Odroid-XU4 and Raspberry Pi 2
- connecting, from PC / Connecting to Odroid-XU4 and Raspberry Pi 2 from a PC
- methods / Connecting to Odroid-XU4 and Raspberry Pi 2 from a PC
- Ethernet hotspot, configuring / Configuring an Ethernet hotspot for Odroid-XU4 and Raspberry Pi 2
- Wiring Pi, installing / Installing Wiring Pi on Odroid-XU4
- OpenRave
- about / OpenRave and IK Fast modules
- installing, on Ubuntu 16.04 / Installing OpenRave on Ubuntu 16.04
- used, for creating COLLADA file of robot / Creating the COLLADA file of a robot to work with OpenRave
- OpenSLAM
- reference link / Building a map using SLAM
- Open Source Computer Vision (OpenCV)
- packages, interfacing / Understanding ROS – OpenCV interfacing packages
- converting, to ROS images using cv_bridge / Converting OpenCV to ROS images using cv_bridge
- Open source Natural Interaction (OpenNI) / Interfacing Kinect and Asus Xtion Pro in ROS
- OS image
- installing, to Odroid-XU4 / How to install an OS image to Odroid-XU4 and Raspberry Pi 2
- installing, to Raspberry Pi 2 / How to install an OS image to Odroid-XU4 and Raspberry Pi 2
- installation, in Windows / Installation in Windows
- installation, in Linux / Installation in Linux
P
- package.xml
- updating / Step 6 – Updating package.xml
- pan joint
- interacting with / Interacting with pan-and-tilt joints
- Parent link / Understanding robot modeling using URDF
- physical properties
- adding, to URDF model / Adding physical and collision properties to a URDF model
- planar joint / Understanding robot modeling using URDF
- plugin description file
- pluginlib
- about / Understanding pluginlib
- used, to creating plugins for calculator application / Creating plugins for the calculator application using pluginlib
- pluginlib_calculator package
- working / Working with the pluginlib_calculator package, Step 8 - Querying the list of plugins in a package
- calculator_base header file, creating / Step 1 - Creating the calculator_base header file
- calculator_plugins header file, creating / Step 2 - Creating the calculator_plugins header file
- plugins exporting, calculator_plugins.cpp used / Step 3 - Exporting plugins using the calculator_plugins.cpp
- plugin loader implementing, calculator_loader.cpp used / Step 4 - Implementing the plugin loader using the calculator_loader.cpp
- plugin description file, creating / Step 5 - Creating the plugin description file: calculator_plugins.xml
- plugin, registering with ROS package system / Step 6 - Registering the plugin with the ROS package system
- CMakeLists.txt file, editing / Step 7 - Editing the CMakeLists.txt file
- list of plugins, querying in package / Step 8 - Querying the list of plugins in a package
- plugin loader, executing / Step 9 - Running the plugin loader
- point cloud data
- working, to laser scan package / Working with a point cloud to a laser scan package
- working / Working with point cloud data
- publishing / How to publish a point cloud
- subscribing / How to subscribe and process the point cloud
- processing / How to subscribe and process the point cloud
- data, writing / Writing data to a Point Cloud Data (PCD) file
- reading, from PCD file / Reading and publishing a point cloud from a PCD file
- publishing, from PCD file / Reading and publishing a point cloud from a PCD file
- Point Cloud Library (PCL)
- packages, interfacing / Understanding ROS - PCL interfacing packages
- URL / Understanding ROS - PCL interfacing packages
- ROS perception, installing / Installing ROS perception
- Pololu DC Gear motor
- Pololu motor drivers
- prismatic joint / Understanding robot modeling using URDF
- Probabilistic Robotics
- reference link / Understanding AMCL
Q
- Qt / Methodology of building the RViz plugin
- QtCreator
- Query Goal State / Using the RViz Motion Planning plugin
- Query Start State / Using the RViz Motion Planning plugin
R
- Raspberry Pi
- Raspberry Pi 2
- ROS, setting up / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- OS image, installing / How to install an OS image to Odroid-XU4 and Raspberry Pi 2
- connecting, from PC / Connecting to Odroid-XU4 and Raspberry Pi 2 from a PC
- methods / Connecting to Odroid-XU4 and Raspberry Pi 2 from a PC
- Ethernet hotspot, configuring / Configuring an Ethernet hotspot for Odroid-XU4 and Raspberry Pi 2
- Wiring Pi, installing / Installing Wiring Pi on Raspberry Pi 2
- Raspbian images
- reference link / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- raw images
- visualizing / Visualizing raw and edge-detected-images
- real robot
- pick action / Pick and place action in Gazebo and real robot
- place action / Pick and place action in Gazebo and real robot
- remote APIs
- reference link / Setting up V-REP with ROS
- revolute joint / Understanding robot modeling using URDF
- rgb-d sensor / Adding a 3D vision sensor to V-REP
- robot description
- ROS package, creating for / Creating the ROS package for the robot description
- creating, for seven DOF robot manipulator / Creating the robot description for a seven DOF robot manipulator
- robotic arm
- simulating, Gazebo used / Simulating the robotic arm using Gazebo and ROS
- simulating, ROS used / Simulating the robotic arm using Gazebo and ROS
- simulating, with Xtion Pro / Simulating the robotic arm with Xtion Pro
- 3D sensor data, visualizing / Visualizing the 3D sensor data
- simulating, with V-REP / Simulating the robotic arm using V-REP and ROS
- simulating, with ROS / Simulating the robotic arm using V-REP and ROS
- simulating with V-REP / Simulating the robotic arm using V-REP and ROS
- simulating with ROS / Simulating the robotic arm using V-REP and ROS
- robotic arm simulation model
- creating, for Gazebo / Creating the robotic arm simulation model for Gazebo
- colors, adding to Gazebo robot model / Adding colors and textures to the Gazebo robot model
- textures, adding to Gazebo robot model / Adding colors and textures to the Gazebo robot model
- transmission tags, adding to actuate model / Adding transmission tags to actuate the model
- gazebo_ros_control plugin, adding / Adding the gazebo_ros_control plugin
- 3D vision sensor, adding to Gazebo / Adding a 3D vision sensor to Gazebo
- Robotic System Toolbox
- ROBOTIS
- about / The DYNAMIXEL servos
- reference link / The DYNAMIXEL servos
- robot joints
- moving, ROS controller used in Gazebo / Moving robot joints using ROS controllers in Gazebo
- robot model
- creating, for differential drive mobile robot / Creating a robot model for the differential drive mobile robot
- robot modeling
- with URDF / Understanding robot modeling using URDF
- with, URDF / Understanding robot modeling using URDF
- xacro, using / Understanding robot modeling using xacro
- properties, using / Using properties
- math expression, using / Using the math expression
- macros, using / Using macros
- Robot Operating System (ROS) / Why should we learn ROS?
- robot pick-and-place task
- working, MoveIt! used / Working with a robot pick-and-place task using MoveIt!
- robot standalone launch file
- executing, C++ nodes used / Running the robot standalone launch file using C++ nodes
- robot state publisher / Understanding robot state publisher
- RoboWare interface
- ROS tool, beginning / Starting ROS tools from the RoboWare interface
- RoboWare Studio
- setting up, in Ubuntu / Setting up RoboWare Studio in Ubuntu
- installing / Installing/uninstalling RoboWare Studio
- uninstalling / Installing/uninstalling RoboWare Studio
- about / Getting started with RoboWare Studio
- ROS packages, creating / Create ROS packages in RoboWare Studio
- ROS workspace, building / Building ROS workspace in RoboWare Studio
- ROS nodes, executing / Executing ROS nodes in RoboWare Studio
- ROS package manager in / ROS package manager in RoboWare Studio
- RoboWare Studio, installation
- URL, for downloading / Installing/uninstalling RoboWare Studio
- ROS
- learning / Why should we learn ROS?
- about / Why should we learn ROS?, Getting started with ROS and Simulink
- selecting, over other robotic platforms / Why we prefer ROS for robots
- features / Why we prefer ROS for robots
- limitations / Why some do not prefer ROS for robots
- reference link / ROS community level
- prerequisites / What are the prerequisites for starting with ROS?
- used, for simulating robotic arm / Simulating the robotic arm using Gazebo and ROS
- V-REP, setting up / Setting up V-REP with ROS
- used, for robotic arm simulating / Simulating the robotic arm using V-REP and ROS
- joint controller, writing / Writing a basic joint controller in ROS
- non-Arduino boards, interfacing / Interfacing non-Arduino boards to ROS
- setting up, on Odroid-XU4 / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- setting up, on Raspberry Pi 2 / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- setting, on Odroid-XU4 / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- setting, on Raspberry Pi 2 / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- used, for blinking LED on Raspberry Pi 2 / Blinking LED using ROS on Raspberry Pi 2, Push button + blink LED using ROS on Raspberry Pi 2
- used, with push button on Raspberry Pi 2 / Push button + blink LED using ROS on Raspberry Pi 2
- examples, executing in Raspberry Pi 2 / Running examples in Raspberry Pi 2
- DYNAMIXEL actuators, interfacing / Interfacing DYNAMIXEL actuators to ROS
- AprilTag, used / Using AprilTag with ROS
- best practices / Best practices in ROS
- standard naming conventions, used / Standard naming conventions used in ROS
- code license agreement / Code license agreement
- code formatting / ROS code formatting
- console output / Console output
- troubleshooting tips / Important troubleshooting tips in ROS
- roswtf, using / Using roswtf
- ROS, community level / ROS community level
- ROS, computation graph level
- about / Understanding the ROS computation graph level
- nodes / ROS nodes
- messages / ROS messages
- topics / ROS topics
- services / ROS services
- bags / ROS bags
- master / The ROS Master
- parameter, using / Using the ROS parameter
- ROS, filesystem level
- about / Understanding the ROS filesystem level
- packages / ROS packages
- metapackages / ROS metapackages
- messages / ROS messages
- services / The ROS services
- ROS-Industrial packages
- about / Understanding ROS-Industrial packages, Getting started with real Universal Robots hardware and ROS-I
- goals / Goals of ROS-Industrial
- history / ROS-Industrial – a brief history
- benefits / Benefits of ROS-Industrial
- installing / Installing ROS-Industrial packages
- block diagram / Block diagram of ROS-Industrial packages
- installing, Universal robotic arms / Installing ROS-Industrial packages of Universal robotic arms
- ROS-Industrial packages, block diagram
- reference link / Block diagram of ROS-Industrial packages
- ROS-Industrial robot client package / ROS-Industrial robot client package
- ROS-Industrial robot driver package / ROS-Industrial robot driver package
- ROS-Industrial robot support packages / Understanding the ROS-Industrial robot support packages
- ROS-MATLAB interface / Getting started with the Robotic System Toolbox and ROS-MATLAB interface
- ROS action client
- ROS actionlib
- working / Working with ROS actionlib
- ROS action server
- creating / Creating the ROS action server
- building / Building the ROS action server and client
- ROS bags
- reference link / ROS bags
- rosbash
- reference link / ROS packages
- ROS C++
- coding style guide / ROS C++ coding style guide
- ROS camera calibration
- working / Working with ROS camera calibration
- images, converting between ROS and OpenCV using cv_bridge / Converting images between ROS and OpenCV using cv_bridge
- image processing, ROS used / Image processing using ROS and OpenCV
- image processing, OpenCV used / Image processing using ROS and OpenCV
- ROS communications-related packages
- reference link / Understanding the ROS computation graph level
- ROS controller
- used, for moving robot joints in Gazebo / Moving robot joints using ROS controllers in Gazebo
- ros_control packages / Understanding the ros_control packages
- hardware interfaces / Different types of ROS controllers and hardware interfaces
- types / Different types of ROS controllers and hardware interfaces
- interacting, with Gazebo / How the ROS controller interacts with Gazebo
- joint state controller, interfacing / Interfacing joint state controllers and joint position controllers to the arm
- joint position controller, interfacing / Interfacing joint state controllers and joint position controllers to the arm
- launching, with Gazebo / Launching the ROS controllers with Gazebo
- robot joints, moving / Moving the robot joints
- roscore command output
- checking / Checking the roscore command output
- ROS Graph layer / Understanding the ROS computation graph level
- ROS interface
- adding, to V-REP joint controllers / Adding the ROS interface to V-REP joint controllers
- installing, of Universal Robots / Installing the ROS interface of Universal Robots
- ROS Kinetic
- reference link / What are the prerequisites for starting with ROS?
- URL, for installing / Setting ROS on Odroid-XU4 and Raspberry Pi 2
- roslaunch / Creating launch files
- ROS Master
- ROS message
- working, in Simulink / Working with ROS messages in Simulink
- publishing, in Simulink / Publishing a ROS message in Simulink
- publish / Publishing a ROS message in Simulink
- blank message / Publishing a ROS message in Simulink
- ROS Navigation stack
- about / Understanding the ROS Navigation stack
- hardware requisites / ROS Navigation hardware requirements
- reference link / ROS Navigation hardware requirements
- odometry source / ROS Navigation hardware requirements
- sensor source / ROS Navigation hardware requirements
- sensor transforms/tf / ROS Navigation hardware requirements
- base_controller / ROS Navigation hardware requirements
- Navigation packages, working / Working with Navigation packages
- installing / Installing the ROS Navigation stack
- ROS node APIs
- in Arduino / Understanding ROS node APIs in Arduino
- ROS nodelets / Understanding ROS nodelets
- ROS nodes
- creating / Creating ROS nodes
- handling / Handling active ROS topics, nodes, and services
- creating, with RoboWare tools / Creating ROS nodes and classes with RoboWare tools
- ROS package
- creating / Creating a ROS package
- maintaining / Maintaining the ROS package
- releasing / Releasing your ROS package, Releasing our package
- preparing, for release / Preparing the ROS package for the release
- creating, for ROS package / Creating a Wiki page for your ROS package
- for 3D robot modeling / ROS packages for robot modeling
- creating, for robot description / Creating the ROS package for the robot description
- reference link / Implementing autonomous navigation using amcl and a static map
- best practices / Best practices in the ROS package
- version control / Best practices in the ROS package
- packaging / Best practices in the ROS package
- ROS parameter server
- ROS perception
- installing / Installing ROS perception
- packages / Installing ROS perception
- rosserial package
- in ROS / Understanding the rosserial package in ROS
- function / Understanding the rosserial package in ROS
- installing, on Ubuntu 16.04 / Installing rosserial packages on Ubuntu 16.04
- ROS services
- working / Working with ROS services
- used, for V-REP interacting / Interacting with V-REP using ROS services, Interacting with V-REP using ROS topics
- handling / Handling active ROS topics, nodes, and services
- ROS teleop node
- adding / Adding the ROS teleop node
- ROS topic
- subscribing, in Simulink / Subscribing to a ROS topic in Simulink
- ROS topics
- working / Working with ROS topics
- used, for V-REP interacting / Interacting with V-REP using ROS topics
- about / Starting with ROS topics and MATLAB callback functions
- handling / Handling active ROS topics, nodes, and services
- ROS troubleshooting
- reference link / Using roswtf
- ROS visualization tool (RViz)
- about / Understanding the ROS visualization tool (RViz) and its plugins
- plugins / Understanding the ROS visualization tool (RViz) and its plugins
- displays panel / Displays panel
- toolbar / RViz toolbar
- Views panel / Views
- Time panel / Time panel
- dockable panels / Dockable panels
- roswtf
- using / Using roswtf
- reference link / Using roswtf
- ros_control
- ros_control packages
- about / Understanding ros_control packages
- controller_interface package / The controller_interface package
- controller_manager / The controller_manager
- rqt_bag
- reference link / ROS bags
- RViz
- 3D robot model, visualizing / Visualizing the 3D robot model in RViz
- working, with Navigation stack / Understanding RViz for working with the Navigation stack
- 2D Pose Estimate button / 2D Pose Estimate button
- particle cloud, visualizing / Visualizing the particle cloud
- 2D Nav Goal button / The 2D Nav Goal button
- static map, displaying / Displaying the static map
- robot footprint, displaying / Displaying the robot footprint
- local cost map, displaying / Displaying the global and local cost map
- global cost map, displaying / Displaying the global and local cost map
- global plan, displaying / Displaying the global plan, the local plan, and the planner plan
- local plan, displaying / Displaying the global plan, the local plan, and the planner plan
- planner plan, displaying / Displaying the global plan, the local plan, and the planner plan
- current goal / The current goal
- RViz Motion Planning plugin
- RViz plugin
- writing, for teleoperation / Writing an RViz plugin for teleoperation
- methodology, building / Methodology of building the RViz plugin
- package, creating / Step 1 – Creating the RViz plugin package
- header file, creating / Step 2 – Creating the RViz plugin header file
- creating / Step 3 – Creating the RViz plugin definition
- description file, creating / Step 4 – Creating the plugin description file
- export tags, adding in package.xml / Step 5 – Adding the export tags in package.xml
- CMakeLists.txt, editing / Step 6 – Editing CMakeLists.txt
- plugin, building / Step 7 – Building and loading plugins
- plugin, loading / Step 7 – Building and loading plugins
S
- self-collisions
- checking, MoveIt! APIs used / Checking self-collisions using MoveIt! APIs
- Semantic Description Format (SDF) / Building a room in Gazebo
- Semantic Robot Description Format (SRDF) / The move_group node
- services applications / Applications of topics, services, and actionlib
- Setup Assistant tool
- used, for generating MoveIt! configuration package / Generating MoveIt! configuration package using the Setup Assistant tool
- seven DOF arm
- about / Explaining the xacro model of the seven DOF arm
- constants, using / Using constants
- macros, using / Using macros
- xacro files / Including other xacro files
- meshes, using in link / Using meshes in the link
- robot gripper, working with / Working with the robot gripper
- viewing, in RViz / Viewing the seven DOF arm in RViz
- seven dof arm in Gazebo
- controller along, running / Step 11 – Running the controller along with the seven dof arm in Gazebo
- shared objects (.so) / Understanding pluginlib
- Simulink
- about / Getting started with ROS and Simulink
- wave signal integrator, creating / Creating a wave signal integrator in Simulink
- ROS messages, working / Working with ROS messages in Simulink
- ROS message, publishing / Publishing a ROS message in Simulink
- ROS topic, subscribing / Subscribing to a ROS topic in Simulink
- control system, developing / Developing a simple control system in Simulink
- Simulink model
- configuring / Configuring the Simulink model
- Simultaneous Localization and Mapping (SLAM)
- about / Why we prefer ROS for robots
- used, for building map / Building a map using SLAM
- launch file, creating for gmapping / Creating a launch file for gmapping
- executing, on differential drive robot / Running SLAM on the differential drive robot
- autonomous navigation implementing, amcl used / Implementing autonomous navigation using amcl and a static map
- autonomous navigation implementing, static map used / Implementing autonomous navigation using amcl and a static map
- amcl launch file, creating / Creating an amcl launch file
- source files
- code, explanation / Step 3 – Explanation of the code
- Southwest Research Institute (SwRI) / ROS-Industrial – a brief history
- srv files
- adding / Adding custom msg and srv files
T
- tilt joint
- interacting with / Interacting with pan-and-tilt joints
- Tiva C Launchpad Controller
- topics applications / Applications of topics, services, and actionlib
- Transistor-Transistor Logic (TTL) / The DYNAMIXEL servos
- Turtlebot robot
- obstacle avoidance system, implementing / Implementing an obstacle avoidance system for a Turtlebot robot
U
- Universal Robots
- Universal Robots hardware / Getting started with real Universal Robots hardware and ROS-I
- UR3 robots / Installing ROS-Industrial packages of Universal robotic arms
- UR5 robots / Installing ROS-Industrial packages of Universal robotic arms
- UR10 robots / Installing ROS-Industrial packages of Universal robotic arms
- URDF
- about / ROS packages for robot modeling
- joint_state_publisher node / ROS packages for robot modeling
- kdl_parser / ROS packages for robot modeling
- robot_state_publisher / ROS packages for robot modeling
- xacro / ROS packages for robot modeling
- creating, for industrial robot / Creating a URDF for an industrial robot
- modularize / Creating a URDF for an industrial robot
- collision-aware / Creating a URDF for an industrial robot
- joint conventions / Creating a URDF for an industrial robot
- Xacro macros / Creating a URDF for an industrial robot
- standards frames / Creating a URDF for an industrial robot
- URDF design
- simplifying / Creating a URDF for an industrial robot
- URDF file
- about / Explaining the URDF file
- URDF model
- creating / Creating our first URDF model
- URDF tags
- reference link / Understanding robot modeling using URDF
- USB To DYNAMIXEL controller / The DYNAMIXEL servos
- USB webcams
- interfacing, in ROS / Interfacing USB webcams in ROS
- usb_cam package
- reference link / Interfacing USB webcams in ROS
V
- V-REP
- setting up, with ROS / Setting up V-REP with ROS
- modes / Setting up V-REP with ROS
- interacting, with ROS services / Interacting with V-REP using ROS services, Interacting with V-REP using ROS topics
- interacting, with ROS topics / Interacting with V-REP using ROS topics
- used, for robotic arm simulating / Simulating the robotic arm using V-REP and ROS
- wheeled robot, simulating / Simulating a differential wheeled robot in V-REP
- laser sensor, adding / Adding a laser sensor to V-REP
- 3D vision sensor, adding / Adding a 3D vision sensor to V-REP
- V-REP joint controllers
- ROS interface, adding / Adding the ROS interface to V-REP joint controllers
- Vector Field Histogram (VFH) / Implementing an obstacle avoidance system for a Turtlebot robot
- Version Control System (VCS / Understanding the ROS filesystem level
- Version Control System (VCS) / Maintaining the ROS package
- Views panel / Views
- vrep_plugin / Understanding the vrep_plugin
W
- wave signal integrator
- creating, in Simulink / Creating a wave signal integrator in Simulink
- wheeled robot
- simulating, in V-REP / Simulating a differential wheeled robot in V-REP
- Wiki page
- creating, for ROS package / Creating a Wiki page for your ROS package
- Win32diskimage
- about / Installation in Windows
- URL, for downloading / Installation in Windows
- Wiring Pi
- about / Configuring an Ethernet hotspot for Odroid-XU4 and Raspberry Pi 2
- installing, on Odroid-XU4 / Installing Wiring Pi on Odroid-XU4
- installing, on Raspberry Pi 2 / Installing Wiring Pi on Raspberry Pi 2
- world plugin
- creating / Creating a basic world plugin
X
- xacro
- used, for robot modeling / Understanding robot modeling using xacro
- Simplify URDF / Understanding robot modeling using xacro
- programmability / Understanding robot modeling using xacro
- using, for robot modeling / Understanding robot modeling using xacro
- converting, to URDF / Converting xacro to URDF
- converting to URDF / Converting xacro to URDF
- XMLRPC (XML Remote Procedure Call) / The ROS Master
- Xtion Pro
- robotic arm, simulating / Simulating the robotic arm with Xtion Pro
Y
- Yaskawa Motoman Robotics