ROS2의 시간 개념 (시스템 시간과 시뮬레이션 시간)

ROS2에서는 시간의 개념이 중요하다. 특히 시스템 시간과 시뮬레이션 시간을 명확히 구분하여 사용해야 한다. 시스템 시간은 컴퓨터 운영체제에서 제공하는 실제 시간(리얼타임)을 나타내며, 시뮬레이션 시간은 시뮬레이터에서 제공하는 가상 시간이다. 이 두 시간의 차이를 이해하는 것이 노드 간의 동기화를 위해 필수적이다.

시스템 시간 (System Time)

시스템 시간은 컴퓨터의 실시간 시계를 기반으로 동작하며, 이는 컴퓨터가 실제 물리적 세계와 상호작용할 때 필요한 시간이다. ROS2에서 시스템 시간은 일반적으로 실시간 제어나 로봇과의 물리적 상호작용에 사용된다. 예를 들어, 센서 데이터를 수집하거나 실제 하드웨어에서 동작하는 로봇에 명령을 전달하는 경우, 시스템 시간이 필요하다.

시스템 시간은 다음과 같은 식으로 표현된다:

$t_{\text{sys}} = T_{\text{epoch}} + \Delta T_{\text{sys}}$

여기서: - $T_{\text{epoch}}$ 는 시스템 시간이 시작된 기준 시간을 나타낸다. - $\Delta T_{\text{sys}}$ 는 기준 시간으로부터 경과한 시간을 나타낸다.

시뮬레이션 시간 (Simulation Time)

시뮬레이션 시간은 가상 환경에서 사용되는 시간으로, 시뮬레이션의 속도에 따라 다를 수 있다. 시뮬레이션 시간은 실제 시간과는 독립적으로 흐르며, 시뮬레이터가 제공하는 시간에 의해 결정된다. 이는 가상 환경에서의 로봇 동작이나 시뮬레이션 환경에서의 실험에 주로 사용된다.

시뮬레이션 시간은 다음과 같은 식으로 정의할 수 있다:

$t_{\text{sim}} = T_{\text{sim\_start}} + \Delta T_{\text{sim}}$

여기서: - $T_{\text{sim\_start}}$ 는 시뮬레이션이 시작된 시간을 나타낸다. - $\Delta T_{\text{sim}}$ 는 시뮬레이션 시간의 경과를 나타낸다.

시뮬레이션 시간은 시뮬레이터의 설정에 따라 빠르게 또는 느리게 흘러갈 수 있으며, 물리적인 제약에서 벗어난 실험을 가능하게 한다. 예를 들어, 시뮬레이터에서 특정 조건을 설정하여 시간의 흐름을 가속하거나 느리게 할 수 있다.

ROS2에서의 시간 사용 방법

ROS2에서는 시스템 시간과 시뮬레이션 시간을 모두 다룰 수 있는 API를 제공한다. 시간의 출처를 명시하지 않으면 기본적으로 시스템 시간이 사용되지만, 시뮬레이션 환경에서는 시뮬레이션 시간을 사용할 수 있다. 이를 위해 use_sim_time이라는 파라미터를 설정해야 한다.

시스템 시간과 시뮬레이션 시간을 구분하는 코드는 다음과 같이 작성된다:

rclcpp::NodeOptions options;
options.parameter_overrides(
  {{"use_sim_time", true}});
auto node = rclcpp::Node::make_shared("my_node", options);

이 코드를 사용하면 해당 노드는 시뮬레이션 시간으로 동작하게 된다. 시뮬레이션 시간과 시스템 시간 사이의 전환은 ROS2에서 원활하게 지원된다.

시간 동기화의 필요성

시스템 시간과 시뮬레이션 시간의 동기화는 여러 노드 간의 통신에서 매우 중요한 역할을 한다. 예를 들어, 여러 센서에서 데이터를 수집하거나 여러 로봇 간의 협력 작업을 수행할 때, 각 노드의 시간 기준이 서로 다르면 데이터의 일관성을 유지하기 어렵다. 시간 동기화가 제대로 이루어지지 않으면 메시지 전송 및 수신의 시점 차이로 인해 데이터 불일치나 시스템 오작동이 발생할 수 있다.

ROS2에서는 시간 동기화를 지원하기 위해 다음과 같은 방법들이 사용된다:

타임스탬프 기반 메시지 동기화: 모든 메시지는 타임스탬프를 포함하여 송신된다. 타임스탬프는 시스템 시간 또는 시뮬레이션 시간을 기반으로 생성되며, 이 시간을 기준으로 메시지 간의 동기화가 이루어진다.
노드 간의 시간 기준 통일: use_sim_time을 통해 시뮬레이션 시간과 시스템 시간을 명확히 구분하고, 모든 노드가 동일한 시간 소스를 사용하도록 설정할 수 있다. 이를 통해 메시지 타임스탬프가 일관되게 유지된다.

ROS2에서 타임스탬프 관리

타임스탬프는 ROS2에서 중요한 요소로, 메시지의 정확한 전송 시점을 기록하는 데 사용된다. 이를 통해 시스템 시간과 시뮬레이션 시간에 관계없이 각 메시지의 발생 시점과 수신 시점을 추적할 수 있다. 타임스탬프는 rclcpp::Time 객체로 처리된다.

auto time_now = node->get_clock()->now();

위 코드는 노드의 현재 시간을 반환하며, 이 시간은 시스템 시간 또는 시뮬레이션 시간 중 하나로 설정된다. 타임스탬프를 사용한 메시지 동기화는 다양한 시나리오에서 발생할 수 있는 시간 불일치를 방지하는 데 도움이 된다.

시뮬레이션 시간과 시스템 시간이 혼재되어 있는 상황에서는 각 시간의 기준을 명확히 하고, 해당 시간에 맞춰 타임스탬프를 생성해야 한다. 특히 시뮬레이션 시간에서는 시뮬레이터가 시간의 흐름을 제어하므로, 시스템 시간이 실제 시간과 다르게 느리거나 빠르게 흐를 수 있다.

타임스탬프와 QoS 설정

시간 동기화에서 중요한 또 다른 요소는 ROS2의 QoS (Quality of Service) 설정이다. QoS 설정을 통해 메시지 전송의 신뢰성, 시간 제한, 전송 우선순위 등을 제어할 수 있으며, 시간 동기화가 필요한 시나리오에서 적절한 QoS 설정은 필수적이다.

대표적인 QoS 설정에는 다음이 있다: - Deadline: 특정 시간 내에 메시지를 수신해야 하는 경우 설정하며, 메시지가 기한 내 도착하지 않으면 이벤트가 발생한다. - Liveliness: 노드가 정해진 시간 동안 활성 상태인지 여부를 확인한다. - Durability: 이전에 전송된 메시지를 저장하여 이후에 연결된 구독자에게 제공할 수 있는 설정이다.

다음은 QoS 설정 예시이다:

rclcpp::QoS qos_settings(10);
qos_settings.deadline(rclcpp::Duration(1, 0));  // 1초 내에 메시지를 받아야 함
qos_settings.liveliness(rclcpp::LivelinessPolicy::AUTOMATIC);
qos_settings.durability(rclcpp::DurabilityPolicy::TRANSIENT_LOCAL);

이와 같은 QoS 설정을 통해 시간 동기화와 관련된 메시지 전송 품질을 높일 수 있다.

ROS2에서 시간 간격 제어

노드 간 시간 동기화의 중요한 요소 중 하나는 타이머이다. 타이머는 특정 주기로 노드가 작업을 수행할 수 있도록 하는 메커니즘이다. 타이머는 주기적으로 실행되며, 시스템 시간 또는 시뮬레이션 시간에 맞춰 실행된다. 타이머 주기는 일반적으로 다음과 같은 식으로 표현된다:

$T_{\text{period}} = \frac{1}{f_{\text{desired}}}$

여기서: - $T_{\text{period}}$ 는 타이머 주기를 의미한다. - $f_{\text{desired}}$ 는 노드가 동작하기를 원하는 주파수(Hz)이다.

예를 들어, 10Hz로 동작하는 타이머는 0.1초 주기로 동작하며, 이는 다음과 같이 설정할 수 있다:

rclcpp::TimerBase::SharedPtr timer = node->create_wall_timer(
  std::chrono::milliseconds(100), callback_function);

여기서 create_wall_timer는 시스템 시간을 기준으로 타이머를 생성하며, std::chrono::milliseconds(100)은 100ms 주기로 타이머를 실행하게 설정한다.

실시간 시스템에서의 시간 동기화

실시간 시스템에서 시간 동기화는 매우 중요한 역할을 한다. 특히 ROS2가 지원하는 실시간 애플리케이션의 경우, 노드 간의 동기화가 정확히 이루어지지 않으면 데이터의 일관성 문제가 발생하거나, 시스템의 응답성이 저하될 수 있다. 실시간 시스템은 물리적 환경에서 로봇이 실시간으로 반응하는 능력에 의존하기 때문에, 시간 지연(Latency)과 관련된 문제를 신중히 다루어야 한다.

ROS2는 DDS(Data Distribution Service) 기반의 미들웨어를 사용하며, 이를 통해 실시간 통신에서 요구되는 시간 동기화를 지원한다. DDS는 분산 시스템에서 시간 동기화를 위해 QoS(품질 서비스) 설정을 사용할 수 있으며, 이를 통해 노드 간의 지연 시간을 줄이고, 통신의 신뢰성을 높인다.

시간 동기화와 타임스탬프 사용의 예

시뮬레이션 시간과 시스템 시간의 차이를 보여주는 구체적인 예를 들어보겠다. 예를 들어, 다음과 같은 상황이 있을 수 있다:

시뮬레이션 시간: 가상 환경에서 로봇의 움직임을 시뮬레이션하고 있는 경우
시스템 시간: 실제 물리적 로봇이 움직이는 경우

두 상황에서 각각 타임스탬프를 생성하고 동기화하는 방법은 다음과 같다.

1. 시스템 시간을 사용하는 경우:

시스템 시간을 사용하여 타임스탬프를 생성하려면, rclcpp::Clock 클래스를 활용할 수 있다.

rclcpp::Time current_time = node->get_clock()->now();

이 코드는 노드가 시스템 시간을 기준으로 타임스탬프를 가져오게 한다. 이 타임스탬프는 센서 데이터, 로봇의 상태 데이터 등을 기록할 때 사용된다.

2. 시뮬레이션 시간을 사용하는 경우:

시뮬레이션 시간은 시뮬레이터가 제공하는 가상 시간을 기반으로 동작한다. 시뮬레이션 시간은 시뮬레이터에서 use_sim_time 파라미터를 활성화해야만 동작한다.

rclcpp::NodeOptions options;
options.parameter_overrides(
  {{"use_sim_time", true}});
auto node = rclcpp::Node::make_shared("my_node", options);

이 코드가 실행되면 해당 노드는 시뮬레이션 시간으로 동작하며, 타임스탬프는 시뮬레이션 시간에 기반하여 생성된다.

3. 시간 동기화 시 발생할 수 있는 문제들:

시간 동기화에서 발생할 수 있는 주요 문제 중 하나는 시간 지연(Latency)이다. 특히 노드 간의 통신에서 지연이 발생하면, 동기화된 상태를 유지하기 어려울 수 있다. 예를 들어, 센서 데이터가 특정 시간에 발생했지만 해당 데이터가 다른 노드에 도착할 때 시간이 지연되면, 그 데이터는 유효하지 않게 될 수 있다.

ROS2에서 시간 지연 문제를 해결하기 위해 다양한 QoS 설정을 적용할 수 있다. 예를 들어, Best Effort QoS는 시간 지연을 줄이기 위한 한 방법이며, 실시간 시스템에서 이러한 설정을 적절히 활용해야 한다.

분산 시스템에서의 시간 동기화

ROS2는 분산 시스템에서 여러 노드가 서로 통신하는 경우에 시간 동기화를 지원한다. 이때, 시스템 시간과 시뮬레이션 시간을 모두 관리할 수 있으며, 각 노드는 자신의 타임스탬프를 유지한다. 그러나 네트워크 상에서 노드 간의 통신 지연이나 패킷 손실로 인해 시간 동기화가 깨질 가능성이 있다.

이러한 문제를 해결하기 위해 ROS2는 NTP(Network Time Protocol)와 같은 외부 시간 동기화 메커니즘을 지원할 수 있다. NTP를 통해 네트워크 상에서 노드 간의 시간이 동기화되면, 모든 노드가 동일한 시간 기준을 사용할 수 있다.

시간 동기화 아키텍처

시간 동기화 구조를 시각화할 수 있다.

graph TD; A[System Clock] --> B[ROS2 Node 1]; A --> C[ROS2 Node 2]; B --> D[Time Synchronization]; C --> D; D --> E[Distributed System Synchronization];

이 다이어그램은 시스템 시간이 ROS2 노드 1과 노드 2에 제공되고, 두 노드가 시간 동기화를 거쳐 분산 시스템에서 시간의 일관성을 유지하는 과정을 보여준다.

시간 지연(Latency) 문제 해결

ROS2에서 시간 지연은 실시간 시스템의 성능에 중대한 영향을 미칠 수 있다. 시간 지연을 최소화하기 위해서는 네트워크와 통신 프로토콜을 최적화하는 것이 중요하다. DDS 기반 ROS2는 QoS 설정을 통해 지연을 줄이거나 허용 가능한 범위 내로 조정할 수 있다.

ROS2의 시간 지연을 줄이기 위한 전략은 다음과 같다:

QoS 정책 최적화: ROS2의 QoS 정책은 메시지 전송 및 수신의 신뢰성과 효율성을 관리할 수 있는 중요한 도구이다. Best Effort 모드를 사용하면 패킷 손실에 따른 데이터 전송 지연을 줄일 수 있다. 또한 Low Latency 모드를 설정하여 패킷이 네트워크를 통해 신속하게 전송되도록 할 수 있다.
메시지 크기 최소화: 전송하는 메시지의 크기를 줄이는 것도 지연 시간을 줄이는 중요한 방법이다. 불필요한 데이터를 제외하고 필요한 정보만 전송하도록 설계해야 한다. 메시지의 직렬화 및 역직렬화 과정에서 발생하는 시간을 줄이기 위해 직렬화 알고리즘을 최적화하는 것도 방법이 될 수 있다.
멀티스레딩 및 멀티프로세싱: 여러 노드가 동시에 데이터를 처리하고 시간 동기화를 유지하기 위해 멀티스레딩 및 멀티프로세싱 기법을 적용할 수 있다. ROS2는 멀티스레딩을 지원하며, 이를 통해 시스템의 처리 능력을 향상시키고 지연 시간을 줄일 수 있다.
NTP(Network Time Protocol): 네트워크 기반 시간 동기화 프로토콜인 NTP를 사용하면 네트워크 상의 노드들이 동일한 시간 기준을 유지할 수 있다. 이를 통해 네트워크 지연으로 인한 시간 불일치를 줄일 수 있다. 특히, 분산 시스템에서 여러 로봇이 협력하여 작업할 때, NTP는 시간 동기화의 신뢰성을 높이는 중요한 방법이다.

시간 지연 문제 해결을 위한 예시 코드

QoS 설정을 통해 시간 지연을 최소화하는 예시 코드를 살펴보겠다. 이 코드는 Best Effort QoS를 사용하여 메시지를 전송하며, 시간 지연을 줄이기 위한 전략을 보여준다.

rclcpp::QoS qos_settings(10);
qos_settings.reliability(rclcpp::ReliabilityPolicy::BestEffort);
qos_settings.durability(rclcpp::DurabilityPolicy::Volatile);

auto publisher = node->create_publisher<std_msgs::msg::String>("topic_name", qos_settings);

위 코드에서 Best Effort 모드는 패킷이 손실될 수 있음을 허용하지만, 메시지 전송 속도를 최적화하여 시간 지연을 줄이다.

분산 시스템에서의 시간 동기화

분산 시스템에서는 여러 노드가 서로 다른 하드웨어나 네트워크 상에서 실행되기 때문에 시간 동기화가 더욱 중요한 역할을 한다. ROS2는 DDS의 Time Synchronization 기능을 통해 노드 간 시간 동기화를 지원한다. 또한, NTP(Network Time Protocol)나 PTP(Precision Time Protocol)와 같은 프로토콜을 사용하여 네트워크 상의 모든 노드가 동일한 시간 기준을 따르도록 설정할 수 있다.

NTP 동작 원리

NTP는 클라이언트-서버 구조를 기반으로 동작하며, 네트워크 상의 클라이언트가 중앙 서버로부터 시간 정보를 받아와 각자의 시간을 동기화한다. 각 클라이언트는 서버에서 받은 시간 정보를 바탕으로 자신의 시스템 시간을 보정하게 된다. 이러한 방식으로 네트워크에 연결된 모든 시스템이 동일한 시간 기준을 따르게 된다.

NTP의 시간 동기화 과정은 다음과 같다:

클라이언트가 NTP 서버로 시간 요청을 보냄.
서버가 클라이언트로 정확한 시간 값을 전송.
클라이언트는 받은 시간 값을 바탕으로 자신의 시간을 수정 및 동기화.

NTP는 높은 정확도로 시간 동기화를 제공할 수 있지만, 대규모 분산 시스템에서는 더욱 정밀한 시간 동기화가 필요할 수 있다. 이 경우 PTP(Precision Time Protocol)를 사용할 수 있으며, PTP는 NTP보다 더 높은 정밀도를 제공한다.

PTP(Precision Time Protocol)의 동작 원리

PTP는 IEEE 1588 표준을 기반으로 한 시간 동기화 프로토콜로, 마이크로초 단위의 정밀도를 제공할 수 있다. PTP는 네트워크 상에서 마스터와 슬레이브 노드 간의 시간 동기화를 지원하며, 주로 실시간 시스템에서 사용된다.

PTP 시간 동기화 메커니즘:

마스터 노드: 네트워크 상의 시간을 기준으로 제공하는 역할을 한다.
슬레이브 노드: 마스터 노드로부터 시간 정보를 받아 자신의 시스템 시간을 수정한다.
동기화 메시지: 슬레이브 노드는 마스터 노드가 전송하는 시간 정보 메시지를 수신하여 자신의 시간을 동기화한다.

이러한 방식으로 PTP는 실시간 시스템에서 매우 높은 수준의 시간 동기화를 보장한다.

타임스탬프의 오차 및 보정

시스템 시간 또는 시뮬레이션 시간을 사용할 때 타임스탬프에서 발생할 수 있는 오차를 보정하는 것도 중요하다. 타임스탬프 오차는 주로 다음과 같은 원인으로 발생할 수 있다:

네트워크 지연: 메시지가 네트워크를 통해 전송될 때 발생하는 지연.
노드 처리 시간: 노드가 메시지를 생성하거나 처리하는 데 걸리는 시간.
하드웨어 차이: 네트워크에 연결된 각 시스템의 하드웨어 성능 차이에 따른 시간 오차.

이러한 오차를 보정하기 위해, ROS2에서는 타임스탬프를 직접 수정하거나 NTP와 같은 시간 동기화 프로토콜을 사용할 수 있다.

타임스탬프 보정 방법

타임스탬프 오차는 ROS2에서 데이터의 일관성을 유지하는 데 중요한 역할을 한다. 타임스탬프 오차를 보정하는 주요 방법은 다음과 같다.

1. 네트워크 지연 보정

네트워크에서 발생하는 지연은 일반적으로 네트워크 트래픽 상태나 물리적 거리로 인해 발생한다. 이를 해결하기 위해, ROS2는 타임스탬프를 수신 시점에 맞춰 보정하는 기능을 제공한다. 노드가 메시지를 수신하면, 해당 메시지의 타임스탬프를 시스템의 현재 시간과 비교하여 네트워크 지연을 추정할 수 있다.

auto message_time = message->header.stamp;
auto current_time = node->get_clock()->now();
auto delay = current_time - message_time;

이 코드는 수신된 메시지와 현재 시간 간의 지연을 계산하며, 이를 바탕으로 타임스탬프 보정을 할 수 있다.

2. 노드 처리 시간 보정

노드에서 발생하는 처리 시간도 타임스탬프의 오차를 유발할 수 있다. 예를 들어, 노드가 센서 데이터를 처리하는 데 걸리는 시간이 길어질수록 타임스탬프와 실제 데이터 발생 시점 간의 차이가 커질 수 있다. 이를 보정하기 위해, ROS2에서는 타임스탬프 생성 시점을 명확하게 정의해야 한다.

데이터가 생성된 시점에서 타임스탬프를 기록하는 것이 가장 이상적이다. 예를 들어, 센서가 데이터를 수집하는 순간 바로 타임스탬프를 기록하면, 노드의 처리 시간에 따른 오차를 줄일 수 있다.

3. 하드웨어 차이에 따른 보정

ROS2는 여러 하드웨어 시스템에서 동시에 작동할 수 있으며, 각 시스템의 하드웨어 성능 차이에 따라 시간 동기화가 필요하다. NTP와 같은 시간 동기화 프로토콜을 활용하여 모든 시스템이 동일한 기준 시간에 맞추도록 보정할 수 있다.

하드웨어 차이에 따른 타임스탬프 오차를 보정하기 위한 방법 중 하나는 각 시스템의 하드웨어 클럭 속도를 조정하는 것이다. ROS2는 각 시스템의 클럭을 모니터링하고, 네트워크 상에서 시간 동기화를 유지할 수 있도록 돕는다.

실시간 시스템에서의 타임스탬프 정확도 향상

실시간 시스템에서는 타임스탬프의 정확도가 시스템의 성능에 직접적인 영향을 미친다. 예를 들어, 로봇 시스템에서 여러 센서 데이터가 정확히 동기화되지 않으면, 로봇의 동작에 오차가 발생할 수 있다.

1. 실시간 운영체제 사용

ROS2는 실시간 성능을 보장하기 위해 실시간 운영체제(Real-Time Operating System, RTOS)와의 통합을 지원한다. 실시간 운영체제는 높은 우선 순위의 작업을 빠르게 처리하여 타임스탬프 오차를 줄일 수 있다. 실시간 운영체제는 커널 레벨에서 작업 스케줄링을 제어하며, 이를 통해 타임스탬프 생성 시점과 실제 데이터 발생 시점을 일치시키는 데 도움을 준다.

2. 타이머를 통한 주기적 동기화

ROS2에서 타이머는 노드가 일정한 주기로 작업을 수행할 수 있게 도와주는 메커니즘이다. 타이머는 주기적인 시간 동기화를 지원하며, 실시간 시스템에서는 타이머를 활용해 정확한 시간 간격으로 데이터를 처리할 수 있다.

타이머의 주기는 일반적으로 다음과 같은 식으로 정의된다:

$T_{\text{timer}} = \frac{1}{f_{\text{desired}}}$

여기서: - $T_{\text{timer}}$ 는 타이머 주기를 의미한다. - $f_{\text{desired}}$ 는 원하는 주파수(Hz)이다.

다음은 타이머를 설정하는 코드 예시이다:

auto timer = node->create_wall_timer(
  std::chrono::milliseconds(100), callback_function);

이 코드는 100ms마다 주기적으로 callback_function을 실행한다. 타이머는 주기적인 데이터 처리와 동기화를 위한 중요한 도구이다.

3. 실시간 클럭 사용

실시간 시스템에서 클럭의 정확성도 중요한 요소이다. 실시간 클럭은 일반적으로 벽시계 시간(wall time) 또는 시스템 클럭(system clock)을 기준으로 동작한다. ROS2에서는 시스템 시간과 시뮬레이션 시간을 모두 사용할 수 있으며, 각 클럭 소스를 명확하게 정의하는 것이 중요하다.

시뮬레이션 환경에서는 시뮬레이션 클럭을 사용할 수 있으며, 이를 통해 시뮬레이션 환경에서 발생하는 시간 오차를 최소화할 수 있다.

rclcpp::Time sim_time = node->get_clock()->now();

이 코드는 시뮬레이션 환경에서 노드가 현재 시뮬레이션 시간을 가져오는 예시이다.

시간 동기화와 로봇 시스템

로봇 시스템에서 여러 센서 데이터를 동기화하는 것은 시간 오차를 줄이기 위한 중요한 요소이다. 예를 들어, 로봇의 LiDAR, 카메라, IMU 센서들이 각각 다른 주기로 데이터를 생성하는 경우, 이 데이터를 정확히 동기화하지 않으면 로봇의 위치 추정이나 환경 인식에 오차가 발생할 수 있다.

ROS2는 이러한 센서 데이터 동기화를 위해 message_filters라는 유틸리티를 제공한다. message_filters는 여러 센서의 데이터를 동시에 받아들이고, 이를 동기화된 상태에서 처리할 수 있다.

message_filters를 이용한 센서 동기화

여러 센서 데이터를 동기화하는 예시는 다음과 같다:

#include <message_filters/subscriber.h>
#include <message_filters/time_synchronizer.h>

message_filters::Subscriber<sensor_msgs::msg::Image> image_sub(node, "camera/image", 10);
message_filters::Subscriber<sensor_msgs::msg::LaserScan> scan_sub(node, "scan", 10);

message_filters::TimeSynchronizer<sensor_msgs::msg::Image, sensor_msgs::msg::LaserScan> sync(image_sub, scan_sub, 10);
sync.registerCallback(callback_function);

이 코드는 이미지 데이터와 LiDAR 데이터를 동기화하여 처리하는 방법을 보여준다. TimeSynchronizer는 두 가지 데이터를 동시에 수신하여 동일한 시간 기준으로 동기화한다.

시간 지연을 줄이기 위한 실시간 QoS 설정

ROS2에서 실시간 성능을 극대화하기 위해 QoS 설정을 적절히 적용하는 것이 중요하다. QoS 설정을 통해 메시지 전달의 신뢰성, 시간 제한, 전송 우선순위 등을 제어할 수 있다.

실시간 시스템에서 가장 중요한 QoS 설정은 다음과 같다:

Liveliness: 노드가 활성 상태인지 여부를 확인하며, 노드가 일정 시간 동안 응답하지 않으면 비활성 상태로 간주된다.
Deadline: 메시지가 특정 시간 내에 수신되어야 하는 경우 설정하며, 기한 내에 메시지가 도착하지 않으면 이벤트가 발생한다.
Latency Budget: 메시지 전송에 허용 가능한 최대 지연 시간을 정의한다.

QoS 설정을 활용한 실시간 성능 최적화는 다음과 같은 방식으로 적용할 수 있다:

rclcpp::QoS qos_settings(10);
qos_settings.liveliness(rclcpp::LivelinessPolicy::AUTOMATIC);
qos_settings.deadline(rclcpp::Duration(0, 100000000)); // 100ms 내에 메시지를 받아야 함
qos_settings.latency_budget(rclcpp::Duration(0, 50000000)); // 최대 지연 시간 50ms

이 코드를 통해 노드 간의 통신에서 시간 지연을 최소화할 수 있다.