This page provides an overview about the SDK Robot-Workstation.
The Intera SDK provides a software interface allowing researchers of all disciplines to develop custom applications to run on their Rethink Robot.
The SDK interfaces with the robot via ROS (Robot Operating System). The robot provides a stand-alone ROS Master to which any development workstation can connect and control the robot via the various ROS APIs.
Robot Hardware Foundations
When you have run through the Installation procedures and you have established communication with your robot, to learn more about what sensors and motors are on the robot and how to use them, see:
Throughout the Wiki, Tutorials, and SDK, we refer to the "SDK Shell" and your "ROS Workspace" or "Environment". These are simple environment concepts and configurations that are useful to have a basic understanding of when using the SDK and ROS.
Your "ROS Workspace" (also called a "Catkin Workspace" in the ROS world), is the
~/ros_ws/ directory you setup in the Installation Tutorials. Inside the
src/ sub-directory, you can create or checkout source code as ROS Packages, which you can then compile and link against via the
The SDK Shell is a term we use to refer to a session in a shell, or Terminal, with the ROS Environment Variables properly configured to point to your ROS Workspace, the Robot, and your computer's ROS ID.
The ROS Environment Variables have three important functions:
- Identifying your robot and Workstation on the ROS Network, based on your Network Configuration.
- Pointing to the path of the ROS Packages, tools, and programs, when you use rosrun (execute programs).
- Linking to the libraries and workspaces when compiling source code.
If you are new to the ROS world, it is highly recommended you take the time to go through the Beginner Level Core ROS Tutorials. Personally recommended is to at least do:
- The first few Configure through 'Understanding ROS' tutorials - (Remember: we use
~/catkin_ws/but they are exactly the same).
- Also, the 'Writing a Simple Publisher and Subscriber' tutorials can be pretty useful when it comes to writing your first ROS program for the ROS newbie.
At the core of the SDK are the interfaces provided to control and access all of the robot's motors and sensors. These sections describe the hardware components of the robot and the foundation API layers upon which the SDK - and your programs - are built. These sections describe the Components of the Robot, and the Interfaces to control them.
SDK Foundations (Interfaces)
The SDK provides interfaces that control the robot hardware layer via the Robot Operating System (ROS) to any other computers on the robot's network. By using the ROS network layer API, any client library or program that can "speak ROS" can control the robot directly. By using the foundation ROS interface layer, the robot can be controlled and programmed in any Programming Language that supports ROS. This has led to a number of user-created interface libraries in different languages. In addition, the Intera Interface provides a Python Class-based interface library, which wraps many of the ROS interfaces in Python Classes.
The ROS Interface is the foundation upon which all interaction with the robot passes through and all other interface layers are built upon. The ROS layer is accessible over the network via any of the standard ROS Client Libraries such as rospy (Python) or roscpp (C++).
The ROS API describes the base interface layer for direct access from the command line or any language.
The SDK also offers a Python API via the
intera_interface module. This module wraps the ROS Interfaces in component-based Python Classes. The SDK Examples are written using this library in order to demonstrate how to use the robot interfaces.
Gives a basic introduction to each class and component in the Python interface library 'intera_interface'.
View the generated Python Code API docs for the intera_interface module.