LAB 05 · 스마트 교차로

교차로 셔틀 토픽 받기

내 PC에서 자율주행 셔틀 노드를 켜고 로봄 연결기로 잇습니다. 교차로의 신호 제어기가 지금 신호를 토픽 /crossroad/signal로 계속 방송하고, 내 셔틀 노드는 그 신호를 받아 두었다가 자기 주기(1초에 5번)로 주행 명령 /crossroad/cmd_vel을 냅니다. 구독 콜백은 값을 받아 두고, 타이머가 그 값으로 일하는 모양입니다.

연결 순서

누가 무엇을 하나 신호등 단추 · 「확인 시작」 → 로봄 서버 → 연결기(신호 퍼블리셔, 0.5초마다 다시 보냄) → /crossroad/signal → 내 노드(신호 구독자)

돌아오는 길 내 노드(명령 퍼블리셔, 1초에 5번) → /crossroad/cmd_vel → 연결기(명령 구독자) → 로봄 서버 → 교차로의 셔틀 · 과제 줄

내 PC에서 직접 확인하는 명령(노드와 연결기가 켜진 뒤):

ros2 topic info -v /crossroad/signal
ros2 topic echo /crossroad/cmd_vel
ros2 node info /robom_crossroad_sim
  1. ROS 2 환경 확인

    Ubuntu 24.04 + ROS 2 Jazzy가 필요합니다. 윈도우는 WSL의 Ubuntu에서 합니다. 아래를 차례로 쳐서 jazzy와 메시지 형식(Vector3 linear · Vector3 angular)이 나오면 됩니다. std_msgs · geometry_msgs는 ROS 2에 늘 들어 있어 따로 깔 것이 없습니다.

    source /opt/ros/jazzy/setup.bash
    printenv ROS_DISTRO
    ros2 interface show geometry_msgs/msg/Twist
  2. 연결기 · 연습 노드 내려받기

    로봄 연결기 내려받기 (robom_link.py)

    판 4 · SHA-256 5d4b39f350347fdff1770652a149b9f9549ddeae195802dcbe29c7a71a3eaa22

    이 실습실은 연결기 판 4 이상이어야 합니다. 받은 파일이 맞는지는 sha256sum robom_link.py로 견줘 봅니다.

    연습 교차로 셔틀 노드 내려받기 (robom_crossroad_sim.py)

    판 2 · SHA-256 6b63dd7b611ac607dd69de9583415fa97f90161c38b02b23aa9385bf0c190cc5

    연습 노드는 구독 · 타이머 · 발행 뼈대가 다 되어 있고, 신호별 속도를 고르는 decide()가 「# 할 일」로 비어 있습니다(그대로 켜면 늘 0.0이라 과제를 통과하지 못합니다): python3 robom_crossroad_sim.py. ROS 2 없이 네트워크만 먼저 볼 때는 연결기의 --demo를 씁니다(연습 모드라서 확인받기는 되지 않습니다).

  3. 연결 열쇠 받기

    열쇠는 로그인한 학생만 받습니다.

    로그인하고 열쇠 받기

  4. 파일 둘러보기

    켜기 전에 내려받은 두 파일이 무엇을 하는지 봅니다. 그림의 화살표를 누르면 그 일을 하는 코드가 아래에서 밝아집니다.

    연결기와 연습 노드 둘러보기

    1 · 한 장 그림

    내 PC
    내 노드robom_crossroad_sim.py
    연결기robom_link.py
    로봄 사이트
    로봄 서버열쇠 · 판정
    지도이 화면

    2 · 연결기 둘러보기 robom_link.py

    연결기는 이 실습실에서 아래 8곳을 씁니다. 내 PC의 ROS 2 쪽에서는 퍼블리셔 · 구독자 · 서비스 · 액션 · 파라미터 클라이언트 노릇을, 사이트 쪽에서는 HTTP로 묻고 올리는 노릇을 합니다.

    1. 1 허용 목록 52번째 줄부터

      /crossroad/signal(보내기)과 /crossroad/cmd_vel(지켜보기)이 이 표에 있어야 연결기가 다룹니다.

      # ── 판 4 허용 목록 (바로잡기 명세 1-2절) ── 서버(app/link/state.py)의 목록과 같아야 한다. 목록 밖은 연결기가 거절한다.
      INTERFACES = "robom_interfaces"
      SERVICES = {"/shuttle/arrival": "robom_interfaces/srv/ShuttleEta"}  # 셔틀 정류장
      ACTIONS = {"/cafe/brew": "robom_interfaces/action/Brew"}  # 바리스타 로봇
      PUBLISH_TOPICS = {  # 사이트가 보내 달라고 할 수 있는 토픽
          "/crossroad/signal": "std_msgs/msg/String",
          "/farm/moisture": "std_msgs/msg/Float64",
      }
      REPEAT_TOPICS = ("/crossroad/signal",)  # 다음 값이 올 때까지 같은 값을 다시 보낸다(교차로가 신호를 계속 방송하는 장면)
      REPEAT_EVERY = 0.5
      WATCH_TOPICS = {  # 켜질 때 모두 구독해 두고, 받은 것을 1초에 한 번 모아 올린다
          "/shuttle/position": "std_msgs/msg/Float64",
          "/crossroad/cmd_vel": "geometry_msgs/msg/Twist",
          "/energy/robot_status": "std_msgs/msg/Header",
          "/farm/water": "std_msgs/msg/Bool",
      }
      PARAM_NODES = ("/robom_farm",)  # 파라미터를 읽고 바꿀 수 있는 노드
      DRONE_TOPICS = {  # 드론(3차부터 그대로)
          "/drone/pose": "geometry_msgs/msg/PoseStamped",
          "/drone/battery": "sensor_msgs/msg/BatteryState",
          "/drone/command": "std_msgs/msg/String",
      }
    2. 2 명령 받기 273번째 줄부터

      HTTP로 기다렸다가 서버가 보낸 「신호 보내기」 요청을 받아 ROS 2 쪽으로 넘깁니다.

      def command_loop(self) -> None:
          tries = 0
          while not self.stop.is_set():
              try:
                  commands = self.server.wait_commands()
                  tries = 0
              except KeyExpired:
                  self._expired()
                  return
              except ServerSaid as error:
                  say(error.args[0])
                  self.stop.wait(1.0)
                  continue
              except (urllib.error.URLError, OSError):
                  tries = self._retry(tries, "받기")
                  continue
              for line in commands:
                  if isinstance(line, str):  # 판 1 모양(서버가 판 머리를 못 본 때)
                      line = {"kind": "drone", "command": line}
                  if not isinstance(line, dict):
                      continue
                  kind = line.get("kind")
                  if kind == "drone" and line.get("command") in ("start", "stop"):
                      say(f"명령 받음: {line['command']}")
                      self.on_command(line["command"])
                  elif kind in REQUEST_KINDS and isinstance(line.get("id"), str):
                      what = line.get("name") or line.get("topic") or ""
                      say(f"요청 받음: {kind} {what}".rstrip())
                      self.on_request(line)
    3. 3 지켜본 메시지 올리기 305번째 줄부터

      구독해서 받은 셔틀 명령을 1초에 한 번 모아 서버로 올립니다.

      def watch_loop(self) -> None:
          """지켜본 메시지를 WATCH_EVERY초에 한 번 모아 올린다(판 3). 받은 것이 없으면 보내지 않는다."""
          tries = 0
          while not self.stop.wait(WATCH_EVERY):
              batch = self._take_watched()
              if not batch:
                  continue
              try:
                  self.server.report({"kind": "topic_watch", "messages": batch})
                  tries = 0
              except KeyExpired:
                  self._expired()
                  return
              except ServerSaid as error:
                  say(error.args[0])
                  if error.status == 429:  # 속도 제한: 묶음을 되돌려 두고 다음 차례에 함께 보낸다(모양 오류는 버린다)
                      self._put_back(batch)
              except (urllib.error.URLError, OSError):
                  tries = self._retry(tries, "지켜본 메시지 올리기")
    4. 4 보낼 토픽 퍼블리셔 686번째 줄부터

      첫 신호를 놓치지 않게 켤 때 /crossroad/signal 퍼블리셔를 미리 만듭니다.

      # 보낼 토픽의 퍼블리셔는 켤 때 미리 만든다(처음 보낸 메시지를 구독자가 놓치지 않게)
      self.publishers = {topic: node.create_publisher(self._need(t), self.prefix + topic, 10) for topic, t in PUBLISH_TOPICS.items()}
    5. 5 지켜볼 토픽 구독 690번째 줄부터

      켤 때 /crossroad/cmd_vel을 구독해 둡니다.

      for topic, type_name in WATCH_TOPICS.items():
          node.create_subscription(self._need(type_name), self.prefix + topic, self._watcher(topic, type_name), 10)
    6. 6 받은 메시지 담기 750번째 줄부터

      받은 Twist를 칸 이름이 붙은 값으로 바꿔 올릴 묶음에 넣습니다.

      def _watcher(self, topic: str, type_name: str):
          def on_message(message) -> None:
              data = to_plain(type_name, message)
              if data is not None:
                  self.link.watch(topic, data)
      
          return on_message
    7. 7 토픽 보내기 790번째 줄부터

      여기서 서버가 보낸 신호를 /crossroad/signal로 내보냅니다.

      def _publish(self, line: dict) -> None:
          topic = line["topic"]
          value = line["data"]["data"]
          message = self._type(PUBLISH_TOPICS[topic])(data=float(value) if PUBLISH_TOPICS[topic].endswith("Float64") else value)
          self.publishers[topic].publish(message)
          if topic in REPEAT_TOPICS:
              self.repeat[topic] = [message, time.monotonic() + REPEAT_EVERY]
          self.link.report({"id": line["id"], "kind": "topic_published"})
    8. 8 신호 다시 보내기 815번째 줄부터

      교차로가 신호를 계속 방송하듯 다음 신호가 올 때까지 같은 신호를 0.5초마다 다시 보냅니다.

      now = time.monotonic()
      for topic, item in self.repeat.items():
          if now >= item[1]:
              self.publishers[topic].publish(item[0])
              item[1] = max(item[1] + REPEAT_EVERY, now)

    3 · 연습 노드 읽기 robom_crossroad_sim.py

    파일 전체입니다(표지 주석 줄만 뺐습니다). 그대로 두는 뼈대는 어두운 바탕, 내가 채우거나 고칠 줄(「# 할 일」 주석과 그 자리의 코드)은 노란 바탕이고, 「# 할 일」 옆에 그 과제 이름이 있습니다.

    #!/usr/bin/env python3"""로봄 연습 교차로 셔틀 노드 — 신호를 받아 두고 자기 주기로 주행 명령을 내는 ROS 2 노드(뼈대).쓰는 법 (Ubuntu 24.04 + ROS 2 Jazzy):    source /opt/ros/jazzy/setup.bash    python3 robom_crossroad_sim.py    # 다른 터미널에서 연결기를 켠다: python3 robom_link.py --key <연결 열쇠>장면: 교차로의 신호 제어기가 지금 신호를 계속 방송한다(연결기가 0.5초마다 다시 보낸다). 셔틀은 받은 신호를 기억해 두고,자기 타이머로 1초에 5번 주행 명령을 낸다.- 구독자: /crossroad/signal(std_msgs/msg/String, red · yellow · green)을 받아 마지막 신호를 저장해 둔다.- 퍼블리셔: 타이머가 1초에 5번 /crossroad/cmd_vel(geometry_msgs/msg/Twist)을 낸다. linear.x는 decide()가 고른다.- --ns <이름>: 토픽 이름 앞에 이름 공간을 붙인다(/<이름>/crossroad/signal). 연결기의 --ns와 같은 이름을 쓴다.연결 · 구독 · 타이머 · 발행 뼈대는 다 되어 있습니다. 「# 할 일」 자리를 채워 완성하세요. 이 파일을 고쳐 가며 배우세요.그대로 켜면 셔틀이 신호와 상관없이 늘 서 있어(linear.x 0.0) 교차로 과제를 통과하지 못합니다.파이썬 표준 라이브러리와 ROS 2에 들어 있는 rclpy · std_msgs · geometry_msgs만 쓴다(따로 설치할 것이 없다)."""import argparseimport reimport sysVERSION = "2"SEND_PER_SECOND = 5  # 주행 명령을 내는 횟수(1초에)def say(text: str) -> None:    print(text, flush=True)

    속도 고르기 내가 채움 과제 1 · 신호 받기, 과제 2 · 신호에 맞게 움직이기

    받아 둔 신호로 셔틀 속도를 고르는 자리로, ROS 2와 상관없는 계산입니다.

    def decide(signal: str | None) -> float:    """받아 둔 신호(아직 받은 신호가 없으면 None)로 셔틀 속도(linear.x)를 고른다(ROS 2와 상관없는 계산)."""    # 할 일: 신호별 속도. 초록(green)이면 0.5, 노랑(yellow)이면 0.2, 빨강(red)이면 0.0을 돌려주세요.과제 1 · 신호 받기, 과제 2 · 신호에 맞게 움직이기    #        모르는 신호이거나 아직 받은 신호가 없으면 서 있어야 합니다(0.0).    return 0.0
    def run(namespace: str) -> None:    # rclpy와 메시지 형식은 여기서만 불러온다.    import rclpy    from geometry_msgs.msg import Twist    from rclpy.node import Node    from std_msgs.msg import String

    노드와 퍼블리셔 뼈대

    노드를 만들고, 받은 신호를 둘 곳과 주행 명령을 낼 퍼블리셔를 만듭니다.

        prefix = f"/{namespace}/crossroad" if namespace else "/crossroad"    rclpy.init()    node = Node("robom_crossroad_sim")    state = {"signal": None}  # 마지막으로 받은 신호(구독 콜백이 저장하고 타이머 콜백이 읽는다)    command = node.create_publisher(Twist, prefix + "/cmd_vel", 10)  # 주행 명령을 낼 토픽

    신호 받아 두기 뼈대

    구독 콜백으로, 신호가 올 때마다 저장만 합니다.

        def on_signal(message) -> None:        # 구독 콜백: 신호 메시지가 올 때마다 불린다(신호 제어기가 0.5초마다 다시 보낸다). 여기서는 저장만 한다.        if message.data != state["signal"]:            say(f"신호 바뀜: {state['signal']} → {message.data}")        state["signal"] = message.data

    주행 명령 내기 뼈대

    타이머 콜백으로, 저장해 둔 신호로 속도를 골라 Twist를 냅니다.

        def drive() -> None:        # 타이머 콜백: 1초에 SEND_PER_SECOND번 불린다. 저장해 둔 신호로 속도를 골라 Twist를 낸다(다른 칸은 0).        twist = Twist()        twist.linear.x = float(decide(state["signal"]))        command.publish(twist)

    구독 · 타이머 걸고 돌리기 뼈대

    신호 구독과 1초에 5번 부를 타이머를 걸고 노드를 돌립니다.

        node.create_subscription(String, prefix + "/signal", on_signal, 10)    node.create_timer(1.0 / SEND_PER_SECOND, drive)    say(f"로봄 연습 교차로 셔틀 노드 판 {VERSION} · 받음 {prefix}/signal · 냄 {prefix}/cmd_vel(1초에 {SEND_PER_SECOND}번)")    try:        rclpy.spin(node)  # 신호가 오면 on_signal(), 주기마다 drive()가 불린다    except KeyboardInterrupt:        say("연습 교차로 셔틀 노드를 끕니다")    finally:        node.destroy_node()        if rclpy.ok():            rclpy.shutdown()
    def main(argv=None) -> int:    parser = argparse.ArgumentParser(prog="robom_crossroad_sim.py", description="로봄 연습 교차로 셔틀 노드 판 " + VERSION)    parser.add_argument("--ns", default="", help="토픽 이름 공간(예: car1 → /car1/crossroad/signal)")    args = parser.parse_args(argv)    if args.ns and not re.fullmatch(r"[A-Za-z][A-Za-z0-9_]{0,31}", args.ns):        say("--ns는 영문자로 시작하는 32자 안의 영문 · 숫자 · _만 됩니다")        return 2    try:        run(args.ns)    except ImportError:        say("ROS 2(rclpy)를 찾지 못했습니다. source /opt/ros/jazzy/setup.bash 를 먼저 하세요")        return 2    return 0if __name__ == "__main__":    sys.exit(main())

    지도로 가기

  5. 연결기 켜기

    연결기 파일이 있는 폴더에서 실행합니다. 연결기가 붙으면 교차로의 신호등 단추와 「확인 시작」을 누를 수 있습니다.

스마트 교차로 · 신호등과 셔틀

연결 안 됨
↓ 휴머노이드 공장 · 준비 중

/crossroad/signal · 서버가 보낸 신호

  1. 아직 보낸 신호가 없습니다

/crossroad/cmd_vel · 셔틀 명령(linear.x)

  1. 아직 받은 명령이 없습니다

연결기가 붙으면 누를 수 있습니다.

단추를 누르면 서버가 신호를 연결기로 보내고, 연결기가 내 PC의 /crossroad/signal에 보낸 뒤 다음 신호가 올 때까지 0.5초마다 다시 보냅니다. 내 노드가 /crossroad/cmd_vel로 낸 명령은 연결기가 1초에 한 번 모아 사이트로 올립니다(시각은 내 PC 시계). 셔틀은 받은 linear.x만큼 움직입니다.

세 색이 모두 든 무작위 신호 7번을 보냅니다(다음 신호는 앞 신호가 닿고 1.6 ~ 2.8초 뒤). 판정은 이 확인으로만 합니다.

과제 칸

통과 0/2

두 과제는 적는 답이 없습니다. 서버가 「확인 시작」으로 보낸 신호와 받은 셔틀 명령만 보고 판정합니다. 신호마다 닿고 1 ~ 1.5초 사이의 명령을 보고, 규칙은 초록 0.5 · 노랑 0.2 · 빨강 0.0(다른 칸은 0)입니다. 확인이 3번 이어서 맞아야 통과하고, 망이 늦어 판정하지 못한 확인은 세지 않습니다(세지 않은 확인이 두 번 이어지면 처음부터 다시 셉니다).

과제 1 · 신호 받기

스마트 교차로의 신호 제어기가 지금 신호를 계속 방송합니다. 셔틀은 그 신호를 받아 두고 자기 주기로 주행 명령을 내야 교차로가 셔틀을 믿을 수 있습니다.

내 PC의 셔틀 노드가 /crossroad/signal (std_msgs/msg/String, red · yellow · green)을 구독해 받은 신호를 기억해 두고, 타이머로 1초에 5번 /crossroad/cmd_vel (geometry_msgs/msg/Twist)을 내게 하세요. 「확인 시작」을 누르면 서버가 세 색이 모두 든 신호 7번을 보냅니다(다음 신호는 앞 신호가 닿고 1.6 ~ 2.8초 뒤). 신호마다 닿고 1 ~ 1.5초 사이의 명령을 봅니다. 같은 색 뒤의 명령은 늘 같고, 빨강 뒤와 초록 뒤의 명령이 서로 다르면 그 확인이 맞습니다. 확인이 3번 이어서 맞으면 「확인받기」로 통과합니다.

로그인하고 연결 열쇠로 연결기를 켜면 서버가 받은 명령으로 판정합니다

힌트 보기
  • 연습 셔틀 노드(robom_crossroad_sim.py)를 먼저 켜고, 다른 터미널에서 연결기를 켭니다. 두 터미널 모두 source /opt/ros/jazzy/setup.bash를 먼저 합니다.
  • 구독 콜백은 받은 신호를 저장만 하고, 타이머 콜백이 저장한 신호로 속도를 골라 냅니다. 연습 노드는 decide()가 늘 0.0을 돌려줍니다.
  • ros2 topic echo /crossroad/signal 로 신호가 PC에 닿는지, ros2 topic echo /crossroad/cmd_vel 로 셔틀 명령이 바뀌는지 볼 수 있습니다.

과제 2 · 신호에 맞게 움직이기

셔틀이 신호와 상관없이 달리면 교차로가 위험해집니다. 초록에는 가고, 노랑에는 천천히, 빨강에는 서야 합니다.

/crossroad/cmd_vel의 linear.x를 받은 신호에 맞게 고르세요. 초록 0.5 · 노랑 0.2 · 빨강 0.0이고, 다른 칸은 0입니다. 「확인 시작」을 누르면 서버가 세 색이 모두 든 무작위 신호 7번을 보냅니다(다음 신호는 앞 신호가 닿고 1.6 ~ 2.8초 뒤). 신호마다 닿고 1 ~ 1.5초 사이의 명령이 모두 규칙대로이면 그 확인이 맞습니다. 확인이 3번 이어서 맞으면 「확인받기」로 통과합니다.

로그인하고 연결 열쇠로 연결기를 켜면 서버가 받은 명령으로 판정합니다

힌트 보기
  • 받은 신호(red · yellow · green)를 읽어 linear.x를 고르는 자리가 연습 노드의 decide()입니다.
  • 늘 같은 속도를 내거나 터미널에서 ros2 topic pub으로 고정 값을 보내면 신호가 바뀌어도 명령이 바뀌지 않아 통과하지 못합니다.