Learn ROS2 as a ROS1 Developer and Migrate Your ROS Projects

Install Rosta and start existing nodes to see the main differences between Rosewarne and Rosta, and learn about architectural changes to better understand the migration.

Install ROS2 Foxy on Ubuntu 20.04 using binary packages, then set up your environment by sourcing /opt/ros/foxy/setup.bash and updating your bashrc for automatic initialization.

Launch a ros2 node, explore ros2 tools, and compare with ros1 by using ros2 run, ros2 topic, and ros2 interface to publish, subscribe, and inspect messages.

Compare ros1 and ros2, noting ros2’s cross‑platform support and a changed transport layer that enables independent nodes to discover each other without a master. Learn language bindings and multi‑machine communication.

Translate a eurozone application into a Rosta application, rewrite an existing Rosewarne project, and learn to build a Rosta app with packages, nodes, topics, services, barometer's analogizes, and tools.

Install and configure ROS Noetic on Ubuntu to test a ROS1 app, learn to source the setup scripts, manage environments, and avoid mixing distributions.

Explore the ROS1 eurozone app's structure, packages, nodes, topics, and services, and translate it to ROS2 while setting up a workspace and building the code across implementations.

Install colcon as the build tool for ROS2 and prepare your workspace for migration from ROS1 by configuring colcon extensions and sourcing the bash completion script for seamless development.

Create a ros2 workspace with a src directory for packages, then source the global ros installation and the workspace overlay before running a build.

Learn to create a Python package in ROS 2, compare with ROS 1 packaging, and configure dependencies, package.xml, and Python package structure for your workspace.

Create a C++ package for the ros2 app using ros2 pkg create with cmake, add std_msgs and my_robot_msgs dependencies, and organize include and source folders.

Create a Python ros2 node inside a ros2 workspace and Python package. Initialize rclpy, instantiate a node object, log via the node, and run with ros2 run, highlighting ros1 migration.

Create a ROS2 Python node using object-oriented programming, subclassing the node and using super, then use timers and spin for periodic callbacks.

Learn to create a C++ ros2 node by initializing ros communication, using a node handle and shared pointers, and adding a publisher and subscriber; build, install, and run the executable.

Create a class that inherits from a node base, initializes its fields, and uses a timer with a shared pointer bound to a callback to print a number at intervals.

Learn to create ros2 nodes in python and c++ using templates, including a no counter node and a no control node, by inheriting from node and spinning in main.

Learn to implement a Python publisher and subscriber in ROS2, publish on a topic, process messages via a callback, and migrate ROS1 patterns across nodes.

Learn to implement ROS 2 topic publishers and subscribers in C++, migrating from ROS 1. Create publishers and subscriptions, publish messages, and handle callbacks with shared pointers in node-based workflow.

Create custom interfaces for ROS 2 by building a robot interfaces package, configuring rosidl for message and service generation, and using the generated interfaces in C++ and Python projects.

Create a ROS2 Python service in a node, implement a callback that processes the request and returns a boolean response, and test it to reset a counter.

Learn to write a ROS2 C++ service, implementing a counter service with a request and response callback, configuring dependencies, and building and running node to handle and return counter values.

Explore remappings in ROS2 to rename nodes, topics, and services at runtime, using command line arguments to apply the remap across the running system.

Explore how ros2 handles parameters: unlike ros1's global parameter server, parameters live inside each node and are declared, retrieved, and set at node startup.

Learn how to declare ROS2 parameters in Python and C++, see that parameters live in nodes, and set values at runtime via the command line, including booleans, integers, strings.

Declare parameters at the start, set values at runtime, and retrieve them from the node using self.get_parameter; publish with a timer based on the frequency.

Learn how to retrieve and use parameters in C++ within ROS2, including default values, typing with parameter objects, and converting a runtime frequency into a timer interval in milliseconds.

Create a Python-based ROS2 launch file to start multiple nodes, configure parameters, remap topics, and migrate from ROS1 launch workflow.

Navigate a cross-bridge that lets ROS1 and ROS2 work together. Implement a transition phase to migrate large projects by running ROS1 and ROS2 packages directly from your ROS application.

Learn to enable Rosewarne Bridge with your custom messages by compiling the bridge from source, using provided code, and setting up workspaces for ROS1–ROS2 message compatibility.

Install and build the ROS 2 bridge for custom messages by configuring cross and bridge workspaces, sourcing ROS installations, and noting CMH false and long build times.

Publish and subscribe across ros1 and ros2 using the ros bridge, by sourcing the bridge workspace, building custom messages, and testing with a shared topic.

Map and align custom messages for the ros bridge by editing a mapping rules file to ensure package and message name consistency across ros1 and ros2.

Build and test a cross to bridge mapping between ros1 and ros2, handling custom interfaces and messages, then verify topics, services, and remapping during migration.

Migrate a ROS1 project to ROS2 by porting Python and C++ packages to Noetic, configuring launch files, and validating with a turtle simulation.

Learn the step-by-step process to migrate a ros1 project to noetic, covering step zero for python 3 readiness, seed preparation, system interfaces, and a final launch file.

Port the ROS projects from Melodic to Noetic by creating a workspace, cleaning up the project, and updating Python to 3, then build, launch, and verify compatibility.

Open a new workspace, unzip the seed project, and build the ros bridge from source to bind ros1-ros2 messages, including custom and dersim messages, using the provided seed.

Learn to port a target publisher node from ROS1 to ROS2 in Python, create the package with dependencies, and run the new coordinates publisher in a ROS2 workspace.

Port the turtle controller node from ROS1 to ROS2 using Python, building a publisher and subscriber turtle control node with target coordinates and a timer-driven loop.

Create a launch file to run the migrated ROS2 project, configure its package and dependencies, and define a simple launch description with a total control node and a target publisher.

Complete the migration by recreating the C++ project with provided code, then enhance the app with launch pad parameters and remapping as you migrate ROS1 projects to Noetic and ROS2.

Plan your next steps by migrating existing ROS1 projects to ROS2 using the Rosewarne Bridge package, and continue practicing core ROS concepts like nodes, topics, services, parameters, and launch.