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

Configure the ros development environment by installing Visual Studio Code with ros extensions and setting up ros noetic; install essential packages like ros controllers and gazebo ros control.

Discover how robotics combines physical activity and decision making, and how the ROS framework enables modular, interoperable software so robots can navigate, grasp, and operate across domains.

Learn how ROS manages hardware drivers and communication, enabling you to reuse your computer vision package across robots with different cameras and motors.

Create a Python ROS node that publishes string messages on a chatter topic at 10 hertz, teaching publish-subscribe fundamentals, ROS master setup, and basic topic inspection.

Develop a simple Python subscriber node in ROS that listens to a topic, receives string messages, and prints each new message to the terminal.

Examine wheeled locomotion architectures, differential drive, Ackermann drive, and omnidirectional mecanum wheels, focusing on controlling motor speeds to reach any pose in the plane, defined by x, y, and theta.

Create a robot model to visualize components and simulate interactions in a physics engine, including sensors like lasers, sonar, and cameras, using ROS tools for PC-based debugging before hardware testing.

Visualize robot data with RViz, a ROS visualization tool that subscribes to topics and renders occupancy grid maps, laser scans, and camera images using plugins.

Start the ros core to run the ros parameter server, query and set parameters with rosparam list, rosparam get, and rosparam set, and note parameters reset when the core restarts.

Discover how ROS launch files simplify starting all required nodes and parameters with one command, using param, node, include tags, and arguments.

Create a single launch file to visualize the RDF robot model in ArcGIS by loading the robot_description parameter on the server and launching rviz with a saved configuration.

Learn to simulate a robot in Gazebo by enriching the URDF with collision and inertia data, using simplified wheel geometry, and adding Gazebo sacro tags for accurate physics.

Create a Gazebo launch file with model and world arguments, convert RDF to URDF, load on the parameter server, and spawn the robot in an empty world.

Explore the ROS control library’s three actuator interfaces: position, velocity, and effort. Learn how iterative error reduction drives commands to reach target positions while countering disturbances.

Express the pose of a mobile robot in a 2d space using world and mobile frames, defining x, y, and theta, then treat translation and rotation as roto-translation.

Master ros turtlesim to apply two dimensional pose kinematics using keyboard teleop and velocity commands, visualize topics with ros graph, and spawn multiple turtles.

Explore how to determine a robot's orientation using the rotation matrix between world and robot reference frames, with theta and coordinates from rotated and world frames.

Describe a mobile robot's velocity from pose and time, deriving x dot, y dot, theta dot, and solving the differential kinematics for a two-wheeled robot using wheel radii and separation.

Divide differential kinematic problem into two parts and combine them to relate wheel velocities to robot's velocity in the world frame, using theta-dependent rotation matrix and a wheel geometry Jacobian.

Translate joystick velocity commands into differential wheel speeds using kinematics, and publish wheel commands on ROS topics to teleoperate the robot.

Operate a robot in gazebo with a joystick, publishing velocity commands to the bumper bot controller. Map the left axis to linear x and the right axis to angular z.

Explore the tf and tf2 libraries to compute and visualize transformations between robot, starting pose, and map frames, enabling accurate odometry and pose tracking in ROS.

Explore how ROS timer tracks time progression to synchronize image acquisition, post-processing, and path planning, enabling estimation of dynamic obstacle positions and regular, repeated execution of user-defined functions.

Create a Python ROS node that uses a timer to execute a callback every second, printing a log message and keeping the node running with a spin loop, via catkin.

Develop a Python ROS service server that takes two integers as a request and returns their sum using a defined add two int service interface.

Learn to build a Python ROS service server that returns the transform between any two frames using a tf2 buffer and listener, enabling dynamic odometry and frame lookup.

Add a ROS service server to the C++ TF examples that returns the transform between any two frames, using tf2 lookup and a transform stamped response with a success flag.

Explore how rotation matrices express two-dimensional and three-dimensional orientation, and why quaternions, composed of four components, offer advantages over rotation matrices across robotics, computer science, and related fields.

Learn how to convert Euler angles to a quaternion and rotate a bumper bot base frame while translating, using quaternion multiply and inverse with a 100-step cycle.

Convert roll pitch yaw to quaternions and rotate a bumper boat base frame while translating along the x axis in ros. Use tf2 quaternions, normalize, and invert after 100 rotations.

Learn wheel odometry to estimate a robot's position and velocity from wheel rotations, radius calibration, and encoder data, and how sensor fusion and global localization improve accuracy.

Apply differential inverse kinematics to derive the robot’s linear and angular velocity from wheel rotation rates using encoders and wheel radii, and compute forward odometry on the x-y plane.

Compute the robot's orientation from wheel rotations using the differential kinematic equation. Integrate angular velocity over time, separating contributions from the right and left wheels to update odometry.

Master wheel odometry by implementing a Python controller that updates the robot's x, y, and theta from wheel displacements, with ROS, Gazebo, and a simple bumper boat controller.

Implement wheel odometry in the C++ bumper robot controller to compute x, y, and theta from wheel rotations, then visualize in Gazebo and verify with ROS topics.

Publish odometry messages from the C++ simple controller to the bumper bot controller odom topic, initializing header fields, quaternion, and updating pose and twist from wheel data.

Explore how probability theory and statistics address uncertainty in robotics. Learn to use probabilistic localization, odometry, and sensor fusion to update estimates as sensor data arrive.

Learn how random variables represent outcomes of random experiments, assign probabilities that sum to one, and apply independence and the product rule to compute probabilities from coin toss and dice.

Explore how probability theory addresses sensor noise in real-world localization by turning simulated encoder readings into noisy signals with a normal random process, improving odometry and localization robustness.

Compare noise-free and noisy odometry in a Gazebo robot simulation using ROS visualization; observe encoder noise and wheel radius and separation errors affecting base footprint ground truth versus noisy odometry.