Simulation

The needs of your robotic application dictate the complexity of your model and the requirements for your simulation engine. Choosing the correct level of simulated detail is an important design choice: the more detail, the more accuracy, but also the more computation time and complexity.

Here are some types of simulations used in robotics:

• Discrete Position
  • Robots are agents that can move from grid-space to grid-space
  • The mechanics of the movement are ignored
• Kinematic
  • Control positions and velocities of the joints
• Dynamic
  • Robots and objects have inertia and you control forces and torques
  • Newton's Laws or Euler Lagrange can be used
  • Complexity of the dynamic effects modeled can vary widely
• Finite Element
  • Parts of the robot can deform according to stress-strain relations
• Fluid Dynamics
  • For underwater or aerial robots

1. What integration scheme do they use?
   • Most simulations ultimately hinge on integrating differential equations
   • Many simulators provide a choice or parameters that can be tuned
   • Accuracy vs speed trade-offs
   • Specific types of differential equations may be better suited to different integration schemes
2. What phenomenon can be modeled?
   • Collisions?
   • Friction?
   • Lighting conditions?
   • Aerodynamics?
3. Visualization tools?
   • Can you view the simulated objects?
   • Can you generate plots based on the simulation?
   • How do you provide input?
   • How do you read the output?
4. What robots are supported?
   • Specific to certain types of robots?
   • General purpose, can make nearly anything?
   • Are their pre-built models available?

• Sometimes, you have a simple model for your robot
• Using a simple model, you can usually write your own simulator
• In some cases, writing your own can be simpler than invoking a complicated general purpose simulator like gazebo.
• Writing a simulation for a robot is a good way to verify you understand the system

• Choice of physics engines:
  • By default it uses the Dart physics engine
• Graphics: Gazebo provides a graphical interface for viewing and creating simulated worlds.
  • Think of the Gazebo display as being a stand-in for the real world and the RViz display is a visualization based off of what the robot senses.
  • Gazebo has powerful rendering features that are aimed at creating photo-realistic models so that computer vision in the simulator can be useful
• Plugin Architecture: Everything in Gazebo is written as a C++ plugin.
  • This makes Gazebo extendable, and provides you with the ability to not only add new objects in Gazebo but also new physical phenomena
  • Gazebo comes with many plugins, representing, for example, different types of sensors
  • ROS support for Gazebo is provided by a plugin
• Network: Like ROS, gazebo consists of multiple processes that communicate with each other using. There are counterparts to ROS mesages and services,but these are entirely different systems

• ROS uses URDF files to represent robots
• Gazebo uses SDF files to represent robots and other objects
• Gazebo provides extensions to URDF files that enable it to convert URDF to SDF automatically
• SDF Tutorials provides help with writing SDF files, including building worlds
• Fuel is a library where people share SDF models and worlds. The website contains functionality to preview, download, and link-to assets for simulation
• Typically, the Gazebo-specific parts of the URDF are kept in a separate file called <robotname>.gazebo.xacro
• Using the xacro:include tag (and with the $(find package) substitution), the main URDF file loads the gazebo file

• ROS can be used to load both URDF and SDF models into the simulator
• URDF files are automatically converted to SDF prior to being loaded
• ros2 run ros_gz_sim create is a ROS node that can load urdf/sdf data into gazebo
  • The data can come from a file, a parameter, a topic, or a string
  • Typically, you will load the data from the /robot_description topic
  • ros2 run ros_gz_sim create --help for all the options
• Additional sdf tags can be added to a URDF by using the <gazebo> tag
  • <gazebo>sdftags go here</gazebo> associates the SDF tags with the full model
    • Useful for adding model-wide plugins like the diff-drive robot
  • <gazebo reference="">sdftags go here</gazebo> associates the SDF tag with the specified link or joint
• For a URDF model to be loaded in gazebo successfully, it requires, at a minimum:
  • All links must have visual, collision, and inertia

1. Gazebo uses plugins to enhance/modify functionality
2. Some plugins can be associated with specific models and used to control them
3. Useful Plugins can be found in the API documentation, especially the Systems.
   • The documentation includes what tags can be used in the SDF to include the plugin
   • Use <plugin name="<C++ Namespace Path of the plugin>" filename="lib_object_with_the_code">
     • For example, to use the ignition::gazebo::systems::DiffDrive plugin:
       • Set name to ignition::gazebo::systems::DiffDrive
       • set filename to libignition-gazebo-diff-drive-system.so
       • Options for this plugin go inside the <plugin></plugin> tag (see API Documentation)
4. The JointStatePublisher plugin publishes joint states

1. The ROS GZ Bridge is used to connect ROS topics and services to Gazebo topics and services
   • ros2 run ros2 run ros_gz_bridge parameter_bridge topic@ros_type@gz_type
     • Provide the topic name, the ROS type, and the corresponding gazebo type
     • Use --help for options/syntax
     • The above syntax starts a bi-directional bridge (e.g. topics from gazebo are published to ros and topics from ros are published to gazebo)
     • Sometimes uni-directional bridges are desired. For example, we may want to receive tf frames from Gazebo without having all of ROS's Tf frames existing in the simulator.
     • Be careful about topic types: for example the ROS type of the /tf topic is TFMessage not TransformStamped
2. You should generally run one ros_gz_bridge and specify all topics/services that must be bridged
3. Once the bridge is running you can publish/subscribe to the topics like any other ROS topic

1. Typically, xacro files go under the urdf directory in the package
2. SDF files for worlds go in a worlds/ directory
3. SDF files for models go in a models/ directory

4. The IGN_GAZEBO_RESOURCE_PATH environment variable tells gazebo where to find SDF files

   • A ROS package that provides gazebo resources needs to set this variable appropriately.

   • Create a .dsv file in the env-hooks directory with the following content (be sure to update the <pkg_name> to be the name of the package):

     prepend-non-duplicate;IGN_GAZEBO_RESOURCE_PATH;share/<pkg_name>/models
     prepend-non-duplicate;IGN_GAZEBO_RESOURCE_PATH;share/<pkg_name>/worlds
     

   • Follow the colcon.pkg instructions to install the hook and have it update the environment whenever you source install/setup.bash
     • When this is done properly, after source install/setup.bash, echo $IGN_GAZEBO_RESOURCE_PATH should contain the paths to the gazebo resources

1. Gazebo Tutorials
2. SDF Format
3. ROS 2 Gazebo Interface (See the README.md files in each package in the repository
4. Fuel Model Library