ROS Tutorials for Beginners

Explore ROS nodes and topics using a robotic vacuum example, showing how motor driver, distance sensor driver, and controller run as nodes with data flow and synchronization managed by ROS.

Create a ros node by including ros.h or rospy, initialize with a name, and run at 10 Hz with ros logging in a package node_basics_p using roscpp or rospy.

Create a C++ ros node by initializing with ros::init, creating a nodehandle, looping with ros::ok at 10 Hz, and logging via ros_info_stream, while setting up CMake and building with catkin_make.

Learn to create a Python ROS node with rospy, initialize the node using init_node, log at 10 Hz with loginfo inside a Rate loop, and run with rosrun.

Start the ROS master with roscore to enable node communication, run the C++ and Python nodes, and verify with rosnode list. The ROS master tracks running nodes for inter-node discovery.

Learn how ROS topics enable publishing and subscribing between nodes, using publisher and subscriber nodes to exchange string messages via std_msgs in C++ and Python.

Implement a C++ publisher node that creates a ros publisher on topic my_first_t with queue size 10, publishing std_msgs::String messages at 10 Hz and logging with the ros info stream.

learn how to implement a python publisher node that sends a string message at 5 hz on the my_first_t topic using rospy and a 10 item queue.

Use subscriber nodes in ROS to receive topic messages via interrupts and callbacks, and keep the node running with ros::spin or rospy.spin.

Implement a ros subscriber node in c++ that subscribes to the my_first_t topic, logs received strings with ros_info via cpp_clbk, and keeps running with ros::spin.

Implement a Python subscriber node for ROS by creating a rospy.Subscriber to the my_first_t topic with String messages, a py_callback to log received data, and rospy.spin to await messages.

Learn to run ROS publisher and subscriber nodes in C++ and Python, publish on the topic my_first_t with std_msgs/String, and visualize cross-language communication with rqt_graph.

Visualize ros node communication with the rqt_graph tool, showing publishers and subscribers on topics such as my_first_t. Use rosrun, ROS master, and rostopic echo with rosnode info to inspect details.

Learn how to read a ROS wiki page and identify compatible ROS versions. Explore installing turtlesim via repository or GitHub, and review its nodes, topics, services, and parameters.

Drive the turtle with turtle_teleop_key publishing on turtle1/cmd_vel via turtlesim_node, observe real-time position and velocity, and use rostopic echo and rqt_graph to verify node communication.

Explore how the geometry_msgs/twist message carries two vector3 messages with x, y, and z components, enabling turtle motion and showing how to inspect this structure with rospack and rosmsg.

Explore the six fields of the twist message, learn how linear.x and angular.z control the turtlesim turtle, and publish circular movements using c++ and python nodes.

Publish twist messages from circleturtle_cpp_n to turtle1/cmd_vel to drive the turtle in a circular path at 20 Hz, with configurable linear x and angular z velocities.

Develop a Python ROS node to move the turtle in a circular path by publishing Twist messages to turtle1/cmd_vel at 20 hz, then explore collision prevention.

Learn to prevent turtle collisions by using real-time pose data and wall coordinates to steer turns, and monitor positions via the turtle1/pose topic.

Learn to implement both a publisher and a subscriber in one ros node, subscribing to the turtle pose topic, checking an imaginary boundary, and using spinOnce for callbacks.

Implement publisher and subscriber in one node to track turtle pose from turtlesim, update is_turtle_outside, and drive the turtle in an infinite loop.

Explore the difference between topics and services in ROS, and learn how clients and servers use bidirectional, synchronous communication, including examples like turtlex/set_pen and turtlex/teleport_absolute.

Strengthen your ROS services knowledge by implementing nodes with a custom message type, exploring turtlesim spawn and set_pen services, and building a client to call services in C++ and Python.

Implement a cpp ros service client to call turtle1/set_pen and change the turtle color on boundary crossing, waiting for the service and using two requests for inside and outside.

Learn to implement a ROS service client node that uses the SetPen service to change the turtle’s path color when it crosses a boundary, using rospy wait_for_service and a ServiceProxy.

Learn how to create custom message and service types for real-world applications, explore turtlesim's msg and srv definitions, and understand how auto-generated headers and modules support these types.

Create custom .msg and .srv files in a ROS package, edit CMakeLists, and build with catkin_make, then implement a three-node system: publisher, subscriber, and server/client using RobotStatus and WarningSwitch.

Edit and generate ROS messages and services by refining RobotStatus.msg and WarningSwitch.srv, wiring dependencies to geometry_msgs and std_msgs, and building C++ and Python modules via catkin_make.

Create a C++ ros node that reads motor rpm data from a csv file and publishes RobotStatus messages on the my_robot_status_t topic at 1 Hz, using custom messages.

Implement the second node that subscribes to the my_robot_status_t topic, monitors motor rpm with a 1900 threshold, and triggers the my_robot_warning_s WarningSwitch service.

Implement a ROS C++ server node for the my_robot_warning_s service in a three-node system, using advertiseService with WarningSwitch::Request to process warnings and send boolean responses.

Implement the first Python ros node to publish RobotStatus messages from rpm_locn_data.csv, reading seven fields (rpm values 1000-2000 and x y z coordinates) at 1 Hz.

Implement the second Python node that subscribes to my_robot_status_t, monitors motor rpm above 1900, and calls the my_robot_warning_s service using WarningSwitchRequest to trigger warnings.

Implements the third node in Python as a ROS service server for the my_robot_warning_s service, using a custom warning message type and a rospy callback with spin.

Explore how the parameter server stores global parameters for all nodes and how rosparam list, get, and set manage turtlesim background colors.

Set and load ros parameters using rosparam and YAML files to configure nodes before launch. Save and verify parameter values on the parameter server, and preview changes with turtlesim_node.

Learn to manage multiple ROS nodes with XML launch files, using tags, elements, and attributes to configure parameters and rename nodes and topics.

Learn how the launch and node tags drive ROS executions by specifying name, package, and type in a launch file, with a Python publisher and C++ subscriber example.

Configure a ROS launch file using the <launch> and <node> tags to start a Python publisher and a C++ subscriber, with package, type, name, and screen output.

Use the remap tag in ROS launch files to change topic names, remapping from my_first_t to my_second_t and restoring communication between nodes started after the remap.

Master the param and rosparam tags in launch files to set single or multiple parameters, load from YAML, and guarantee parameters load before nodes in ROS.

Apply param and rosparam tags in ros launch files to set single or multiple parameters, load from YAML, and verify values with rosparam get.

Define and use arg tags in roslaunch to accept command line inputs with defaults, dereference them to set turtlesim parameters, and understand behavior when arguments are provided or omitted.

Explore the include tag in roslaunch, which lets a launch file incorporate other launch files or packages to launch multiple nodes modularly using the file attribute.

Discover how the ROS master coordinates nodes and enables distributed communication across networks, using IP addresses, ports, and URIs to connect devices like Raspberry Pi and high-performance PCs.

Configure linux hostnames and map them to local IPs with /etc/hosts, then verify ROS networking with roscore across two virtual machines.

Run roscore to start the parameter server, rosout, and the ros master, enabling parameter tracking, logging, and node registration; configure the master URI via ROS_MASTER_URI in .bashrc.

Register nodes with the ROS master via XMLRPC using ROS_MASTER_URI, sharing node names, topics, message types, and URIs, then establish TCPROS connections for publishers, subscribers, and services.

Set up two virtual machines to enable multi-machine ROS node communication. Verify connectivity by pinging each IP and test port accessibility with netcat on 12445 and 15525.

Set up multi-machine ros communication by running the ros master and publisher on vm1, and the subscriber on vm2, configuring ros master uri and building the multi_machine_p package.