MicroROS and ESP32 WiFi Controlled Robot Hands-On using ROS2

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.

Enable wifi control on an ESP32 with wifi.h, a client and server on port 80, connecting to an ssid and password to drive the robot via http.

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.

Learn to structure ESP32 projects into libraries for motor driving, OLED display, and Wi-Fi communication, enabling distributed code, easier debugging, and better programming practices.

Create modular libraries for an ESP32 robot project with OLED display, motor control, and WiFi data processing. Structure header files with extern objects and include guards to improve maintainability.

Explore platform io, open main.cpp, and implement a micro-ros node using the rclcpp interface with the executor, support, and allocator to enable inter-node communication between the ESP32 and a laptop.

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.

Implement a micro ROS enabled ESP32 robot by refactoring initialization, defining wifi setup and subscriber, starting executors, and mapping command velocity to forward, reverse, left, and right via teleop twist.

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.

See the final output of a wifi controlled robot hands-on project built with micro-ROS on ESP32, integrated with ROS2 for seamless robotics 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 the basics of ROS topics, publishers, and subscribers, including message types and multi-subscriber scenarios, in a microROS and ESP32 wifi setup with localization, mapping, slam, and obstacle avoidance examples.

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.

Learn to create a ROS2 ultrasonic sensor node on an ESP32, publish distance values to the ultrasonic values topic as an ultrasonic message, and test in a simulated environment.

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.

Run a real sensor through a ROS2 ESP package with a simulation to enable real-world and simulated worlds to communicate and control rotation based on distance.

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.

Publish to the command velocity topic in ROS2, using geometry messages to map linear x and y and angular z from keyboard input into robot 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.

During testing, the lecture shows mapping command velocity inputs to left and right wheel values, using a mapping function and direction pins, with serial prints and a stop-on-zero condition.

Convert velocity topic messages to PWM signals for a two-wheel robot, test forward, backward, and turning motions, and debug wheel direction inversions in ROS2 with microROS on ESP32.

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.

Shift from serial to wifi control for a micro-ROS and ESP32 robot, configuring IP and server port, and uploading ROS2-compatible code to enable wireless operation.

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.

Learn to implement encoder interfaces with interrupts on ESP32, wiring pins, and attaching interrupts, then publish encoder values in ROS2 via micro-ROS publishers for left and right encoders.

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 encoder outputs in a ROS2 ESP32 robot, using a velocity subscriber and an encoder publisher, and fix timing with loop delays for faster, more reliable updates.

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 a basic ROS service example on MicroROS with ESP32, demonstrating a service server and client, and how a request prints hello and world, plus a counter message.

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.

Create a ROS2 based service that makes a differential drive robot move straight for a given distance or time, using velocity control and encoder feedback.

Push and update the GitHub repository as you complete each section, review the readme and main changes, track commits, and prepare to move into section four.

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.

Explore tf messages and the transform broadcaster to publish geometric transforms between frames, using headers, quaternions, and transforms in ROS to represent circular motion.

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.

Implement a ROS-based service to clear encoder data and reset encoders between profiles, and publish encoder values through callbacks.

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.

This lecture explains odometry messages in ros2 navigation, including position and orientation in base_link, variances, and how encoder ticks translate to travel distance using wheel geometry.

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.

learn to create a single ROS launch file to run three nodes for the sb32 package, enabling serial communication, publish, and output viewing from one streamlined launch.

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.

Learn to use an imu sensor for x, y, z rotations. Publish imu data on ros2 topics and read wheel encoders with differential drive to map motion in 3d space.

Visualize robot odometry in rviz using the launch file with Esp32 and MicroROS. Drive the robot with the keyboard and observe odometry, encoder inaccuracies, delays, and command velocity.

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.