intro.tex

\chapter{Introduction and Goals}



\section{What is \drake?}

Drake is a toolbox written by the Robot Locomotion Group at the MIT Computer Science and Artificial Intelligence Lab (CSAIL). It is a collection of tools for analyzing the dynamics of our robots and building control systems for them in MATLAB. It deals with general nonlinear systems (including hybrid systems), but also contains specialized tools for multi-link rigid-body dynamics with contact. You might want to use Drake in your own research in order to, for example:
\begin{itemize}
\item Analyze the stability of your systems - e.g., by automatically computing Lyapunov functions for global or regional (region of attraction analysis) using Sums-of-Squares optimization,
\item Design nonlinear feedback controllers for complicated (nonlinear, underactued) dynamical systems,
\item Perform trajectory and feedback-motion planning for complicated (nonlinear, underactuated) dynamical systems, or
\item Compute invariant ``funnels" along trajectories (derived from your own motion planning software) for robust motion planning. 
\item Interface with a fast inverse kinematics library for rigid-body systems with a rich specification of kinematic constraints.
\end{itemize}

Drake also contains supporting methods for visualization, identification, estimation, and even hardware interfaces; making it our complete robotics software package. It has been used by the Robot Locomotion Group and a number of collaborators, but now we are attempting to open up the code to the broader community.

Drake is implemented using a hierarchy of MATLAB classes which are designed to expose and exploit available structure in input-output dynamical systems. While some algorithms are available for general nonlinear systems, specialized algorithms are available for polynomial dynamical systems, linear dynamical systems, etc.; many of those algorithms operate symbolically on the governing equations. The toolbox does a lot of work behind the 
scenes to make sure that, for instance, feedback or cascade combinations of polynomial systems remain polynomial. The toolbox also provides a parser that reads Universal Robot Description Format (URDF) files which makes it easy to define and start working with rigid-body dynamical systems. Drake uses the Simulink solvers for simulation of dynamical systems, and connects with a number of external tools (some relevant dependencies are listed below) to facilitate design and analysis. 

\subsection{Relative to \simulink and SimMechanics}

Roughly speaking, \matlab's \simulink provides a very nice interface for describing dynamical systems (as S-Functions), a graphical interface for combining these systems in very nontrivial ways, and a number of powerful solvers for simulating the resulting systems.  For simulation analysis, it provides everything we need.   However the S-Function abstraction which makes \simulink powerful also hides some of the detailed structure available in the equations governing a dynamical system; for the purposes of control design and analysis I would like to be able to declare that a particular system is governed by analytic equations, or polynomial equations, or even linear equations, and for many of the tools it is important to be able to manipulate these equations symbolically.   

You can think of \drake as a layer built on top of the \simulink engine which allows you to defined structured dynamical systems.  Every dynamical system in \drake can be simulated using the \simulink engine, but \drake also provides a number of tools for analysis and controller design which take advantage of the system structure.  While it is possible to use the \simulink GUI with \drake, the standard workflow makes use of command-line methods which provide a restricted set of tools for combining systems in ways that, whenever possible, preserve the structure in the equations.  

Like SimMechanics, \drake provides a number of tools for working specifically with multi-link rigid body systems.  In SimMechanics, you can describe the system directly in the GUI whereas in \drake you describe the system in an XML file.  SimMechanics has a number of nice features, such as integration with SolidWorks, and almost certainly provides more richness and faster code for simulating complex rigid body systems.  \drake on the other hand will provide more sophisticated tools for analysis and design, but likely will never support as many gears, friction models, etc. as SimMechanics.  

%\subsection{Not just \matlab}



%\subsection{As a component in R.O.S.}

\subsection{For controlling real hardware}

Drake also has many interfaces which allow it to connect to other components of a robotic / control system.  Inputs and outputs of the dynamical systems, or static matlab functions (e.g. for trajectory planning), can be connected directly to network interfaces.  We primarily use  Lightweight Communications and Marshalling (LCM) \cite{Huang10} to make these connections; support for other protocols (such as ROS\cite{ROS}) can be added easily or accomplished via an independent network translator.  This approach has been used extensively on real hardware experiments at MIT, and formed the foundation of our solution for controlling a complex humanoid for MIT's entry into the DARPA Robotics Challenge (with Drake nodes running in desktop MATLAB instances inside the real-time feedback loops)\cite{MITDRC}.  In addition to the primary MATLAB front end, a number of methods for kinematics and dynamics of rigid-body systems are also available directly as a C++ library.  


\section{Getting Started}

To download and install Drake, please follow the ``QuickStart'' instructions available at

\medskip
\centerline{\url{http://drake.mit.edu/documentation}}
\medskip

\noindent This page also contains links to detailed documentation of the methods and classes in Drake (autogenerated using Doxygen), and additional information including a FAQ and an online discussion forum.  Please let us know about any issues you have, and of course about any success stories!