Drake ("dragon" in Middle English) is a C++ toolbox started by the Robot Locomotion Group at the MIT Computer Science and Artificial Intelligence Lab (CSAIL). The :doc:`development team has now grown significantly </credits>`, with core development led by the Toyota Research Institute. It is a collection of tools for analyzing the dynamics of our robots and building control systems for them, with a heavy emphasis on optimization-based design/analysis.
While there are an increasing number of simulation tools available for robotics, most of them function like a black box: commands go in, sensors come out. Drake aims to simulate even very complex dynamics of robots (e.g. including friction, contact, aerodynamics, ...), but always with an emphasis on exposing the structure in the governing equations (sparsity, analytical gradients, polynomial structure, uncertainty quantification, ...) and making this information available for advanced planning, control, and analysis algorithms. Drake provides interfaces to high-level languages (MATLAB, Python, ...) to enable rapid-prototyping of new algorithms, and also aims to provide solid open-source implementations for many state-of-the-art algorithms. Finally, we hope Drake provides many compelling examples that can help people get started and provide much needed benchmarks. We are excited to accept user contributions to improve the coverage.
Here is a quick summary of capabilities:
- Modeling Dynamical Systems
- C++ block-diagram modeling environment with support for:
- Continuous, discrete, hybrid, event-triggered, and multi-rate systems
- Stochastic systems
- System constraints
- Rigid-body kinematics and dynamics
- Rigorously designed and tested, well-documented multi-body library
- Load from :doc:`SDF / URDF models <models>` (+ a few custom tags)
- Contact/collisions modeled with either compliant or rigid contact using continuous (differential equation) and discrete (difference equation, i.e., time stepping) models; Coming soon: hybrid models for rigid contact
- Geometry queries (e.g. collision detection, contact queries, and sensor queries) for simple geometries and convex meshes; Coming soon: non-convex meshes and multi-contact
- Rich library of kinematic and dynamic queries (e.g. Centroidal dynamics, Center of Pressure, Kinematic Jacobians, ...)
- Sensor models (lidar, RGB-D camera, imu, contact force/torque)
- Hand-derived models for many canonical control dynamical systems
- Easily add your own models/components
- For nearly all of the above we aim to expose sparsity in the governing equations and provide analytical gradients / symbolic analysis
- Coming soon:
- API upgrade from RigidBodyTree to MultiBodyTree
- Soft-body kinematics and dynamics
- More sophisticated rendering (towards photo-realism) and noise models for perception
- Core Libraries / Utilities
- MathematicalProgram, a C++ interface wrapping many open-source and commercial solvers
- Symbolic Computation, Eigen-compatible scalar types for symbolic design and analysis
- Simulation and Analysis
- Simulation with a suite of numerical integration routines
- Local stability/controllability/observability analysis (via linearization / semi-definite programming)
- To be ported from MATLAB to C++:
- Find fixed points / trim conditions
- Region of attraction analysis using sums-of-squares optimization
- Finite-time verification (e.g. forward/backward reachability analysis)
- Coming soon:
- Uncertainty quantification
- Planning
- Optimization-based inverse kinematics (fast SQP-based methods and Global IK)
- Trajectory optimization (kinematic and dynamic)
- Rich library of constraints used by all of the above
- To be ported from MATLAB to C++
- Contact-implicit trajectory optimization
- Mixed-integer-convex trajectory optimization
- Footstep/Gait planning for walking robots
- Grasp optimization
- Feedback motion planning
- Coming soon:
- Feedback Control Design
- LQR design for fixed-points
- Inverse-dynamics controller with contact constraints using Quadratic Programming (e.g. for humanoid whole-body control)
- To be ported from MATLAB to C++
- Time-varying LQR
- Sums-of-squares-based feedback design
- Value iteration algorithms (for low dimensional systems)
- State Estimation
- Recursive filter design (Kalman Filters, Luenberger observers)
- Coming soon:
- "Smoothing" estimators for nonlinear systems
- System Identification
- Least-squares "equation error" minimization for rigid body systems (with automatic extraction of identifiable lumped parameters)
- Nonlinear "simulation error" minimization
- Many examples / benchmarks / model systems
- Acrobot, Cart-Pole, Bouncing balls, ...
- Quadrotors
- Automotive/Traffic
- Manipulation
- To be ported from MATLAB to C++
- Fixed-Wing UAVs
- Walking Robots
- Humanoids (most notably including the bulk of our codebase for Atlas from MIT's entry in the DARPA Robotics Challenge)
- Other
Most of these models/tools are described in the companion textbook from an MIT course/MOOC. We've also recently started populating the :doc:`gallery` (contributions welcome!).
We hope you find this tool useful. Please see :ref:`getting_help` if you wish to share your comments, questions, success stories, or frustrations. And please contribute your best bug fixes, features, and examples!
If you would like to cite Drake in your academic publications, we suggest the following BibTeX citation:
@misc{drake,
author = "Russ Tedrake and the Drake Development Team",
title = "Drake: A planning, control, and analysis toolbox for nonlinear dynamical systems",
year = 2016,
url = "http://drake.mit.edu"
}
The Drake developers would like to acknowledge significant support from the Toyota Research Institute, DARPA, the National Science Foundation, the Office of Naval Research, Amazon.com, and The MathWorks.
.. toctree:: :maxdepth: 1 installation getting_help Doxygen (C++) <doxygen_cxx/index.html#://> GitHub <https://github.com/RobotLocomotion/drake> developers credits
.. toctree::
:maxdepth: 1
python_bindings
julia_bindings
matlab_bindings