Robotics and ROS - Learn by Doing! Manipulators

Install ros noetic on ubuntu 20 using terminal commands, configure sources, install dependencies, and verify ros core on a virtual desktop with gazebo for simulation.

Install a robust robotics development environment by upgrading the terminal, adding ros packages (move it, ros controllers, gazebo), and setting up python tools (pip, flask) plus vscode and arduino ide.

Ros stands for robot operating system, a software framework that manages robot hardware and software through reusable packages. It enables hardware-agnostic development, reusing modules across different robots and cameras.

Explore hardware abstraction in ROS and its analogy to a desktop operating system, showing how ROS provides a standard interface for sensors and motors.

Explore device control in ROS through drivers that connect hardware to the OS, using printers and cameras as examples to provide a standard interface for sending commands and retrieving data.

Ros master coordinates node communication through a publisher-subscriber model. Learn how topics, languages, and message types route data between publishers and subscribers.

Explore how ROS package management structures software into reusable, node-based packages that speed up robot development by leveraging community-implemented, optimized components.

Clarify the architecture of a ROS application by defining the workspace, packages, and nodes, and show how packages host navigation and obstacle detection nodes.

Create and initialize a ros workspace with a src folder, add the arduino ball test package with dependencies ros cpp, ros py, and std_msgs, and build with catkin_make.

Learn to build a Python ROS publisher node that publishes string messages on the chatter topic at 10 Hz, using rospy and the ROS master.

Publish a string hello world with a counter to the chatter topic at ten hertz in a ros cpp publisher node, using std_msgs.

Create a Python subscriber node in ROS to listen to a topic, handle string messages with a callback, and log received data while showcasing cross-language publisher compatibility.

Create a C++ ROS subscriber node that reads string messages from a topic, handles them via a callback, and prints 'I heard' followed by the message, demonstrating cross-language ROS communication.

Explore how a digital twin visualizes and simulates a real robot on your PC, including physics and sensors, to speed up debugging and testing.

Visualize robot data with RViz to inspect maps, laser scans, and camera images in ROS topics, using plugins to interpret complex messages for a digital twin and robot model.

Define the robot structure using the URDF format, XML, specifying links, joints, sensors, masses and inertias, and their mounting to create a kinematic tree for simulation or prototyping.

Create a robot ERDF skeleton in ROS by building an Arduino bot description package, defining links and joints with XML, and visualizing the model with ROS launch.

Build the robot’s digital twin by adding links and revolute and fixed joints from base to gripper, configuring origins and meshes, then visualize with ROS.

Learn how the ROS parameter server stores configuration variables accessible by all nodes, enabling asynchronous sharing of infrequently changing data like robot descriptions.

Master the rosparam workflow on the ROS parameter server by listing, getting, and setting parameters such as ros distro noetic and first name Antonio, which vanish when ROS master stops.

Convert sacro and macro to erdf, load the robot description into the ROS parameter server, and visualize the model in rviz using the robot state publisher and joint state publisher.

Learn how Gazebo enables a digital twin in ROS by simulating sensors and motors, publishing identical topics to real hardware, and testing perception and grasping in a virtual environment.

Enhance the URDF with collision, mass, inertia, and transmission data for Gazebo simulation, using macros for default inertial values and configuring Gazebo plugins for robot control.

Create and use a ROS launch file to start Gazebo simulations by launching multiple nodes and loading parameters with a single command, reducing terminals and manual setup.

Launch a single ROS launch file to visualize the robot by loading RDF model into the parameter server and starting the joint state publisher, robot state publisher, and RViz display.

Create a reusable ROS launch file to start a Gazebo robot simulation, spawning the robot from an RDF model with configurable arguments.

Explore how ROS Control enables motor actuation through a modular control system, linking the hardware interface and the controller manager to translate inputs into motor commands in simulation and reality.

Learn how YAML configuration files enable modular ROS nodes for different robots. Load these parameters from the ROS parameter server to tailor grasping applications to varying joints and grippers.

Create a yaml configuration file in the Arduino Test package, start the ros core, and load it into the parameter server with ros param load; verify with ros param list.

Use the ROS timer to manage time progression from image capture to processing and planning, improving obstacle detection and trajectory decisions.

Create a simple Python ROS node that uses a timer to execute a function every second. Define the timer callback, log messages, and restart the timer for the next execution.

Create a simple C++ ROS timer node that executes every second and prints a console message. Implement a one-second timer and a timer callback that outputs code timer callback function.

Explore ROS services, including the service server and service client, and how request‑response communication enables reusable functionality like face recognition across nodes.

Learn to build a simple python ros service server that adds two integers and returns the sum, with a defined interface and callback.

Develop a basic ROS C++ service server that sums two input integers, defines the request and response in a srv file, advertises the service, and runs with roscore.

Create a Python service client in ROS that calls a prior service server to sum two numbers, using wait_for_service and a service proxy, with two command-line arguments.

Create a c++ ROS service client that uses the add_two_ints interface to sum two numbers via the server, sharing the same request and response messages in the Arduino test package.

Explore how the hardware interface, together with the controller manager, converts ROS radians to Arduino degrees for servo motors, enabling bidirectional feedback and seamless control via a service server.

Implement a Python angles converter service to translate ros radians to Arduino degrees for the control system, exposing two services: radians to degrees and degrees to radiance.

Create a ros cpp service server to convert angles from ros radians to arduino degrees and back, using a new arduino controller package with the angles converter interface.

Build the real robot control system with ROS and C++. Create an Arduino board interface with joint state and joint command interfaces, managed by a controller manager.

Implements the Arduino board interface logic to run the ROS controller, converting commands to degrees via the radians-to-degrees service and publishing to Arduino actuate using joint state and position interfaces.

Define the joint trajectory and joint state interfaces for the controller manager, enabling arm and gripper control. Create YAML configurations under the Arduino board namespace for 50 Hz status updates.

Launch and orchestrate the Arduino board control system with a configurable ROS launch file that loads YAML parameters, starts real or simulated nodes, remaps joint states, and runs Gazebo simulation.

Explore robot kinematics, linking joint angles to the gripper’s position and orientation using direct and inverse kinematics, and simplify arm motion in Cartesian space.

Explore two dimensions of reference frames and how translation and rotation compose motion, transforming a point from the world frame to the link frame via a translation vector.

Learn how two-dimensional rotation changes a rigid body's orientation in the plane, using frames l and w and a rotation matrix to relate coordinates between the frames.

Derive the 2d roto-translation between frames l and w by combining rotation and translation into a single transformation matrix that links the coordinates of point p.

Extend translation from two to three dimensions by modeling a rigid body's motion with translation and rotation, using world and link frames to compute point P's position.

Explore three-dimensional rotation by decomposing rigid-body motion into elementary rotations about the z, y, and x axes, using Rz, Ry, and Rx matrices to relate coordinates between frames.

Compute the position of point P in world by combining translation and rotation from frame L to frame W with a transformation matrix that incorporates the translation vector and rotation.

Master forward kinematics for a 3-dof robot arm by computing the gripper position from joint angles using transformation matrices and frame chains, relating world and end-effector frames with tf.

Explore how the ETF library tracks frame positions and orientations and publishes them via the robot state publisher, enabling direct kinematics with DF Echo and TF Echo.

Explore how inverse kinematics convert a gripper’s position in three-dimensional space into joint angles, enabling direct gripper control and motor actuation.

Explore MoveIt fundamentals with the MOVE group node, inverse kinematics, and obstacle-aware trajectory planning. Learn how the planning scene, sensors, and GUI/API interfaces enable real or simulated robot control.

Explore setting up MoveIt for a robot manipulator by generating collision-aware configuration, defining planning groups for the arm and gripper, and producing a ready-to-run ROS package with launch files.

Configure MoveIt by editing Kinematics.yaml to enable position-only inverse kinematics, remap Arduino joint states, and update move group, controllers, and launch files; then plan and execute trajectories in Gazebo.

Explore a ROS-based framework with a digital twin, trajectory control, and Move It kinematics to operate a robot gripper via GUI or API integration and voice commands.

Learn how ROS actions provide non-blocking asynchronous communication between an action client and an action server for long-running robotic tasks, offering goal submission, periodic feedback, and final results.

Learn the actionlib interface for long-running robot tasks by coordinating an action client and server with goal, feedback, result, and cancellation.

Develop a Python action server in ROS to compute the Fibonacci sequence up to a given order, defining a Fibonacci.action interface with goal, feedback, and result messages.

Learn to implement a simple ROS action server in C++ that computes the Fibonacci sequence up to a given order, including goal, feedback, and result messages, with preemption handling.

Implement a Python action client that communicates with a Fibonacci action server, sending a goal, waiting for the result, and printing the resulting Fibonacci sequence.

Develop a C++ ROS action client that communicates with a Fibonacci action server, sends a goal, waits for results, and prints the resulting sequence.

Develop a Python ROS action server that uses the Movie API to plan and execute robot tasks, enabling Alexa voice control and Move It planning for arm and gripper.

Build a C++ ROS action server connected to a movie API to define robot tasks, using Move It to plan trajectories and Alexa for voice-triggered execution.

Connect your robot to the internet to unleash cloud-enabled capabilities by creating an Amazon Alexa skill that uses the API and GUI to trigger robot tasks and provide feedback.

Create and configure a custom Alexa skill to control an Arduino robot over the internet, including invocation name, intents, endpoint setup, building, and testing with voice and JSON requests.

Configure the Alexa skill and establish communication with your PC using engine rock HTTP server on port 5000. Configure the Alexa developer console endpoint and test the interaction.

Develop the interface between the robot and Alexa by building a Python Flask web service, using the Alexa SDK for Python to handle launch intents and exchange commands.

Develop and test an Alexa skill that uses a ROS task server to control the robot through peak, sleep, wake, and launch intents with dedicated handlers.

Integrate and simulate the full robot system using ROS, Gazebo, and Arduino, then visualize with MoveIt and RViz. Explore launch workflows and prepare for real-robot integration.

Replace the simulated gazebo with a real robot arm and implement all course functionalities on hardware using ROS, with both simulated and real environments to test ideas.

Establish bidirectional Arduino–ROS communication to actuate servo motors, using the Rosie Arduino library to serialize messages and enable the Arduino as a ROS node publishing and subscribing to topics.

Create a publisher ROS node on an Arduino using the ROS library, publishing 'Hello World' to the chatter topic every second, via the Arduino IDE and USB connection.

Develop an Arduino ROS subscriber that listens to the toggle led topic via ros_lib, reads empty messages, and toggles the Arduino board LED when messages arrive.

Master controlling robot joints by actuating servo motors with Arduino and ROS, starting from a single servo to four servos across all joints using a ROS publisher-subscriber interface.

Control four Arduino-attached servo motors (base, shoulder, elbow, gripper) via ROS, using unsigned int multi array messages with min 0 max 180 and smooth 1-degree steps.

Assemble the robot and calibrate its motors in a hands-on lab for manipulators. Develop ROS-based manipulation skills through a practical, project-driven lab.

Engage in a hands-on hardware lab to assemble the robot, Part 1, building practical skills with manipulators and ROS concepts from the robotics course.

Assemble the robot in part 2, continuing the hands-on manipulator build and component integration for a practical, learn-by-doing experience in robotics and ROS.

Develop hands-on skills in robotics and ROS manipulators by assembling the robot in part 3 of the hardware lab.

Launch a complete ros launch file to bring up the real robot, load the rdf model, start the control system, and enable moveit and Arduino serial interfaces, and Alexa control.

Build and control a real robot from scratch using an RDF model, ROS control, and trajectory planning with inverse kinematics to drive a gripper, plus Alexa voice control.

Finish this journey by applying robot manipulator concepts with professional tools used by leading robotics firms in real projects, developing your ideas through hands-on, creative learning.