rclpy 노드를 제대로 종료하려면: rate.sleep() 루프가 rclpy.shutdown() 뒤 ROSInterruptException으로 빠져나오는 시점 계산하기
while rclpy.ok(): 안에서 rate.sleep()으로 10 Hz를 맞추는 제어 노드를 다른 스레드에서 rclpy.shutdown()으로 끄면, 루프는 다음 주기까지 기다린 뒤 빠져나올까, 아니면 바로 깨어날까. Robotics Stack Exchange의 질문 “Actual good way to close nodes”가 묻는 “노드를 깔끔하게 끄는 법”을 가장 흔한 경우로 좁히면 이 질문이 된다. rclpy 노드를 제대로 종료하려면 rate.sleep() 루프가 rclpy.shutdown() 뒤 ROSInterruptException으로 빠져나오는 시점을 계산할 수 있어야 하고, 그 예외가 오류인지 정상 신호인지도 구분해야 한다.
답은 “바로 깨어난다”다. ROS 2 Jazzy(rclpy 7.1.12) 컨테이너에서 5번씩 재 보니 10 Hz든 1 Hz든 셧다운 호출 뒤 1 ms 안팎에 ROSInterruptException이 났다. 그런데 같은 실험에서 Ctrl+C(SIGINT)는 이 경로를 타지 않았다. 메인 스레드의 루프는 KeyboardInterrupt를 받았고, 워커 스레드에 둔 루프는 2초를 기다려도 깨어나지 않았다. 그래서 제목의 계산은 명시적인 rclpy.shutdown()에만 맞는다. 아래에서는 Python 스레드와 예외, node.create_rate()를 써 본 정도의 지식을 전제로 원리를 소스에서 확인하고, 반복 횟수를 손으로 계산한 다음, 실측과 맞춰 보고 종료 코드를 고친다. 소스 기준은 2026년 10월 27일(KST)에 확인한 ros2/rclpy jazzy 브랜치 커밋 4e607c0이다.

rate.sleep()이 실제로 기다리는 것은 깃발 하나다
먼저 용어 몇 개를 맞춘다. 노드(node)는 ROS 2 프로그램의 실행 단위다. 컨텍스트(context)는 rclpy.init()이 켜는 ROS 통신 상태 묶음이고, rclpy.ok()는 그 기본 컨텍스트가 아직 꺼지지 않았는지를 묻는다. 셧다운(shutdown)은 컨텍스트를 무효로 만드는 일이다. 실행기(executor)는 준비된 콜백을 골라 호출하는 일꾼이고, 스핀(spin)은 그 일꾼을 계속 돌리는 일이다. rate.sleep() 루프를 쓰는 노드는 rclpy.spin(node)을 별도 스레드에서 돌려야 틱이 온다.
rate.sleep()을 “100 ms 동안 자는 함수”로 생각하기 쉽지만 rclpy의 Rate는 시계를 직접 읽지 않는다. node.create_rate(10)은 주기 0.1초짜리 타이머를 만들고, Rate는 그 타이머의 콜백 자리에 threading.Event.set을 꽂는다. 이벤트(threading.Event)는 스레드 사이의 깃발이다. set()으로 올리고 wait()로 기다린다. sleep()은 이 깃발이 올라오기만 기다린다(timer.py L118-L177, node.py L1803-L1823).
깃발을 올리는 쪽은 둘이다. 하나는 executor가 실행하는 타이머 콜백으로, 틱(tick, 타이머가 한 주기를 채운 순간)마다 깃발을 올린다. 다른 하나는 셧다운이다. Rate는 생성되자마자 context.on_shutdown()에 자기 종료 함수를 등록해 둔다. 종료 콜백(shutdown callback)은 “셧다운될 때 불러 달라”고 맡겨 둔 함수를 말한다. 알람시계 비유는 여기서 깨진다. 알람은 시간이 되면 혼자 울리지만, Rate의 틱은 spin이 멈추면 오지 않는다. 그 때문에 spin 없이 sleep()이 영원히 멈추는 문제는 rclpy에서 rate.sleep()이 멈추거나 주기가 안 맞을 때에서 따로 다뤘고, 여기서는 루프를 끝내는 쪽만 본다.
셧다운이 깃발을 올리고 예외를 남기는 순서
rclpy.shutdown()은 기본 컨텍스트의 Context.shutdown()을 부른다. 이 함수는 잠금 안에서 먼저 rcl(ROS 2의 C 클라이언트 라이브러리) 수준의 컨텍스트를 끄고, 이어서 등록된 종료 콜백을 차례로 부른다(context.py L117-L166). 콜백 중 하나가 Rate._on_shutdown()이다. 아래는 timer.py를 줄여 옮긴 의사 코드이며 원문 그대로가 아니다.
Rate.__init__: self._timer.callback = self._event.set # 틱마다 깃발
context.on_shutdown(self._on_shutdown) # 셧다운 때 불러 달라고 등록
_on_shutdown: self._is_shutdown = True; self.destroy()
destroy: self._is_destroyed = True; self._event.set() # 셧다운도 깃발을 올린다
_presleep: if _is_shutdown: raise ROSInterruptException() # ① 셧다운 뒤 새로 부른 sleep
if _is_destroyed: raise RuntimeError(...)
sleep: _presleep(); try: _event.wait() finally: _postsleep()
_postsleep: if _is_shutdown: destroy(); raise ROSInterruptException() # ② 자고 있던 sleep
이 순서에서 세 가지가 나온다. 이미 잠든 sleep()은 다음 틱이 아니라 셧다운 콜백이 올린 깃발에 깨어나고, finally의 _postsleep()에서 ROSInterruptException('rclpy.shutdown() has been called')을 던진다(②). 셧다운 뒤에 sleep()을 다시 부르면 _presleep()이 기다리기 전에 같은 예외를 던진다(①). _is_shutdown 검사가 _is_destroyed보다 앞에 있어서 RuntimeError가 아니라 ROSInterruptException이 나온다. 그리고 rcl 셧다운이 콜백보다 먼저이므로, 깨어난 루프가 rclpy.ok()를 보면 이미 False다.
이 예외는 버그가 아니라 의도된 종료 신호다. 공식 테스트 test_shutdown_wakes_rate는 주기가 약 115일인 Rate를 잠재운 스레드가 rclpy.shutdown() 뒤 돌아오는지 확인하는데, 그 스레드는 ROSInterruptException을 잡아 무시한다. 주석에도 “rate.sleep() can raise ROSInterruptException if the context is shutdown while it is sleeping.”이라고 적혀 있다(test_rate.py L115-L137). 반면 Jazzy rclpy Timer API 문서의 Rate.sleep() 설명에는 이 예외가 없다. 동작의 근거는 문서가 아니라 소스와 테스트에 있다.
종료 직전까지 몇 번 돌았는지 계산해 보기
원리를 숫자로 바꿔 본다. 단위는 ms이고, 첫 sleep()이 t=0에 시작하며 틱은 주기의 정수배 시각에 온다고 가정한다. 주파수 f(Hz)인 루프의 주기는 T = 1000 / f다. 셧다운 시각을 s라 하면 셧다운 전에 정상 반환된 sleep() 횟수는 n = ⌊s / T⌋다. s가 틱과 정확히 겹치면 어느 쪽이 먼저인지는 스레드 순서에 달려 있다.
비교를 위해 일부러 틀린 가정 하나를 세운다. “셧다운이 와도 sleep()은 다음 틱까지 기다린다”는 가정이다. rclpy의 실제 동작이 아니라 종료 지연의 크기를 가늠하기 위한 반례다. 이 가정에서 셧다운 뒤 추가 대기는 T·⌈s / T⌉ − s이고, 최악이면 거의 한 주기 전체가 된다. 소스대로라면 깃발이 즉시 올라가므로 이론상 추가 대기는 0이다.
10 Hz 루프를 2350 ms에 끄는 경우를 계산하면 다음과 같다.
- 주기 T = 1000 / 10 = 100 ms
- 정상 반환 n = ⌊2350 / 100⌋ = 23회, 마지막 정상 틱은 2300 ms
- 마지막
sleep()이 셧다운 전까지 이미 기다린 시간 = 2350 − 2300 = 50 ms - 반례 가정의 추가 대기 = 2400 − 2350 = 50 ms, 소스 경로의 추가 대기 = 0 ms(이론값)
같은 시각에 1 Hz 루프라면 정상 반환은 1000 ms와 2000 ms의 2회이고, 반례 가정의 추가 대기는 3000 − 2350 = 650 ms로 커진다. 바퀴 달린 로봇이 0.5 m/s 명령을 받은 채 그 650 ms 동안 마지막 명령을 유지한다고 가정하면 0.5 × 0.65 = 0.325 m를 더 간다. 느린 루프일수록 “다음 틱까지 기다리느냐”가 물리적으로 의미 있는 차이가 되는 이유다. 이 값들은 자체 산술 예제(example.py)의 assertion 8개로 검산했고 결과는 verification.json에 있다. 산술 검산일 뿐 ROS나 로봇을 실행한 결과는 아니다.
직접 풀어 볼 문제 하나. 5 Hz 루프를 1730 ms에 rclpy.shutdown()으로 끄면 정상 반환은 몇 번이고, 반례 가정과 소스 경로의 추가 대기는 각각 얼마일까. T = 1000 / 5 = 200 ms이므로 n = ⌊1730 / 200⌋ = 8회다. 마지막 정상 틱이 1600 ms이고 다음 틱은 1800 ms이므로 반례 가정의 추가 대기는 1800 − 1730 = 70 ms, 소스 경로는 0 ms(이론값)다. 셧다운 뒤에 except 없이 루프가 rate.sleep()을 한 번 더 부른다면 기다리지 않는다. 앞의 의사 코드 ①에서 즉시 같은 예외가 난다.
컨테이너에서 6가지 종료 방식을 5번씩 재 보기
이론값 0 ms가 실제로 얼마인지, Ctrl+C도 같은 길로 가는지는 실행해야 안다. 하네스가 같은 스크립트를 5번 실행했고, 스크립트는 구성마다 새 Python 프로세스를 띄워 시그널 핸들러와 컨텍스트가 섞이지 않게 했다. 시각은 time.monotonic()으로 쟀다. monotonic 시계(단조 시계)는 시스템 시각 조정에 영향받지 않고 앞으로만 가는 시계라서 짧은 간격을 재는 데 쓴다. 기준점 t=0은 node.create_rate() 직후다. Ctrl+C는 터미널 대신 같은 프로세스 안에서 os.kill(os.getpid(), SIGINT)로 흉내 냈다. 시그널(signal)은 운영체제가 프로세스에 보내는 알림이고, 터미널의 Ctrl+C가 보내는 것이 SIGINT다.
측정 환경은 ros:jazzy-ros-base 이미지(고정 다이제스트 ros@sha256:8eed0a4669bbf43ee331878a4c39bd8ebddea8e3312a58b4fae8edb14526b617), Python 3.12.3, rclpy 7.1.12(데비안 패키지 7.1.12-1noble.20260912.162354), 기본 RMW인 rmw_fastrtps_cpp, 네트워크 없음, CPU 1개·메모리 1 GiB다. RMW(ROS middleware, 미들웨어 계층)는 rclpy 아래에서 실제 통신을 맡는 구현이며, 다른 RMW에서는 재지 않았다. 5회 실행 모두 종료 코드 0이었고 구성 6개를 매번 돌렸으니 프로세스 30개분의 기록이다. 재현 스크립트와 실행별 원본 출력은 실험 디렉터리에 있다. 스크립트는 experiment.py, 원본 출력은 results.json이다(스크립트 sha256 5eee79ca9b88b0114fcca6ccbf799b5ebefb546fe3c50ff510fe2b0a3c5b6ad6).
curl -fsSLO https://raw.githubusercontent.com/sungpyo9053/blog/c03fa5198ffcd01128db2c3160bab1cefef6d3ca/experiments/rclpy-close-node-rate-sleep-shutdown-ros-interrupt-exception/experiment.py
docker run --rm --network none --cpus 1 --memory 1g -v "$PWD":/work ros@sha256:8eed0a4669bbf43ee331878a4c39bd8ebddea8e3312a58b4fae8edb14526b617 bash -c "source /opt/ros/jazzy/setup.bash && python3 /work/experiment.py"
정상이면 환경 한 줄과 구성별 JSON 한 줄씩, 모두 7줄이 나오고 종료 코드는 0이다. 아래 표의 왼쪽은 실행 전에 plan.md에 적어 둔 예측, 오른쪽은 5회 실측이다. 지연은 셧다운·시그널을 호출한 시각부터 루프가 끝난 시각까지다.
| 구성 | 계산·예측 | 실측 (5회) |
|---|---|---|
A: 10 Hz, 메인 스레드 루프, 2350 ms에 다른 스레드가 rclpy.shutdown() |
정상 반환 23회, ROSInterruptException, 지연은 0보다 크고 반례 50 ms보다 훨씬 작음 |
23회 5/5, ROSInterruptException 5/5, 지연 0.777–0.837 ms |
| B: 1 Hz, 나머지는 A와 같음 | 2회, 반례 650 ms보다 훨씬 작음 | 2회 5/5, ROSInterruptException 5/5, 지연 0.762–0.83 ms |
| D: 10 Hz, 틱과 겹치는 2400 ms에 셧다운 | 23 또는 24회, 실행마다 다를 수 있음 | 24·24·23·24·23회, ROSInterruptException 5/5, 지연 0.797–1.12 ms |
A·B·D 뒤 rate.sleep() 재호출 |
기다리지 않고 즉시 ROSInterruptException |
15/15 즉시 ROSInterruptException, 막힌 시간 0.019–0.088 ms |
G: 루프를 워커 스레드로, 2350 ms에 rclpy.shutdown() |
즉시 ROSInterruptException |
5/5 ROSInterruptException, 지연 0.818–5.277 ms |
| E: 메인 스레드 루프, 2350 ms에 SIGINT | KeyboardInterrupt, 재호출한 sleep()은 막혔다가 1000 ms 워치독이 깨움 |
KeyboardInterrupt 5/5, 지연 0.188–0.249 ms, 재호출 sleep()은 1000.146–1000.331 ms 막힌 뒤 워치독이 깨움 5/5 |
| F: 워커 스레드 루프, 2350 ms에 SIGINT | 워커의 sleep()이 2000 ms 안에 깨어나지 않음 |
메인 스레드 KeyboardInterrupt 5/5, 워커는 2000 ms 대기 안에 끝나지 않음 5/5, 워치독의 node.destroy_rate(rate) 뒤 끝남(시그널부터 2000.54–2001.655 ms) |
워치독(watchdog)은 측정이 무한히 멈추지 않도록 스크립트가 둔 감시 장치로, 정해진 시간이 지나면 node.destroy_rate(rate)를 불러 잠든 sleep()을 강제로 깨운다.
| 끝난 뒤 상태 | 명시적 셧다운 (A·B·D·G, 20회) | SIGINT (E·F, 10회) |
|---|---|---|
spin 스레드(rclpy.spin)가 끝난 방식 |
정상 반환 | ExternalShutdownException |
rclpy.shutdown() 다시 호출 |
RuntimeError: Context must be initialized before it can be shutdown |
RCLError: failed to shutdown: rcl_shutdown already called on the given context, at ./src/rcl/init.c:333 |
rclpy.try_shutdown() |
예외 없음 | 예외 없음 |
첫 번째 실행의 B·E 줄과 환경 줄을 그대로 옮긴다.
{"env": {"python": "3.12.3", "ros_distro": "jazzy", "rclpy": "7.1.12", "rmw": "default"}}
{"case": "B", "hz": 1, "at_ms": 2350, "action": "shutdown", "loop_thread": "main", "ok_right_after_loop_end": false, "ok_false_at_ms": 2350.987, "resleep_after_end": {"result": "ROSInterruptException", "msg": "rclpy.shutdown() has been called", "blocked_ms": 0.021, "watchdog_fired": false}, "second_shutdown": {"result": "raised", "type": "RuntimeError", "msg": "Context must be initialized before it can be shutdown"}, "try_shutdown": {"result": "ok", "returned": "None"}, "spin_thread": {"alive": false, "end": "returned", "t_ms": 2351.387}, "trigger": {"t_call_ms": 2350.202, "t_return_ms": 2350.847}, "normal_returns": 2, "return_times_ms": [1000.699, 2000.613], "returns_after_trigger_ms": [], "loop_end": {"how": "ROSInterruptException", "msg": "rclpy.shutdown() has been called", "t_ms": 2350.964}, "trigger_to_loop_end_ms": 0.762, "trigger_to_spin_end_ms": 1.185, "max_abs_tick_error_ms": 0.699, "child_exit": 0, "child_wall_ms": 2605.2, "child_stderr_traceback": false}
{"case": "E", "hz": 10, "at_ms": 2350, "action": "sigint", "loop_thread": "main", "ok_right_after_loop_end": true, "ok_false_at_ms": 2351.499, "resleep_after_end": {"result": "returned", "blocked_ms": 1000.331, "watchdog_fired": true}, "second_shutdown": {"result": "raised", "type": "RCLError", "msg": "failed to shutdown: rcl_shutdown already called on the given context, at ./src/rcl/init.c:333"}, "try_shutdown": {"result": "ok", "returned": "None"}, "spin_thread": {"alive": false, "end": "ExternalShutdownException", "t_ms": 2350.517}, "trigger": {"t_call_ms": 2350.131, "t_return_ms": 2350.19}, "normal_returns": 23, "return_times_ms": [100.652, 200.575, 300.554, 400.563, 500.6, 600.553, 700.55, 800.58, 900.558, 1000.562, 1100.543, 1200.542, 1300.548, 1400.575, 1500.561, 1600.573, 1700.526, 1800.556, 1900.556, 2000.577, 2100.557, 2200.564, 2300.582], "returns_after_trigger_ms": [], "loop_end": {"how": "KeyboardInterrupt", "msg": "", "t_ms": 2350.33}, "trigger_to_loop_end_ms": 0.199, "trigger_to_spin_end_ms": 0.386, "max_abs_tick_error_ms": 0.652, "child_exit": 0, "child_wall_ms": 3606.8, "child_stderr_traceback": false}
B 줄에서 1 Hz 루프의 정상 반환은 1000.699 ms와 2000.613 ms 두 번이고, 2350.202 ms에 부른 셧다운 뒤 0.762 ms 만에 루프가 끝났다. 반례 가정의 650 ms와 비교하면 다음 틱을 기다리지 않았다는 뜻이다. 계산의 전제였던 “틱은 주기의 정수배에 온다”도 대체로 맞았다. 정상 반환 시각과 이상적 틱 시각의 차이는 A·B·D·E·F에서 최대 1.387 ms였고, G는 한 실행에서 15.212 ms까지 벌어졌다.
D가 23회와 24회로 갈린 것도 예측 범위 안이다. 24회였던 세 번은 2400 ms 틱의 반환(2400.552–2400.575 ms)이 셧다운 호출(2400.598–2400.629 ms)보다 먼저 찍혔고, 23회였던 두 번은 셧다운 호출이 2400.117 ms와 2400.121 ms로 틱 반환보다 먼저 들어갔다. 경계에서는 몇 번 돌았는지보다 “어느 쪽이든 1 ms 안팎에 끝난다”가 더 쓸모 있는 결론이다.
E에서 KeyboardInterrupt를 받은 직후 rclpy.ok()가 아직 True였던 실행이 5번 중 2번 있었다. 그 두 번도 ok()는 2351.457 ms와 2351.499 ms에 False가 됐다.
예측과 다르게 나온 값은 rclpy.shutdown() 재호출의 예외 종류 하나다. 리서치 단계에서는 C++ 쪽 Context::shutdown() 소스를 근거로 이미 꺼진 컨텍스트면 RCLError가 날 것으로 봤는데, 그 오류는 SIGINT 쪽에서만 나왔고 명시적 셧다운 뒤에는 RuntimeError가 났다. 메시지가 왜 다른지는 이번에 소스 줄로 확인하지 않았다. 나머지 값은 실행 전 예측대로 나왔다.
이 실험은 컨테이너 안의 rclpy 프로세스만 다룬다. 시뮬레이터나 실물 로봇을 돌린 결과가 아니며, 1 CPU 환경의 ms 값이 다른 기기에서 같다고 볼 근거도 없다. 다만 “다음 틱을 기다리지 않는다”는 판단은 가장 느린 실행의 지연도 반례 가정의 추가 대기보다 훨씬 작았다는 데서 나오므로, 기기가 달라도 쉽게 뒤집히지 않을 것으로 본다.
Ctrl+C는 종료 콜백을 건너뛴다
표의 E·F가 A·G와 다른 이유는 rclpy의 시그널 처리에 있다. rclpy.init()은 기본 컨텍스트에 SIGINT·SIGTERM 핸들러를 설치한다(init.py L65-L93). SIGINT가 오면 이 핸들러는 원래 있던 핸들러를 먼저 부르고, 별도 시그널 처리 스레드를 깨운다. Python의 원래 핸들러가 KeyboardInterrupt를 만든다. 시그널 처리 스레드는 등록된 컨텍스트마다 C 수준의 rcl_shutdown()만 호출한다(signal_handler.cpp L306-L320, L141-L155). Python의 Context.shutdown()을 거치지 않으니 Rate._on_shutdown도 불리지 않는다. 2020년에 열린 rclpy 이슈 #532 “rclpy Context.on_shutdown callbacks are not called when Ctrl-C is pressed”가 이 동작을 보고하며, 2026년 10월 27일 확인 기준으로 열려 있다.

메인 스레드 루프가 Ctrl+C에 깨어난 것은 Rate 덕분이 아니다. Python 시그널 핸들러는 항상 메인 스레드에서 실행되고(Python signal 문서), 그 핸들러가 던진 KeyboardInterrupt가 Event.wait()를 끊었다. 같은 이유로 워커 스레드의 sleep()에는 아무도 깃발을 올려 주지 않는다. spin 스레드는 컨텍스트가 꺼진 것을 보고 ExternalShutdownException으로 끝났으니 틱도 더는 오지 않는다. F에서 워커가 2초 동안 그대로 있다가 node.destroy_rate(rate) 뒤에야 끝난 것이 이 상황이다. destroy_rate()는 Rate.destroy()를 불러 깃발을 올리지만 _is_shutdown은 그대로라서 sleep()은 예외 없이 반환하고, 루프는 while rclpy.ok() 조건에서 빠져나왔다.
Ctrl+C 뒤 rclpy.shutdown()이 RCLError를 낸 것도 같은 흐름이다. 시그널 처리 스레드가 이미 rcl_shutdown()을 했기 때문이다. rclpy.try_shutdown()은 ok()가 True일 때만 셧다운을 하므로 조용히 지나간다(context.py L117-L166). 같은 이유로 Ctrl+C 뒤에 try_shutdown()을 불러도 워커의 Rate는 깨어나지 않는다고 소스상 판단된다. 이번 실험에서는 그 조합을 따로 재지 않았다.
워커 스레드의 생존을 확인하는 코드에도 함정이 하나 있었다. 실험 스크립트를 시험 실행하던 단계에서, 메인 스레드가 worker.join(0.05) 안에서 SIGINT로 KeyboardInterrupt를 받으면 Python 3.12.3의 threading 구현이 아직 살아 있는 워커를 멈춘 것으로 표시해 is_alive()가 False를 돌려줬다. 루프 종료 기록은 비어 있는데 스레드는 끝났다고 나오는 모순이었다. 그래서 최종 스크립트는 워커 루프가 finally에서 직접 set하는 threading.Event로 종료를 판정한다. rclpy가 아니라 Python 표준 라이브러리의 동작이지만, Ctrl+C 처리 코드에서 join()과 is_alive()로 워커 상태를 믿으면 같은 착각을 할 수 있다.
루프와 spin 스레드에서 각각 잡을 것
실측에서 실제로 돌아간 루프는 다음과 같다. experiment.py의 loop() 함수에서 예상 밖 예외를 기록하는 except BaseException과 finally 블록만 빼고 옮겼다.
try:
while rclpy.ok():
rate.sleep()
returns.append(ms())
loop_end["how"] = "rclpy.ok()==False"
except (ROSInterruptException, KeyboardInterrupt) as exc:
loop_end.update(how=type(exc).__name__, msg=str(exc)[:160])
try가 while 바깥에 있다는 점이 중요하다. 명시적 셧다운이면 ROSInterruptException이, 메인 스레드에서 Ctrl+C를 받으면 KeyboardInterrupt가 루프를 통째로 끝낸다. 반대로 루프 본문 안에서 KeyboardInterrupt를 잡고 계속 돌게 만들면, E에서 본 것처럼 그 직후 rclpy.ok()가 아직 True일 수 있고 다음 sleep()은 깃발이 오지 않아 막힌다(E의 재호출이 워치독 전까지 약 1초 막힌 것과 같은 상태). 이 부분은 실측 두 가지를 이어 붙인 해석이다.
이를 바탕으로 한 종료 구조는 다음과 같다. 이 블록 전체를 이 형태로 실행하지는 않았다. 각 except가 받는 예외는 위 실측과 Jazzy 공식 데모 talker.py L39-L50의 except (KeyboardInterrupt, ExternalShutdownException) + finally: node.destroy_node(); rclpy.try_shutdown() 패턴에서 가져왔다.
# 구조 예시(이 형태 그대로는 미실행): 루프는 메인 스레드, spin은 보조 스레드
import threading
import rclpy
from rclpy.exceptions import ROSInterruptException
from rclpy.executors import ExternalShutdownException
def spin_quietly(node):
try:
rclpy.spin(node)
except ExternalShutdownException: # Ctrl+C로 컨텍스트가 꺼졌을 때 spin이 받는 예외
pass
def main():
rclpy.init()
node = rclpy.create_node("control_loop")
threading.Thread(target=spin_quietly, args=(node,), daemon=True).start()
rate = node.create_rate(10)
try:
while rclpy.ok():
# 센서 읽기·명령 계산
rate.sleep()
except (ROSInterruptException, KeyboardInterrupt):
pass # 명시적 셧다운과 Ctrl+C 모두 정상 종료 신호
finally:
node.destroy_node()
rclpy.try_shutdown() # 이미 꺼졌으면 조용히 지나간다
if __name__ == "__main__":
main()
finally에 rclpy.shutdown()이 아니라 rclpy.try_shutdown()을 둔 것은 위 표 때문이다. 어느 경로로 끝났든 shutdown() 재호출은 30회 모두 예외를 냈고 try_shutdown()은 30회 모두 조용히 지나갔다. spin 스레드를 daemon=True로 둔 것은 Ctrl+C 뒤 프로세스가 그 스레드를 기다리지 않게 하려는 선택인데, Python threading 문서는 daemon 스레드가 종료 시 갑자기 멈추며 자원이 제대로 해제되지 않을 수 있다고 경고한다. spin 스레드에서 파일이나 장치 핸들을 다룬다면 이 선택을 다시 봐야 한다.
루프를 꼭 워커 스레드에 둬야 한다면 Ctrl+C로는 깨어나지 않는다는 F의 결과를 전제로 설계해야 한다. 이번 실측에서 워커를 깨운 것은 메인 스레드가 부른 node.destroy_rate(rate)였고 5번 모두 그 뒤에 루프가 끝났다. 메인 스레드에서 KeyboardInterrupt를 받으면 destroy_rate()를 부르는 방식이 한 가지 방법이지만, 이 경우 워커는 예외 없이 rclpy.ok() 조건으로 빠져나온다는 점을 루프 코드가 알고 있어야 한다.
자주 묻는 질문
rclpy.shutdown()을 부르면 rate.sleep() 루프는 다음 주기까지 기다리나?
기다리지 않는다. Rate가 등록해 둔 종료 콜백이 깃발을 바로 올려서, Jazzy 실측에서는 10 Hz와 1 Hz 모두 셧다운 호출 뒤 1 ms 안팎에 ROSInterruptException이 났다.
종료할 때 나는 ROSInterruptException은 오류인가?
버그가 아니라 의도된 종료 신호다. 공식 테스트 test_shutdown_wakes_rate도 이 예외를 잡아 무시하므로, 루프 바깥의 try에서 정상 신호로 잡아 두면 된다.
Ctrl+C를 누르면 rate.sleep() 루프는 어떻게 끝나나?
명시적 셧다운과 다른 경로를 탄다. 메인 스레드 루프는 KeyboardInterrupt를 받았고, 워커 스레드에 둔 루프는 2초를 기다려도 깨어나지 않아 node.destroy_rate(rate) 뒤에야 끝났다. rclpy의 시그널 처리가 C 수준의 rcl_shutdown()만 호출해 종료 콜백을 건너뛰기 때문이다.
finally에서 rclpy.shutdown() 대신 try_shutdown()을 쓰는 이유는?
실측에서 rclpy.shutdown() 재호출은 30회 모두 예외를 냈다(명시적 셧다운 뒤 RuntimeError, SIGINT 뒤 RCLError). rclpy.try_shutdown()은 30회 모두 조용히 지나갔다.
셧다운이 바로 되면 로봇도 바로 멈추나?
보장하지 않는다. 이 결과는 Python 루프가 언제 빠져나오는지에 대한 것이고 바퀴가 언제 멈추는지에 대한 것이 아니다. 실물 정지는 diff_drive_controller의 cmd_vel_timeout(기본값 0.5초) 같은 하위 계층 장치에 맡기고, 쓰는 드라이버에 이런 타임아웃이 꺼져 있지 않은지 먼저 확인한다.
실물 로봇에서는 이 계산이 정지를 보장하지 않는다
위 결과는 Python 루프가 언제 빠져나오는지에 대한 것이고, 바퀴가 언제 멈추는지에 대한 것이 아니다. 0.325 m는 “드라이버가 마지막 명령을 계속 유지한다”는 가정에서 나온 환산이며 실물로 잰 값이 아니다. 셧다운 뒤에도 마지막 정지 명령을 publish할 수 있는지는 확인하지 않았다. 정지 명령을 보내야 한다면 컨텍스트가 살아 있을 때, 즉 셧다운 전에 보내는 쪽으로 설계해야 할 것으로 보지만 이 역시 검증하지 않은 설계 고려다.
실물 정지는 Python 종료 처리가 아니라 하위 계층의 장치에 맡긴다. 예를 들어 ros2_controllers Jazzy의 diff_drive_controller에는 cmd_vel_timeout 파라미터가 있다. 기본값은 0.5초이며, 받은 cmd_vel 명령이 그보다 오래되면 바퀴 명령을 0으로 바꾸고 “Velocity command timed out. Braking.” 경고를 낸다(diff_drive_controller_parameter.yaml L94-L98, diff_drive_controller.cpp L120-L133). 소스로 확인한 사실이고 실물 실험은 아니다. 쓰는 드라이버에 이런 타임아웃이 있는지, 0으로 꺼져 있지 않은지 먼저 확인한다. 처음 시험할 때는 바퀴를 바닥에서 띄우거나 저속으로 돌리고, 하드웨어 비상 정지(E-stop) 스위치에 손이 닿는 곳에서 한다.
이번 측정이 다루지 않은 범위도 남아 있다. SIGTERM(kill 명령의 기본 시그널)은 rclpy.init()이 같이 처리하지만 따로 재지 않았고, 터미널에서 프로세스 그룹 전체로 가는 실제 Ctrl+C도 os.kill로 흉내 낸 것과 완전히 같다고 보장하지 않는다. Rolling 이후의 with rclpy.init(): 컨텍스트 매니저 경로 역시 이 글의 Jazzy 근거로는 판단하지 않았다. Jazzy에서 메인 스레드에 rate.sleep() 루프를 두는 노드라면, 종료 때 보이는 ROSInterruptException은 정상 신호로 잡아 두고 Ctrl+C의 KeyboardInterrupt와 spin 스레드의 ExternalShutdownException을 함께 처리한 뒤 try_shutdown()으로 마무리하면 된다. 워커 스레드 루프를 쓰고 있다면 Ctrl+C 한 번에 실제로 빠져나오는지부터 확인한다.