Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

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

Name: Self Driving and ROS - Learn by Doing! Odometry & Control
Rating: 4.7 (242 reviews)

Create a Self-Driving robot and learn about Robot Localization and Sensor Fusion using Kalman Filters

Highest Rated

Created byAntonio Brandi

Last updated 1/2026

English

English [Auto],Korean [Auto],

What you'll learn

Create a Real Self-Driving Robot
Mastering ROS, the Robot Operating System
Implement Sensor Fusion algorithms
Simulate a Self-Driving robot in Gazebo
Develop a Controller
Odometry and Localization
Kalman Filters and Extended Kalman Filter
Probability Theory
Differential Kinematics
Create a Digital Twin of a Self-Driving Robot
Master the TF library

Course content

13 sections • 139 lectures • 20h 20m total length

Course Motivation2:53
The Self-Driving Program3:29
Course Presentation6:16
Meet your Teacher1:45
[BONUS]: Boost your Robotics Software Developer Career2:10
Get the Most out of the Course3:49
Set up your development environment, ask questions in the q&a section, and learn robotics and self-driving concepts in c++ and python using the framework with a real robot or simulator.
Course Material1:02

Why a Robot Operating System?4:50
What is ROS3:24
Learn how ROS manages hardware drivers and communication, enabling you to reuse your computer vision package across robots with different cameras and motors.
Hardware Abstraction3:11
Low-Level Device Control1:40
Messaging between Process7:56
Package Management1:46
Architecture of a ROS Application2:48
Introduction to ROS
<LAB>Create and Activate a Workspace</LAB>11:07
<PY>Simple Publisher</PY>17:50
<C++>Simple Publisher</C++>17:38
<PY>Simple Subscriber</PY>11:56
<C++>Simple Subscriber</C++>12:21
Workspaces, Publishers, Subscribers

Robot Locomotions6:39
Mobile Robots4:53
Friction Effects9:54
Robot Description4:03
URDF5:28
<LAB>Create the URDF Model</LAB>23:01
RViz5:55
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.
Parameter Server4:56
<LAB>Parameter Server</LAB>6:16
<LAB>Visualize the Robot</LAB>8:02
Launch Files4:26
<LAB>Visualize the Robot with Launch Files</LAB>8:48
Add a Can on top of your Robot
Gazebo5:03
show some world that is possible to create with gazebo AWS robomaker
<LAB>Simulate the Robot</LAB>17:13
<LAB>Launch the Simulation</LAB>13:49

Robot Kinematics3:52
Pose of a Mobile Robot3:53
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.
Translation Vector4:46
<LAB>Introduction to Turtlesim</LAB>13:24
Master ros turtlesim to apply two dimensional pose kinematics using keyboard teleop and velocity commands, visualize topics with ros graph, and spawn multiple turtles.
<PY>Translation Vector</PY>21:46
<C++>Translation Vector</C++>27:09
Rotation Matrix8:14
<PY>Rotation Matrix</PY>10:10
<C++>Rotation Matrix</C++>10:32
Transformation Matrix3:39

Differential Kinematics1:36
Velocity of a Mobile Robot3:17
Linear Velocity6:04
Angular Velocity5:28
Velocity in World Frame5:05
Differential Forward Kinematics4:08
Simple Speed Controller2:03
<PY>Simple Speed Controller</PY>31:48
<C++>Simple Speed Controller</C++>35:16
<LAB>Teleoperating with Joystick</LAB>11:25
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.
<LAB>Using the diff_drive_controller</LAB>22:14

The TF Library5:23
Operations with Transformations7:09
Static and Dynamic Transformations3:25
<PY>Simple TF Static Broadcaster</PY>16:54
<C++>Simple TF Static Broadcaster</C++>20:15
ROS Timer5:12
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.
<PY>ROS Timer</PY>6:00
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.
<C++>ROS Timer</C++>6:16
<PY>Simple TF Broadcaster</PY>12:38
<C++>Simple TF Broadcaster</C++>14:14
ROS Services5:48
<PY>Service Server</PY>14:49
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.
<C++>Service Server</C++>17:11
<PY>Service Client</PY>12:18
<C++>Service Client</C++>13:56
<PY>Simple TF Listener</PY>19:22
<C++>Simple TF Listener</C++>19:57
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.
Angle Rapresentations2:02
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.
Euler Angles4:46
Quaternion4:29
<PY>Euler to Quaternion</PY>11:00
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.
<C++>Euler to Quaternion</C++>10:50
<LAB>TF Tools</LAB>8:13

Where is the Robot?3:08
The Local Localization Challenge6:37
Wheel Odometry7:49
Differential Inverse Kinematics5:33
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.
<PY>Differential Inverse Kinematic</PY>16:08
<C++>Differential Inverse Kinematic</C++>18:01
Wheel Odometry - Position3:17
Wheel Odometry - Orientation3:38
<PY>Wheel Odometry</PY>10:04
<C++>Wheel Odometry</C++>9:14
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.
<PY>Publish Odometry Message</PY>14:22
<C++>Publish Odometry Message</C++>14:51
Draw the Robot's Trajectory
<PY>Broadcast Odometry Transform</PY>12:09
<C++>Broadcast Odometry Transform</C++>12:44

Requirements

Basic knowledge of Python or C++
Basic knowledge of Linux
No prior knowledge of ROS required
No prior knowledge of Robotics theory required
No hardware required. All the course can be followed also using only the PC

Description

Would you like to build a real Self-Driving Robot using ROS, the Robot Operating System?

Would you like to get started with Autonomous Navigation of Robot and dive into the theoretical and practical aspects of Odometry and Localization from industry experts?

The philosophy of this course is the Learn by Doing and quoting the American writer and teacher Dale Carnegie

Learning is an Active Process. We learn by doing, only knowledge that is used sticks in your mind.

In order for you to master the concepts covered in this course and use them in your projects and also in your future job, I will guide you through the learning of all the functionalities of ROS both from the theoretical and practical point of view.

Each section is composed of three parts:

Theoretical explanation of the concept and functionality
Usage of the concept in a simple Practical example
Application of the functionality in a real Robot

There is more!

All the programming lessons are developed both using Python and C++ . This means that you can choose the language you are most familiar with or become an expert Robotics Software Developer in both programming languages!

By taking this course, you will gain a deeper understanding of self-driving robots and ROS, which will open up opportunities for you in the exciting field of robotics.

Who this course is for:

Self-Driving enthusiast
Makers and Hobbists keen on robotics
Software developers taht wants to learn ROS and Robotics
Students or Engineers that wants to learn how to buid a robot from scratch
Developers that already knows ROS and that want to use it in a real world application
Robotics Engineers that wants to develop skills in Autonomous Navigation
Beginner Python developers curious about Self-Driving
Beginner C++ developers curious about Self-Driving

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

What you'll learn

Explore related topics

Course content

Introduction7 lectures • 21min

Setup4 lectures • 16min

ROS Introduction12 lectures • 1hr 36min

Locomotion15 lectures • 2hr 8min

Control6 lectures • 50min

Kinematics10 lectures • 1hr 47min

Differential Kinematics11 lectures • 2hr 8min

TF Library23 lectures • 4hr 2min

Odometry14 lectures • 2hr 18min

Probability for Robotics11 lectures • 1hr 32min

Requirements

Description

Who this course is for: