Comment configurer ROS 2 : Guide pratique

sudo apt update && sudo apt install locales
sudo locale-gen en_US en_US.UTF-8
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
export LANG=en_US.UTF-8
sudo apt install software-properties-common
sudo add-apt-repository universe

sudo apt update && sudo apt install curl -y
curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null
sudo apt update

# Installation bureau (recommandée) : ROS, RViz, démos, tutoriels
sudo apt install ros-jazzy-desktop

# Installation de base (minimale) : uniquement ROS et outils en ligne de commande
# sudo apt install ros-jazzy-ros-base

# Outils de développement (optionnels)
sudo apt install ros-dev-tools

# Source du fichier de configuration ROS 2 (ajoutez à ~/.bashrc pour la persistance)
source /opt/ros/jazzy/setup.bash

# Vérification de l'installation
ros2 --version
# Sortie attendue : ros2 version 26.0.0 (ou supérieure)

# Lister les nœuds
ros2 node list

# Lister les topics
ros2 topic list

# Écouter un topic
ros2 topic echo /scan

# Appeler un service
ros2 service call /reset_pose std_srvs/srv/Empty

# Lister les actions
ros2 action list

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class MinimalPublisher(Node):
    def __init__(self):
        super().__init__('minimal_publisher')
        self.publisher_ = self.create_publisher(String, 'topic', 10)
        timer_period = 0.5  # secondes
        self.timer = self.create_timer(timer_period, self.timer_callback)
        self.i = 0

    def timer_callback(self):
        msg = String()
        msg.data = f'Hello ROS 2: {self.i}'
        self.publisher_.publish(msg)
        self.get_logger().info(f'Publication : "{msg.data}"')
        self.i += 1

def main(args=None):
    rclpy.init(args=args)
    minimal_publisher = MinimalPublisher()
    rclpy.spin(minimal_publisher)
    minimal_publisher.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class MinimalSubscriber(Node):
    def __init__(self):
        super().__init__('minimal_subscriber')
        self.subscription = self.create_subscription(
            String,
            'topic',
            self.listener_callback,
            10)
        self.subscription  # éviter l'avertissement de variable inutilisée

    def listener_callback(self, msg):
        self.get_logger().info(f'J’ai entendu : "{msg.data}"')

def main(args=None):
    rclpy.init(args=args)
    minimal_subscriber = MinimalSubscriber()
    rclpy.spin(minimal_subscriber)
    minimal_subscriber.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

# Terminal 1 : Exécuter l'éditeur
python3 publisher.py

# Terminal 2 : Exécuter l'abonné
python3 subscriber.py

# Sortie attendue (Terminal 2) :
# [INFO] [minimal_subscriber]: J’ai entendu : "Hello ROS 2: 0"
# [INFO] [minimal_subscriber]: J’ai entendu : "Hello ROS 2: 1"

#include <chrono>
#include <memory>
#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

using namespace std::chrono_literals;

class MinimalPublisher : public rclcpp::Node {
public:
  MinimalPublisher() : Node("minimal_publisher"), count_(0) {
    publisher_ = this->create_publisher<std_msgs::msg::String>("topic", 10);
    timer_ = this->create_wall_timer(
      500ms, std::bind(&MinimalPublisher::timer_callback, this));
  }

private:
  void timer_callback() {
    auto message = std_msgs::msg::String();
    message.data = "Hello ROS 2: " + std::to_string(count_++);
    RCLCPP_INFO(this->get_logger(), "Publication : '%s'", message.data.c_str());
    publisher_->publish(message);
  }
  rclcpp::TimerBase::SharedPtr timer_;
  rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher_;
  size_t count_;
};

int main(int argc, char * argv[]) {
  rclcpp::init(argc, argv);
  rclcpp::spin(std::make_shared<MinimalPublisher>());
  rclcpp::shutdown();
  return 0;
}

# Créer un espace de travail
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src
ros2 pkg create --build-type ament_cmake cpp_pubsub

# Remplacer le fichier généré src/cpp_pubsub/src/publisher_member_function.cpp par le code ci-dessus
# Compiler
cd ~/ros2_ws
colcon build --packages-select cpp_pubsub

# Sourcer l'espace de travail
source install/setup.bash

# Exécuter l'éditeur
ros2 run cpp_pubsub talker

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        Node(
            package='cpp_pubsub',
            executable='talker',
            name='talker_node',
            parameters=[{'use_sim_time': True}]
        ),
        Node(
            package='demo_nodes_py',
            executable='listener',
            name='listener_node'
        )
    ])

ros2 launch launch_example.py

# Lister les paramètres
ros2 param list

# Obtenir un paramètre
ros2 param get /talker_node use_sim_time

# Définir un paramètre
ros2 param set /talker_node use_sim_time false

from rclpy.qos import QoSProfile, ReliabilityPolicy, HistoryPolicy

qos_profile = QoSProfile(
    reliability=ReliabilityPolicy.RELIABLE,
    history=HistoryPolicy.KEEP_LAST,
    depth=10
)

self.publisher = self.create_publisher(
    String,
    'topic',
    qos_profile
)

<robot name="my_robot">
  <ros2_control name="MyRobotSystem" type="system">
    <hardware>
      <plugin>my_robot_hardware/MyRobotSystemHardware</plugin>
    </hardware>
    <joint name="joint1">
      <command_interface name="position"/>
      <state_interface name="position"/>
      <state_interface name="velocity"/>
    </joint>
  </ros2_control>
</robot>

from launch import LaunchDescription
from launch_ros.actions import Node
from launch_ros.substitutions import FindPackageShare
from launch.substitutions import PathJoinSubstitution

def generate_launch_description():
    return LaunchDescription([
        Node(
            package='controller_manager',
            executable='ros2_control_node',
            parameters=[PathJoinSubstitution([
                FindPackageShare('my_robot_description'),
                'config',
                'my_robot_controllers.yaml'
            ])]
        ),
        Node(
            package='controller_manager',
            executable='spawner',
            arguments=['joint_state_broadcaster']
        ),
        Node(
            package='controller_manager',
            executable='spawner',
            arguments=['joint_trajectory_controller']
        )
    ])

# Lancer rqt
rqt

# Plugins courants :
# - Moniteur de topics (/rqt_topic)
# - Appel de service (/rqt_service_caller)
# - Graphe des nœuds (/rqt_graph)

# Enregistrer des topics
ros2 bag record /scan /odom

# Rejouer
ros2 bag play rosbag2_2026_06_02-12_00_00

# Informations
ros2 bag info rosbag2_2026_06_02-12_00_00

# Lancer RViz2
rviz2