Self Driving and ROS 2 - Learn by Doing! Odometry & Control

Install ros2 jazzy on Ubuntu 24.04 and configure the desktop version with rviz, demos, and tutorials by copying commands, updating the system, and sourcing the bashrc.

Set up a ros2 development environment on Ubuntu 24.04 using Visual Studio Code with ROS extensions, Terminator terminal, and essential ROS 2 packages for Gazebo and joystick control.

Describe why a new robot operating system emerged to overcome ROS 1 limitations, including unreliable wireless networks, real-time guarantees, and security concerns, enabling fleet collaboration and hardware integration.

Create and activate a ros2 workspace by building an overlay, adding python and c++ packages, and sourcing setup.bash to recognize new packages in each terminal.

Implement a python ros2 subscriber node using the publisher-subscriber protocol to read string messages from a topic and log each message, alongside a c++ publisher to show language-agnostic communication.

Implement a ros2 c++ simple subscriber node that subscribes to a string topic, reads and prints messages, and demonstrates ros2 publisher-subscriber communication within the bumper bot cpp package.

Create a ros2 bumper bot urdf sakro model, build the bumper bot description package, define base footprint, base link, wheels and caster joints, attach meshes, and visualize the model.

Explore how nav2 and ros2 enable autonomous mobile robots with path planning and obstacle avoidance, and learn how node parameters configure software behavior for different robot setups.

Create a simple ros2 python node configurable by parameters, with a runtime change callback that handles an integer and a string parameter, logs updates, and returns a set_parameters_result.

Enhance the bumper bot urdf for Gazebo by adding collision and inertia tags, replacing complex meshes with simple spherical geometry, and exporting Gazebo-ready friction and joint parameters.

Use yaml configuration files to define all ros parameters for a node in a comprehensible, simple format, set them in one command, and expose them to the node at runtime.

Launch gazebo, launch ROS 2 control, and use the simple velocity controller to drive robot wheels. Learn to list controllers and hardware interfaces, and publish velocity commands.

Explore ros2 turtle sim to apply 2D pose kinematics, publish velocity commands via turtle teleop key, visualize node and topic flows with Arc Graph, and spawn multiple turtles.

Use the rotation matrix to relate the robot frame to the world frame and compute world coordinates from p_x_first and p_y_first using theta.

Develop a two-node c++ ros 2 application that computes and prints the rotation matrix between two turtles from their world poses, including theta in radians and degrees.

Derive the differential kinematics relating wheel speeds to the robot's linear and angular velocity, enabling velocity commands in the robot frame and joystick-driven motion in the world frame.

Describe a mobile robot's velocity from its pose in a 2d frame using time derivatives, and derive a two-wheel differential kinematics model for joystick control.

Develop a Python ros2 node that receives a velocity message, converts it to per-wheel commands with a differential drive matrix, and publishes wheel speeds.

Develop a c++ simple speed controller node that receives a robot-frame velocity and publishes wheel commands using a differential drive speed conversion matrix.

Launch the simple controller in ros2, choosing python or c++ and configuring wheel radius and wheel separation. Watch the node translate velocity commands into wheel motions.

Teleoperate a ros2 robot with a joystick by converting joystick input into twist stamped commands and publishing them to the bumper bot controller command velocity topic via joy teleop.

Learn by doing: configure the ROS 2 diff drive controller to convert velocity commands into wheel speeds, compare it with a simple controller, and teleoperate a differential-drive robot in Gazebo.

Explore the TF2 library in ROS 2 to manage frame transformations and odometry. Use URDF and the robot state publisher to visualize the robot's frames.

Explore how to relate robot, camera, and map frames by chaining transformation matrices, compute relative positions using intermediate frames, and master the crucial order of matrix multiplication.

Create a simple ros 2 c++ service server that sums two integers, connect a client in another ros 2 node, and interact via the ros 2 command line interface.

Create a ros 2 python get_transform service that returns the transform between two frames using tf2, a transform buffer and listener, and a stamped response with a success flag.

Express the orientation of a 3d object with Euler angles via rotations about z, y, and x axes, producing roll, pitch, and yaw, then compose them with rotation matrices.

Explore TF2 tools in ROS 2 to visualize and inspect reference frames, publish static and dynamic transforms, and read transformation matrices using view frames and tf2 echo.

Track the robot’s motion to estimate its current pose using odometry from wheel rotations, speeds, and timing, and explore laser and visual odometry methods.

Compute the robot's position and orientation from wheel odometry in a Python controller by updating x, y, and theta from wheel rotations using the wheel radius and joint states.

Publish the dynamic odometry transform from the odom frame to the base footprint in a C++ ros 2 node using the Transform Broadcaster and a transform stamped message, enabling rviz.

Investigate how dependent events, such as robot localization and rock detection, use conditional probability to compute joint probability as P(X) times P(Y|X).

Apply probability theory to model sensor noise and enhance localization in real environments. The chapter adds a normal random process to simulated encoder outputs to reproduce realistic noisy odometry.

Develop a Python node to simulate gaussian noise in wheel encoder readings, affecting odometry and robot localization in Gazebo, then publish noisy odometry separately for comparison with the simple controller.

Develop a ros 2 c++ noisy controller that adds gaussian noise to wheel encoder readings in gazebo, publishing noisy odometry and localization for comparison with the simple controller.