ROS 2 for Beginners Level 2 - TF | URDF | RViz | Gazebo

Explore the fundamentals of TF transforms in ROS, building intuition for coordinating real or simulated robots through a project-based, hands-on introduction.

Visualize a robot in rviz 2 by loading a urdf model from the urdf tutorial package, and inspect tf frames, joints, and 3d axes.

Understand how transforms connect robot frames into a TF tree, with the base link as root and limbs as children; TF topics publish translations and rotations.

Identify how tf keeps a structured, timestamped tree of robot frames, linking translations and rotations over time to run a ROS robot, and explain how URDF fits into this workflow.

Explore the unified robot description format (URDF) to define robot links and joints in XML, visualize in rviz, and generate transforms, then start a simple mobile base project.

Create your first urdf file named my_robot.urdf, define a base link with a box visual, specify the origin, and visualize it in rviz using the urdf tutorial package.

Color robot links by creating a material tag with an rgba color and applying it in the link's visual tag for green or blue variants.

Combine two links with a fixed joint to generate the first tf, set parent and child links, adjust joint origin, and align the visual geometry for a proper urdf model.

Build a URDF with multiple links, adding a box atop a cylinder, define fixed joints and origin, and offset the visual for correct TF frames in RViz.

Learn to use URDF joints beyond fixed, including revolute, continuous, and prismatic, defining parent and child relations, origin, axis, and limits for robotic links.

Add a right wheel by creating a right wheel link with a cylinder visual, connect it to the base link using a continuous joint, and align origin and axis.

Complete the robot's urdf by adding the left and right wheel links, a caster wheel, and the base footprint, using fixed joints and offsets, then test iteratively.

Finish building a URDF robot by adding the base link, left wheel, caster wheel, and base footprint, configure joints and visuals, then test in RViz and Gazebo.

Learn to create a ROS 2 package with URDF, the robot state publisher, and launch files to publish tf from joints and links defined in a PDF.

Explore how the robot state publisher uses a URDF and joint state data to publish TF frames, visualize the TF tree in RViz, and support navigation stacks and Gazebo simulation.

Learn to run the robot state publisher with urdf in ros2, passing robot_description. Use zakro to process the urdf, and visualize tf and joint states with arc graph and jarvis.

Create and configure a ros2 package to store the urdf and launch files, install the urdf into the workspace share folder, and prepare for launching the robot.

Write an xml ros 2 launch file to start the robot state publisher with the urdf, along with the joint state publisher and rviz, and compare xml and python approaches.

Create a python launch file for ros2 that mirrors the xml approach, resolving the urdf path and launching robot state publisher, joint state publisher, and rviz.

Add a saved arviz configuration to the ros 2 launch file to initialize rviz with the robot state publisher, joint state publisher, and tf.

Implement and install an Avis configuration in your ROS 2 package, update launch files, and visualize the robot's TF with URDF in RViz using robot state and joint state publishers.

Learn to enhance URDF with Zaccaro properties and macros, enabling dynamic, modular designs, and include a pdf file inside another URDF to prepare for Gazebo.

Adapt the urdf for zakuro by renaming it to a .urdf.zakuro extension and adding xmlns:zakuro with the https://udemy-p.learnex.fyi/_ud_origin/www.ros.org/wiki/zakuro url in the robot tag, then build with symlink install.

Discover how Zacharo constants and variables streamline urdf, use pi, and create base length variables to dynamically compute wheel positions.

Practice creating xacro properties for base length, base width, base height, wheel radius, and wheel length to build a dynamic urdf and test changes with arviz.

Explore how to convert hardcoded URDF dimensions into macro properties, using base width, base height, wheel radius, and wheel length to create dynamic, reusable robot models in ROS URDF.

Create and reuse Zaccaro macros to generate URDF components efficiently, using parameters and prefixes to build left and right wheel links, while balancing readability and avoiding premature optimization.

Learn how to split a URDF into multiple Xacro files and include one Xacro inside another, organizing materials and properties for Gazebo and RViz workflows.

Use zakuro to build zakuro files compatible with urdf, leverage macros, properties, and constants, and run the zakuro command to generate a plain urdf for the robot state publisher.

Explains using real meshes in URDF links by importing STL files from a package's meshes folder, referencing them in the geometry, and adjusting the scale and orientation for proper visuals.

Explore gazebo as a ROS physics simulation, contrasting it with Avs visualization. Adapt URDF, spawn the robot, and add a gazebo control plugin to run a simulated world.

Install gazebo, run it with js sim, explore an empty world, add shapes, observe physics, then bridge gazebo topics with ros2 and launch from a ros2 launch file.

Learn how gazebo works with ROS 2 by bridging topics with the ros gazebo bridge package to map joint state and command topics, using urdf and robot state publisher.

Add inertial tags to every link in the URDF, and use a box inertia macro to define mass and six inertia values, enabling Gazebo to simulate gravity and dynamics.

Create and apply inertia macros for the base, wheel, and caster links. Add cylinder and sphere macros for wheel and caster, then visualize inertia with uvs.

Create two URDF inertia macros—cylinder inertia and sphere inertia—using mass, radius, length, origin, and rpy, applying axis formulas to visualize correct mass properties in rviz.

Add collision tags in URDF to define simple collision shapes for Gazebo, using a box for the base link and a sphere for wheels, with visual and collision kept separate.

Spawn the robot in Gazebo by adapting the eRDF with inertial and collision tags, using the robot state publisher, the robot description topic, and terminal commands to verify the URDF.

Create a dedicated bringup package with a single launch file to start the robot in Gazebo, launching the robot state publisher, URDF, and spawning the robot via the create node.

Create and configure a ROS 2 bring-up package, set up a launch file to spawn a robot in Gazebo, wire in robot_state_publisher with URDF, and prepare RViz integration.

Add gazebo plugins to control the robot in gazebo, publish joint states and tf in ROS2, and integrate the URDF with a diff drive; a gazebo bridge to ROS2 follows.

Set up a ros-gazebo bridge to expose gazebo topics to ros2, configure a yaml bridge file, and map clock, joint state, tf, and cmdvel topics for bidirectional communication.

Launch and test the robot in gazebo from the urdf, enable the diff drive and joint state publisher plugins, and validate rviz visuals, ros2 topics, tf frames, and cmdvel control.

Build a Gazebo world around a simulated robot by adding a ground plane, sun, and Open Robotics models, then save as an SDF and spawn or remove the robot.

Launch the robot in a custom gazebo world by placing the sdf file in the workspace and updating the launch file. Visualize in rviz and control via teleop twist.

Launch your ROS 2 robot in Gazebo with a camera sensor added to the URDF, configure a Gazebo plugin, and publish a camera stream on a ROS topic.

Add a camera to the URDF by creating a camera link and a joint from base, using a box visual and inertia, and place the joint origin for Gazebo.

Add a Gazebo sensor plugin to simulate a camera, configure the camera sensor in the URDF, and bridge Gazebo topics to ROS2 for camera info and image.

Offer an optional quick fix by adding a virtual camera link optical and a fixed joint that reorients the frame so OpenCV's z axis points forward, aligning with ROS conventions.

Build a final ROS 2 project that integrates URDF, Gazebo, and RViz with a mobile base and a two-axis arm, then learn to control joints with the provided tools.

Build a standalone arm URDF with links and joints, attach it to a mobile base, and visualize and test it in rviz and Gazebo using tf frames.

Adapt the robot's urdf for gazebo by adding collision and initial tags to each link, assign inertial properties, and spawn it to verify visuals, collisions, and inertia.

Add Gazebo plugins for the robotic arm, configure a joint position controller and joint state publisher, bridge ROS 2 topics to Gazebo, and visualize with RViz and TF.

Combine the mobile base and robotic arm into a single urdf with a fixed joint, set origins and tf, and spawn and simulate the integrated robot in gazebo.

Explore Gazebo to simulate your robot with realistic gravity, friction, and physics; compare with Arviz for debugging, adapt the URDF, add a Gazebo control plugin, and build a simulated world.

Launch Gazebo to see its real physics engine and ROS integration, and learn to insert a box or sphere with gravity and controlled time.

See how Gazebo and ROS work together via the Gazebo ROS bridge. Use URDF, joint state publishers, and TF to simulate hardware with plugins.

Add inertial tags to each link in the URDF to enable Gazebo simulation, and use simple inertia formulas to fill the 3x3 matrix with ixx, ixy, ixz, iyy, iyz, izz.

Apply inertia macros to a ros 2 urdf model, defining inertial tags for the box, wheel, and caster, and practice creating cylinder and sphere macros from wiki matrices.

Create and reuse macros to compute and apply inertial properties in urdf models, deriving cylinder and sphere inertia from mass, radius, height, and origin for wheels and caster.

Add collision tags to each link in the URDF for Gazebo, using a simplified collision shape based on the visual, to ensure proper collisions and balance accuracy with compute time.

Spawn the robot in Gazebo by publishing its urdf with the robot state publisher and spawning it via spawn_entity.py from the robot_description topic, highlighting inertia, visual, and collision tags.

Create a new bring up package and a launch file to start the robot in Gazebo, including the robot state publisher, include the Gazebo launch, spawn_entity, and arviz visualization.

Create and launch a ros 2 robot in gazebo by building a my robot bring up package, a gazebo launch, and a robot state publisher with rviz visualization.

Create a mobile base Gazebo file and use Gazebo tags to color each link in the urdf, setting the base link blue and the wheels gray.

Add a gazebo differential drive control plugin to enable command velocity input and odometry/tf publishing, enabling rviz visualization of a ros 2 robot in gazebo.

Build a simulated world around the robot in Gazebo, add objects like bookshelf, ball, and cabinet, design walls in building editor, save as my world.world, and launch Gazebo with it.

Launch and spawn a robot in a Gazebo world using a launch file and spawn node, and manage world files (SDF and URDF) with Gazebo editor and args for worlds.

Add a camera sensor to a ros2 Gazebo simulation by editing the urdf, configuring a plugin, and streaming the camera to a ros topic, with an introductory, step-by-step process.

Add a camera to a ros 2 urdf by creating a camera link and a fixed joint to the base, with visual, collision, inertia, and rviz and gazebo visualization.

Add a Gazebo plugin for the camera to enable a real camera in Gazebo, linking to the camera link and publishing image and camera info on ROS topics.

Apply a fix for Gazebo camera with ROS and OpenCV by adding a camera optical joint that shares the camera link origin and rotates -90 degrees on x and z.

Start the final project overview by designing and simulating a mobile base with a two-axis robotic arm in URDF, using TF, RViz, and Gazebo.

Create a URDF for a robotic arm on a mobile base, defining arm base link, forearm link, and hand link with revolute joints; visualize tf frames in rviz and Gazebo.

Adapt the URDF for Gazebo by adding collision and inertia tags. Spawn the robot in Gazebo, test visuals and physics, and adjust friction and damping before plugins.

Add gazebo plugins to control the robotic arm in ros2 and Gazebo by implementing a joint state publisher and a joint trajectory controller, enabling urdf-based tf publishing and rviz visualization.

Combine the mobile base and robotic arm into one URDF by adding a fixed joint between base link and arm base link, and verify TF in RViz and Gazebo.

Master tf transforms and urdf, build a robot in gazebo with plugins, visualize with rviz, spawn in a world, and add sensors and a robotic arm.

Rewatch sections to reinforce concepts and redo complete robot project from scratch using the downloadable code, then pursue navigation with navigation stack or MoveIt with URDF and ros2 control.