Installation
Documentation
Browse Packages
News
Community
Loading
Rock
the Robot Construction Kit
/
Table of Contents
Go to
master
stable
Flavor
next
Table of Contents
Intro
Overview
About Rock
Installation
Managing Packages
Packages API
Tutorials
Basics
Advanced
System Management
Core
Base Types
Build System
Developing Components
Running Components
Running Complex Systems
Data Analysis
Graphical User Interface
Additional Core Functionality
Data Processing
Device Drivers
Envire
Debugging Techniques
Table of Contents
Table of Contents
Overview
Development Workflow
Data Analysis
Advanced System Management
About Rock
Relation to Others
What’s the difference with the Orocos Toolchain?
How does Rock relate to the Robot Operating System (ROS)?
What is Rock?
Overview
Origin
Release Strategy
Contributing
Generating your own package directory
Acknowledging Rock
Installation
Level of support
Well tested Oses
Untested OSes
Status for other
Installation: the easy way
Other bootstrapping options
Maintaining a Rock installation
Managing Packages
Managing Packages
Plain C++ Libraries
Ruby libraries
vizkit Widgets
vizkit 3D Plugins
oroGen projects
Package Structure
Categories
Naming
Libraries and oroGen components
Mapping between local installation and gitorious repositories
Rock CMake Macros
Initialization
Executable Targets (
rock_executable
)
Library Targets (
rock_library
)
Vizkit Plugin Targets (
rock_vizkit_plugin
)
Vizkit Widget Targets (
rock_vizkit_widget
)
Test Suite Targets (
rock_testsuite
)
Using Rock packages outside of Rock
Preparations
How to build the other packages
Packages API
Basics
Introduction
Rock Tutorials
What to expect from the basic tutorials
Quick Start.
Tutorials Outline
Installing the tutorial results
Creating libraries
Abstract
Creating libraries
Adding the required functionality
Integration into the build system
Build it
Summary
Creating components
Abstract
Creating an oroGen component
Define tasks
Integration into the build system
Writing the task
Run it
Summary
Configure components
Abstract
Configure a component
Update the build configuration
Embed the configuration property into the oroGen component
Build the task
Embedding configuration into the ruby script
Run it
Use a configuration file
Summary
Connecting components
Abstract
Create a consumer component
Connecting multiple components
Run it
Summary
Installing Packages
Abstract
Finding available packages and oroGen tasks
Package / Packages Sets
Adding Package Sets
Installing Packages
Summary
Viewing The Data (Live / Log Files)
Abstract
Task Inspector
Logging Data
rock-replay
Summary
Simulate a Robot
Abstract
Implementation
Create a new library
Wrapping it up
Define task
Run it
Adding a Joystick into the Mix
Tutorial Info
Finding a standard task that provides a port X.
Integration of the task
Run it
Control through a Virtual Joystick
Tutorial Info
Finding the right widget
Integrating it
Run it
Advanced
Introduction
Advanced Rock Tutorials
What to expect from the advanced tutorials
Installing the tutorial results
Deployments
Defining deployments
Usage in Ruby scripts
Replaying data in scripts
Data Visualization
Abstract
Displaying Data with Vizkit
Designing a custom GUI
Connecting a custom GUI with an orocos task
Connecting a custom GUI with log files
Summary
3D Data Visualization
Abstract
Vizkit 3D
How to use it
Feeding data to your plugin
Writing a Vizkit C++ Widget
Abstract
Create Qt Designer Widget
Access widget from Ruby
Register the Widget to be accessible via TaskInspector and RockReplay
Summary
Writing a 3D Vizkit plugin
Abstract
Implementation
Displaying more than one type with a single plugin
Configuration Interface
Interfacing with Ruby scripts
Using Avahi to find the tasks
Abstract
Ruby scripts
The Avahi nameservice
Run it
Summary
System Management
System Management
Moving to bundles
Abstract
Create the bundle
Logs in bundles
Move on to the next tutorial
First composition
Abstract
A first model-based script
Checking the script and running the network
Stopping the script
What happened ?
Summary
Going abstract - Data Services
Abstract
Data Services
Abstracting the command generator
Adding a random-motion generator
Running the final network
Conclusion
Basic workflow
Abstract
Starting and restarting processes
Defining modalities
Summary
Configuration files
Abstract
Presentation
Defining multiple configurations
Summary
Refining models - a leader/follower system
Abstract
The leader-follower system
Specializations
Adding ports to compositions
Summary
Base Types
Introduction
Basic Types
Time
TimeMark
Angle
Matrix / Vector
Pose
Motion Command
Odometry
Waypoint
Samples
Actuators
Build System
Introduction
What is Autoproj
Overview of an autoproj installation
Software packages in Autoproj
Bootstrapping
Bootstrapping
Basic usage
Shell helpers
Switching configuration
The manifest file.
Structure
Listing and adding package sets
Listing the available packages.
Picking the packages to build
Adding packages
Building a new package
Importing a package from a VCS
Sharing package definitions with the rest of the world
Understanding autoproj error messages
I know nothing about a prepackaged package called ‘XXXX’, …
XXX depends on YYY, which is excluded from the build
The osdeps system
Declaring and inspecting dependencies
Fine-tuning the osdeps behaviour
Behaviour during bootstrapping
Behaviour on operating systems (OS) not supported by autoproj
Getting a bit of help from autoproj even in modes different than ‘all’
Advanced
Advanced Topics
Customizing the installation
Changing the installation’s layout
Removing packages from the build (
exclude_packages
)
Using packages that are already installed (
ignore_packages
)
Local overrides of version control information
Tuning what files autoproj looks at to determine if a package should be updated
Building local packages
Setting up the path to specific commands (make, parallel builds)
More complex customization
Building packages selectively on the command line
Tooling with shell scripts
Query Syntax
Query Fields
Output Formatting
Examples
The manifest.xml file
Creating a package set
Adding a package
Autobuild scripts
source.yml
Interaction between package sets definition files
Using configuration options
Writing autobuild scripts
Defining CMake packages
Defining autotools packages
Defining Ruby packages
Defining oroGen packages
OS-specific bits (
not_on
and
only_on
)
Custom package building
Declaring documentation targets
Defining dependencies
Defining and using options
Writing Package Handlers
Reporting
Running Subcommands
Package import
Common Importer Options
Git
Subversion
CVS
Tar archives
Patching the source once it is checked out/updated
Package Dependencies
When to make a dependency optional
Dependencies in the package’s manifest.xml
Dependencies in autobuild files
Cross-Set Dependencies
Operating System dependencies
Defining dependencies between source packages and OS packages
OS packages
RubyGems packages
Ignoring some dependencies
Relationship between source packages and osdeps packages
Supporting new OSes in autoproj
Adding support in autoproj
Testing
Autoproj API
Autobuild API
Developing Components
The Workflow
What are oroGen and typeGen
Tutorials
The Development Workflow
The Runtime Workflow
Cheat Sheet (PDF)
Type definitions
Task Interface
Interface Elements
Limits on Types Used in the Interface
Ports
Properties
Operations
C++ objects representing the interface elements
Default and required activities
Dynamic Ports
Task States
The nominal RTT state machine
Error handling in the full RTT state machine
Designing states in oroGen components
Components that need configuration
Extending the state machine
Task Inheritance
Deployments
The deployment block
Instanciating tasks
Threading
Initial setup of the generated deployment
Logger integration
Triggering
Triggering Mechanisms
Periodic Triggering
Declaration
C++ task implementation
Data-Driven Tasks
Declaration
C++ task implementation
Deployment
FD-driven tasks
Declaration
Mandatory setup in the C++ task
Runtime use in updateHook()
Cross-project dependencies
Advanced - Writing oroGen plugins
Advanced - oroGen additions to the standard RTT component interface
Advanced - Opaque types
API
Running Components
Introduction
Running components using Ruby
Tutorials
Quickstart
oroinspect - finding out what is there
oroGen types and Ruby scripts
General API
Mapping between C++ and Ruby
Structures
Arrays
std::vector
Enums
Opaque Types (ADVANCED SUBJECT)
Customization on the Ruby side
Direct Access to the Type Models
Starting the system up
Manipulating tasks
Getting a hold on task contexts
Manipulating and monitoring the component’s state
Properties
Data connections
Port access
Creating connections
Disconnecting
Reading outputs or writing inputs
Configuration Files
Configuration file format
Using single configuration files
Configuration directories
Generating configuration files from the tasks
Generating configuration files from property logs
Error messages
failed to contact the name server (Orocos::CORBAError)
API
Running Complex Systems
Introduction
Advanced System Deployment
Tutorials
Naming conventions
Models, classes and instances
General Concept
Components
System model files vs. deployment files
Workflow
Step 1: Modelling
Step 2: Subsystem Design
Step 3: Runtime deployment
Data Services
Model Hierarchy
Linking to concrete components
Task Contexts
Modelling
Configurations
Extending the Model
Compositions
Providing Services
Configuration
Dependency specification: tasks and behaviours
Extending the Composition Models
Devices
Declaring devices
Describing the Robot Hardware
Communication Busses
Declaring Device Drivers
Combus Support
(Advanced)
Subsystem Design
Instance Requirements
Deployment Files
Orocos Deployments
Orocos rb api
Roby guide
Data Analysis
Overview
Data Analysis
Setting Up Data Logging
The setup
Making oroGen deployments logging-ready
Logging all output ports using Orocos.rb
Hand-made logging using orocos.rb
Reading Log Data
pocolog: command-line inspection of log files
Getting the data as a CSV file
Reading log files using Ruby scripts
Replay Log Data
Features
Usage
Understanding time in log files
Example: Loading and accessing log data:
Example: Loading and replaying log data
Example: Filtering log data
Example: Advanced
Updating log files
Updating base-type samples
Updating custom samples
Graphical User Interface
Overview
Vizkit
2D Visualization
3D Visualization
Developing a Simple GUI
Displaying Log Files
Plotting Data
Qt Designer
Vizkit 3D
Using Vizkit3D
Writing Vizkit3D Plugins
Adding Properties
Ruby
Available Widgets
Writing Vizkit Widgets
Writing Custom ruby Widgets
Writing Custom C++ Widgets
Data Processing
Data Acquisition
Data is King
Timestamping
Time-ordered data processing
The timestamp estimator
Filtering jitter
Estimating latency
... API and oroGen usage
The TimestampEstimator class
Timestamper Usage
Handling bursts and lost packages
Estimating latency through hardware timestamps
TimestampEstimator at the oroGen level
Processing Data - the Stream Aligner
Stream Aligner Principles
Period, latency and stream aligner timeout
Using the stream aligner
... in oroGen
... at Runtime
Monitoring
Handling Geometry - the Transformer
... in oroGen
Latency Considerations
... at runtime
Component Interface
Transformation Specifications
Ruby scripting
... in Roby
The need for more
Additional transformer modelling
Transformer configuration
Instanciating networks with transformations
Device Drivers
Introduction
Structure
Naming conventions
Writing a device driver
Guidelines
Opening / Closing a device
Packet Extraction
Use Cases
Type 1
Type 2
Type 2 disguised as Type 1
Summary
oroGen Integration
Guidelines
Usage
Details about the iodrivers_base::Task interface
Envire
Overview
Envire Rationale
Overview
Core Features
Creation & Object Ownership
Structure
Serialization
Frame Tree
Frame Tree
Transformation
Uncertainty
Maps
Maps
Metadata
Examples of Maps
Operators
Operators
Debugging Techniques
Base Logging
Introduction
Adding the base logger to a library
Using the logger
Configuring the base logger
Compile-time
At run-time