Set up the ESP32 wifi controlled robot development environment using Visual Studio Code and platform IO, creating an Arduino project for the do it ESP32 dev kit and uploading code.

Interface motors on the ESP32 by defining motor pins and a PWM channel, configure LEDC at 5000 Hz with 8-bit resolution, and drive forward, stop, and turns using 0–255 values.

Utilize platform IO to install the Adafruit SSD1306 library and initialize an OLED display via I2C address 0x3C, then draw directional arrows and test with delays and clears.

Explore micro ROS basics by building a publisher and subscriber on an ESP32 with Platform IO and ROS 2 humble, configure serial and wifi options, and upload via VS Code.

Discover how the micro ros agent enables esp32 to talk to ros2 via serial, with a step-by-step setup, building the agent, and a counter publisher.

Transition from serial communication to wifi setup with ros and micro ros, highlighting wifi bugs and the need to restart the agent and adjust IP settings for reliable operation.

Learn how to build a wifi-enabled ROS 2 subscriber on ESP32 using micro-ROS, replacing the publisher with a subscription, handling int32 messages, and running the micro-ROS agent.

Learn to convert a wired serial subscriber to wifi using micro ROS on ESP32, configure wifi transport, UDP communication, and ROS2 topic publishing with a subscriber.

Explore the command velocity topic using the geometry message twist to drive a robot, subscribing to the command velocity topic in ROS2 and extracting linear x and angular z velocities.

Integrate the motor control library with the ros2 node on the esp32, mapping forward, reverse, left, right, and stop to pwm speeds scaled from linear velocity for wifi-driven robot control.

Install the ESP32 package for the Arduino IDE and add required libraries, then configure the IDE and VS Code with a GitHub workflow, and test by uploading a blink example.

Set up a GitHub repository for a ROS2 ESP32 project, create a local workspace and package, and manage commits, clones, and pushes for version control.

Install and configure the rosserial Arduino library to enable ROS communication with ESP32, upload a blink example, and troubleshoot common serial issues.

Learn led toggling on esp32 using rosserial with ros2, a toggle topic subscriber, and a message callback driving a led and lcd.

Publish ultrasonic distance from an ESP32 in ROS2 via a publisher node, using trigger and echo pins, duration-based distance with the speed of sound, to a topic.

Implement ultrasonic interfacing on the microcontroller using a trigger pin and echo input, calculate distance in centimeters, monitor via the serial monitor, and prepare for ROS integration.

Drive a 2d turtle sim robot using ROS2 by publishing command velocity on turtle1/command_vel and subscribing to ultrasonic distance values to control forward movement and rotation.

Push your ESP32 robotics project changes to a GitHub repository, review untracked files and publisher-subscriber communication, and organize a ROS-based mobile robot project page with hardware and software requirements.

Build a basic mobile robot car with a microcontroller, a resolution disk, speed sensors, a motor driver, and a 12-volt battery; use five-volt rails and a common ground for ros2.

Esp32 pwm signal generation to drive motors with smooth motion using 16 independent pwm channels, duty cycle, frequency, and resolution, connecting channels to motor drivers for multi-motor control.

Develop a generic ESP32 car drive program by defining motor pins, implementing forward, backward, left, and right movements, and testing via serial output before compiling and uploading.

Drive a two-motor car with PWM on an ESP32 using ROS2, defining motor pins and channels, and set 5000 Hz with 8-bit resolution for forward, backward, left, and right motion.

This lecture shows how to convert command velocities into PWM signals for a differential-drive robot, mapping linear and angular velocities to left and right wheel speeds and 0–255 PWM values.

Drive the robot using a serial communication workflow with ESP32, upload updated code, test topic subscriptions, and refine forward, reverse, left, and right commands using 0110 logic.

Diagnose and fix wifi and tcp/ip setup to convert a ros serial node to wifi, validate server port configuration, and test command velocity control via raw serial.

this lecture demonstrates driving a wifi-connected robot using ros2, executing right turns, forward and reverse movements, and stop commands, while noting high speed and skidding effects, all via wireless control.

Encoders provide feedback by converting motor motion into digital signals, with optical encoders using a slotted disc, enabling precise position, velocity, and distance tracking for mobile robots via interrupts.

Set up an ESP32 ROS2 encoder node using interrupts to count left and right encoders, then publish counts to ROS topics and debug direction issues.

Integrate encoder feedback with ROS2 by subscribing to command velocity from the keyboard and publishing encoder data to drive the car, organizing code into sections for interface, services, and encoders.

Explore ROS services as a request–response communication method, contrasting with publisher/subscriber patterns, and learn to implement a robot service that returns camera feeds or moves the robot for set seconds.

Explore ros2 service functionality through a callback that echoes input and shows how a service call blocks the publisher during processing with a counter service.

Learn to implement a robot drive service for a wifi-driven esp32 car, driving forward for a set time via a ros2 service, using a move_forward function and a service callback.

Implement a ros service that converts user input from string to seconds, converts to milliseconds, then drives the robot forward and stops via ros serial on ESP32 with ROS2.

Explore transforms in 2D space by defining robot positions and orientations relative to an origin, using translations and rotations, and distinguish dynamic wheel transforms from fixed body transforms.

Publish real-time transforms from the ESP32 and visualize them using rviz by setting the fixed frame to basslink, showing a transform from basslink to the door with a one-meter translation.

Develop an encoder interface and ROS2 service-driven profiles to control robot motion, then estimate wheel rotation ticks from timed delays of 300, 500, and 800 ms.

Explore differential drive odometry for a ROS 2-based ESP32 WiFi robot, tackle encoder noise, and implement a Python odom node to publish wheel transforms and odometry.

Investigate odom node parameters by evaluating inconsistent encoder outputs, averaging readings, and deriving counts per meter to configure the node’s inputs and improve wheel odometry.

Configure a MicroROS-enabled ESP32 robot and upload code, then run the differential drive odom node. Visualize encoder data in RViz and diagnose encoder errors affecting x, y, and rotation.

Push updates to the GitHub repository and document the readme with input, output, author, and time while outlining robot visualization, transforms, and ROS2 profiling for MicroROS and ESP32.

Set up an imu sensor via i2c on the esp32, publish imu data (orientation, angular and linear velocities) to ros2, and visualize in rviz with a static transform.

Launch a single ros launch file to automate the robot workflow, configure the differential drive transforms, and process encoder data for publishing and subscribing topics.

Finalize the project by validating the network connection and ROS2 communication through the ESB, launching the differential drive package, and controlling the robot car with keyboard input.