# Isaac Sim 인터페이스 둘러보기

Isaac Sim은 NVIDIA의 강력한 시뮬레이션 환경으로, 주로 로봇의 개발과 테스트, 그리고 ROS2와의 통합을 위한 플랫폼으로 사용된다. 이 섹션에서는 Isaac Sim의 다양한 인터페이스를 설명하고, 이를 통해 로봇 개발자가 어떻게 시뮬레이션 환경을 설정하고 활용할 수 있는지에 대해 다룬다. 각 인터페이스는 로봇 시스템의 시뮬레이션과 제어를 위한 핵심적인 역할을 한다. 이 내용은 기초적인 사용법에서부터 고급 기능에 이르기까지 포괄적으로 다루어진다.

#### Isaac Sim 환경 구성 요소

Isaac Sim은 다양한 구성 요소로 이루어져 있다. 가장 기본적인 구성 요소들은 시뮬레이션 환경을 제공하는 그래픽 인터페이스, 로봇 제어를 위한 API, 그리고 ROS2와의 통합을 위한 구성 요소들이다. 각 구성 요소는 아래와 같이 나눠볼 수 있다.

1. **3D 뷰어** Isaac Sim의 3D 뷰어는 로봇 및 환경을 시뮬레이션하는 데 중요한 역할을 한다. 이 뷰어는 실제 환경에서 로봇의 움직임을 시각적으로 확인할 수 있게 해주며, 물리적 상호작용, 센서 데이터, 카메라 이미지 등을 실시간으로 시각화할 수 있다. 또한, 로봇의 경로 계획 및 동작을 추적하는 데 유용한 도구들이 포함되어 있다.
2. **로봇 제어 API** 로봇 제어를 위한 핵심 API는 다양한 모듈로 구성되어 있으며, 각 모듈은 로봇의 모션을 제어하는 기능을 제공한다. 이 API는 ROS2와 함께 사용하여 로봇의 명령을 보내고 받을 수 있으며, 시뮬레이션된 로봇에 대한 제어 신호를 전달하는 역할을 한다.
3. **ROS2 통합** Isaac Sim은 ROS2와 긴밀하게 통합되어 있어, 로봇 개발자는 ROS2 노드를 사용하여 시뮬레이션과 상호작용할 수 있다. 이를 통해 로봇의 센서 데이터, 상태 정보, 명령을 처리하고, 실제 로봇 시스템에 적용할 수 있다.

#### 3D 뷰어 및 환경 설정

3D 뷰어는 Isaac Sim의 가장 중요한 기능 중 하나로, 물리적 시뮬레이션을 시각적으로 확인할 수 있는 중요한 도구이다. 이 뷰어는 기본적으로 Unreal Engine이나 Omniverse를 사용하여 구현되며, 다양한 물리 엔진과 렌더링 기능을 통해 현실감 있는 시뮬레이션을 제공한다. 3D 뷰어를 설정하는 방법은 다음과 같다.

**기본 환경 설정**

Isaac Sim을 실행한 후, 기본 환경을 설정하기 위해서는 다음과 같은 작업들이 필요하다.

1. **Omniverse 계정 생성 및 로그인** Omniverse 계정을 만들고, 해당 계정으로 Isaac Sim에 로그인해야 한다. 이 과정은 Omniverse 플랫폼과의 연결을 위해 필수적이다.
2. **시뮬레이션 환경 불러오기** Isaac Sim은 다양한 기본 시나리오를 제공하며, 이를 기반으로 사용자는 자신의 요구에 맞는 시뮬레이션 환경을 선택하고 불러올 수 있다. 예를 들어, 로봇이 실내를 탐색하는 시나리오나, 자율주행차가 도로 위를 주행하는 시나리오 등이 제공된다.
3. **환경 조정** 3D 뷰어에서 환경을 편집하고 조정하는 기능도 제공된다. 이 기능을 통해 시뮬레이션 중인 환경에 장애물을 추가하거나, 로봇의 위치를 조정할 수 있다.

**고급 기능**

고급 사용자는 3D 뷰어를 이용하여 다양한 시뮬레이션 파라미터를 수정하거나, 시뮬레이션 환경을 보다 정교하게 조정할 수 있다. 예를 들어, 로봇이 특정 위치로 이동할 때 발생하는 물리적 상호작용을 더욱 현실감 있게 설정할 수 있으며, 다양한 센서 데이터를 실시간으로 시각화할 수 있다.

#### ROS2와의 통합

Isaac Sim은 ROS2와의 통합을 위해 다양한 ROS2 패키지 및 API를 제공한다. 이를 통해 사용자는 ROS2 노드를 Isaac Sim과 연결하고, 실제 로봇처럼 시뮬레이션된 로봇을 제어할 수 있다.

**ROS2 노드 설정**

1. **ROS2 설치 및 환경 설정** ROS2를 설치하고, 필요한 패키지들을 설정하는 과정이 필요하다. 이 과정에서는 ROS2 Humble 버전을 사용하며, 해당 버전과 호환되는 패키지들을 설치해야 한다. 예를 들어, `ros-isaac-sim` 패키지와 같은 ROS2 패키지가 필요하다.
2. **Isaac Sim의 ROS2 통합 사용** Isaac Sim은 ROS2와의 통합을 위한 특별한 기능들을 제공한다. 예를 들어, 로봇의 센서 데이터를 ROS2 토픽을 통해 전달하거나, ROS2 서비스를 통해 로봇의 동작을 제어할 수 있다. 또한, ROS2의 Action 서버를 사용하여 로봇의 동작을 비동기적으로 제어하는 기능도 제공된다.

**ROS2 메시지 유형**

Isaac Sim에서는 ROS2 메시지 타입을 통해 시뮬레이션된 데이터를 주고받을 수 있다. 이러한 메시지는 시뮬레이션된 센서 데이터, 로봇 상태, 명령 등을 포함할 수 있다. 예를 들어, 카메라 이미지 데이터를 `sensor_msgs/Image` 메시지로 처리하거나, 로봇의 위치를 `geometry_msgs/Pose` 메시지로 전송할 수 있다.

#### 인터페이스 상호작용

Isaac Sim의 인터페이스는 매우 직관적이며, 사용자가 쉽게 접근할 수 있도록 설계되어 있다. 이 인터페이스는 주로 GUI를 통해 조작되며, 3D 뷰어, 시뮬레이션 파라미터 설정, 로봇 제어 등을 직관적으로 수행할 수 있다. 또한, 고급 사용자에게는 Python API를 제공하여 시뮬레이션을 스크립팅하고 자동화할 수 있는 기능을 제공한다.

#### Python API를 통한 제어

Isaac Sim은 Python API를 통해 로봇 제어와 시뮬레이션 환경 설정을 자동화할 수 있는 기능을 제공한다. Python 스크립트를 사용하면, 3D 뷰어를 통해 로봇을 제어하거나, 시뮬레이션의 파라미터를 동적으로 변경하는 등의 작업을 할 수 있다. 이를 통해 실시간으로 시뮬레이션을 제어하며, 로봇의 동작을 테스트하고 분석할 수 있다.

**Python 스크립트 예시**

Python API를 사용하여 시뮬레이션을 제어하려면, 다음과 같은 기본적인 스크립트 구성이 필요하다.

```python
import omni
from omni.isaac.core import World
from omni.isaac.core.utils import stage
from omni.isaac.core.objects import DynamicCuboid

# 세계 객체 생성
world = World(stage)
world.render()

# 시뮬레이션 환경에서 객체 생성
cube = DynamicCuboid(prim_path="/World/Cube", size=(1, 1, 1))
world.scene.add_object(cube)

# 시뮬레이션 실행
world.step()
```

이 스크립트는 Isaac Sim 환경에서 기본적인 큐브 객체를 생성하고, 시뮬레이션을 한 단계 진행한다. `World` 객체는 시뮬레이션 환경을 나타내며, `DynamicCuboid` 객체는 동적인 큐브 모양의 물체를 생성한다.

#### 시뮬레이션과 로봇 제어의 통합

Isaac Sim을 이용한 로봇 제어는 ROS2와의 통합을 통해 이루어진다. 이 과정에서 주요한 역할을 하는 것은 ROS2의 노드와 Isaac Sim에서 제공하는 제어 명령이다. 예를 들어, ROS2를 통해 로봇의 속도 명령을 보내거나, 특정 동작을 실행하는 등의 작업을 수행할 수 있다.

**ROS2를 통한 로봇 속도 제어 예시**

로봇의 속도를 제어하기 위해서는 ROS2의 `geometry_msgs/Twist` 메시지를 사용하여 속도 명령을 전달할 수 있다. 예시로는 다음과 같은 코드가 있다.

```python
import rclpy
from geometry_msgs.msg import Twist
from rclpy.node import Node

class RobotController(Node):
    def __init__(self):
        super().__init__('robot_controller')
        self.publisher_ = self.create_publisher(Twist, '/robot/cmd_vel', 10)
        timer_period = 0.1
        self.timer = self.create_timer(timer_period, self.timer_callback)

    def timer_callback(self):
        msg = Twist()
        msg.linear.x = 1.0
        msg.angular.z = 0.5
        self.publisher_.publish(msg)
        self.get_logger().info('Publishing: "%s"' % msg)

def main(args=None):
    rclpy.init(args=args)
    robot_controller = RobotController()
    rclpy.spin(robot_controller)
    robot_controller.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()
```

이 코드에서는 `geometry_msgs/Twist` 메시지를 통해 로봇의 선형 속도와 각속도를 제어한다. `robot_controller` 노드는 일정 시간 간격으로 `Twist` 메시지를 발행하여 로봇에 속도 명령을 전달한다.

#### 고급 기능: 시뮬레이션 데이터 분석

Isaac Sim은 로봇 개발자에게 매우 유용한 시뮬레이션 데이터 분석 기능을 제공한다. 시뮬레이션 중 발생하는 다양한 데이터를 실시간으로 분석하고, 이를 기반으로 로봇의 성능을 평가할 수 있다. 예를 들어, 로봇의 센서 데이터를 실시간으로 수집하고, 이를 바탕으로 경로 추적 및 로봇 동작을 최적화할 수 있다.

**센서 데이터 분석**

Isaac Sim에서는 다양한 센서 데이터, 예를 들어 LiDAR, 카메라, IMU 등의 센서 데이터를 시뮬레이션 할 수 있다. 이러한 센서 데이터를 ROS2 메시지를 통해 실시간으로 수집하고 분석하는 예시는 다음과 같다.

```python
import rclpy
from sensor_msgs.msg import LaserScan
from rclpy.node import Node

class SensorDataListener(Node):
    def __init__(self):
        super().__init__('sensor_data_listener')
        self.subscription = self.create_subscription(
            LaserScan,
            '/robot/laser_scan',
            self.listener_callback,
            10
        )
        self.subscription

    def listener_callback(self, msg):
        # LaserScan 데이터를 처리하는 로직
        self.get_logger().info('Received LaserScan data')
        print(f"Range Data: {msg.ranges}")

def main(args=None):
    rclpy.init(args=args)
    sensor_listener = SensorDataListener()
    rclpy.spin(sensor_listener)
    sensor_listener.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()
```

이 예제에서는 `LaserScan` 메시지를 사용하여 LiDAR 센서로부터 받은 데이터를 실시간으로 처리한다. `ranges` 필드에는 센서에서 수집된 거리 데이터가 포함되어 있으며, 이를 이용하여 로봇의 환경을 파악하거나 경로를 계획할 수 있다.

#### 그래픽 인터페이스와 실시간 상호작용

Isaac Sim은 강력한 GUI 인터페이스를 제공하여 시뮬레이션을 직관적으로 제어할 수 있다. GUI를 통해 로봇의 위치나 동작을 실시간으로 조정하거나, 시뮬레이션 파라미터를 수정할 수 있다. 또한, 물리적 상호작용을 시각적으로 확인하고, 각종 센서 데이터를 그래픽적으로 표시할 수 있는 기능을 제공한다.

**인터페이스에서 시뮬레이션 제어**

GUI를 사용하면, 3D 뷰어 내에서 직접 로봇을 조작하거나, 환경을 편집하여 실시간으로 시뮬레이션을 조정할 수 있다. 또한, 다양한 슬라이더나 버튼을 통해 시뮬레이션 파라미터를 동적으로 수정할 수 있다. 예를 들어, 로봇의 속도를 조절하거나, 장애물을 추가하는 등의 작업이 가능한다.

#### 로봇의 동작 모니터링 및 분석

Isaac Sim에서는 로봇의 동작을 실시간으로 모니터링할 수 있는 다양한 도구를 제공한다. 이 도구들은 로봇의 상태를 추적하고, 시뮬레이션 중 발생하는 이벤트를 기록하며, 이를 통해 시스템의 성능을 분석하는 데 중요한 역할을 한다.

**실시간 상태 모니터링**

Isaac Sim의 3D 뷰어는 로봇의 현재 위치, 속도, 방향을 실시간으로 확인할 수 있는 기능을 제공한다. 또한, 로봇이 주행하는 동안 각 센서에서 발생하는 데이터도 실시간으로 시각화할 수 있다. 예를 들어, 카메라 영상이나 LiDAR 데이터를 통해 로봇의 주변 환경을 모니터링하면서 로봇의 움직임을 제어할 수 있다.

**상태 모니터링 예시**

로봇의 상태를 모니터링하려면, ROS2에서 제공하는 메시지를 활용하여 로봇의 위치나 속도 정보를 구독하고 이를 실시간으로 표시할 수 있다. 예를 들어, `geometry_msgs/Pose` 메시지를 통해 로봇의 위치를 추적하고, `geometry_msgs/Twist` 메시지를 통해 속도 정보를 받을 수 있다.

```python
import rclpy
from geometry_msgs.msg import Pose, Twist
from rclpy.node import Node

class RobotStateMonitor(Node):
    def __init__(self):
        super().__init__('robot_state_monitor')
        self.pose_subscription = self.create_subscription(
            Pose,
            '/robot/pose',
            self.pose_callback,
            10
        )
        self.velocity_subscription = self.create_subscription(
            Twist,
            '/robot/cmd_vel',
            self.velocity_callback,
            10
        )

    def pose_callback(self, msg):
        self.get_logger().info(f"Robot Position: {msg.position.x}, {msg.position.y}, {msg.position.z}")
        
    def velocity_callback(self, msg):
        self.get_logger().info(f"Robot Velocity: {msg.linear.x}, {msg.angular.z}")

def main(args=None):
    rclpy.init(args=args)
    robot_state_monitor = RobotStateMonitor()
    rclpy.spin(robot_state_monitor)
    robot_state_monitor.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()
```

이 코드에서는 `Pose` 메시지로 로봇의 위치를, `Twist` 메시지로 로봇의 선형 및 각속도를 실시간으로 구독하여 로봇의 상태를 모니터링한다. 이 정보를 통해 로봇의 동작을 추적하고 필요한 제어 명령을 내릴 수 있다.

#### 시뮬레이션 환경에서의 장애물 및 상호작용

Isaac Sim에서는 시뮬레이션 환경 내에서 로봇과의 물리적 상호작용을 시뮬레이션할 수 있다. 로봇이 장애물과 상호작용하는 상황을 실험해보거나, 특정 환경에서 로봇이 어떻게 반응하는지를 확인할 수 있다. 이를 통해 로봇의 내구성, 반응 속도, 충돌 방지 능력 등을 테스트할 수 있다.

**장애물 상호작용 설정**

시뮬레이션 환경 내에서 장애물을 추가하거나, 로봇의 이동 경로를 조정하여 물리적 상호작용을 실험할 수 있다. 장애물은 간단한 큐브나 복잡한 형태를 가질 수 있으며, 물리 엔진을 통해 로봇과의 충돌이나 상호작용을 실시간으로 확인할 수 있다.

```python
from omni.isaac.core.objects import DynamicCuboid

# 장애물 추가
obstacle = DynamicCuboid(prim_path="/World/Obstacle", size=(2, 2, 0.5))
world.scene.add_object(obstacle)
```

이 코드에서는 `DynamicCuboid` 객체를 사용하여 간단한 장애물을 시뮬레이션 환경에 추가한다. 추가된 장애물은 로봇과의 상호작용을 통해 충돌을 감지하거나, 로봇의 이동 경로를 제어할 수 있다.

#### 고급 물리 엔진과 상호작용

Isaac Sim은 고급 물리 엔진을 내장하고 있어, 시뮬레이션 내에서 물리적 상호작용을 사실적으로 구현할 수 있다. 예를 들어, 로봇이 장애물에 충돌할 때 발생하는 반동, 마찰, 회전 등을 물리 엔진을 통해 실시간으로 계산하여 반영한다. 이러한 물리 엔진의 정확도는 로봇의 성능을 평가하는 데 매우 중요한 요소이다.

**물리 엔진 설정**

Isaac Sim은 다양한 물리 엔진을 지원한다. 예를 들어, NVIDIA의 PhysX 엔진을 사용하여 로봇과 환경 간의 물리적 상호작용을 구현할 수 있다. 이 엔진은 물체 간의 충돌, 마찰, 관성 등을 시뮬레이션하며, 시뮬레이션 환경 내에서 발생할 수 있는 물리적 이벤트를 정확하게 계산한다.

#### 시뮬레이션 데이터 로깅 및 분석

Isaac Sim은 시뮬레이션 데이터를 로깅하고 이를 분석할 수 있는 기능을 제공한다. 실시간으로 발생하는 센서 데이터, 로봇의 상태 정보, 환경 변수 등을 로그로 기록하여, 이후의 분석 및 개선 작업에 활용할 수 있다. 이 데이터는 또한, 로봇의 성능을 평가하고, 실험 결과를 검증하는 데 중요한 역할을 한다.

**데이터 로깅 예시**

```python
import logging

# 로깅 설정
logging.basicConfig(filename='simulation.log', level=logging.INFO)

# 센서 데이터 로그 기록
logging.info(f"Robot Position: {msg.position.x}, {msg.position.y}")
logging.info(f"Robot Velocity: {msg.linear.x}, {msg.angular.z}")
```

이 예시에서는 시뮬레이션 중에 발생하는 로봇의 위치와 속도 데이터를 로그 파일에 기록한다. 이 데이터는 나중에 분석을 통해 로봇의 동작을 최적화하거나 성능을 평가하는 데 활용될 수 있다.

#### ROS2와 Isaac Sim의 통합

Isaac Sim은 ROS2와 원활하게 통합되어 로봇의 제어와 센서 데이터를 처리할 수 있는 강력한 환경을 제공한다. 이 통합을 통해 로봇의 제어를 ROS2 네트워크 상에서 처리하고, Isaac Sim에서 실행되는 시뮬레이션에 실시간으로 영향을 미칠 수 있다.

**ROS2 메시지를 통한 제어 및 데이터 송수신**

Isaac Sim에서는 ROS2 메시지를 통해 로봇의 동작을 제어하거나, 시뮬레이션 환경에서 발생하는 데이터를 수집할 수 있다. 예를 들어, ROS2의 `Twist` 메시지를 사용하여 로봇의 속도를 제어하거나, `LaserScan` 메시지를 사용하여 센서 데이터를 수집할 수 있다. 이러한 메시지를 통해, 실시간으로 시뮬레이션 환경과 상호작용하거나 로봇의 동작을 자동화할 수 있다.

```python
import rclpy
from geometry_msgs.msg import Twist
from rclpy.node import Node

class RobotController(Node):
    def __init__(self):
        super().__init__('robot_controller')
        self.publisher_ = self.create_publisher(Twist, '/robot/cmd_vel', 10)
        timer_period = 0.1
        self.timer = self.create_timer(timer_period, self.timer_callback)

    def timer_callback(self):
        msg = Twist()
        msg.linear.x = 1.0
        msg.angular.z = 0.5
        self.publisher_.publish(msg)
        self.get_logger().info('Publishing: "%s"' % msg)

def main(args=None):
    rclpy.init(args=args)
    robot_controller = RobotController()
    rclpy.spin(robot_controller)
    robot_controller.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()
```

이 예제는 `Twist` 메시지를 통해 로봇의 속도 명령을 ROS2로 전송하는 코드이다. `linear.x`는 로봇의 선형 속도를, `angular.z`는 로봇의 각속도를 제어한다. 이 정보를 Isaac Sim 내의 로봇에 전달하여 시뮬레이션을 제어할 수 있다.

#### 로봇 모델과 시뮬레이션 환경 설정

Isaac Sim은 로봇 모델과 시뮬레이션 환경을 설정하고 제어하는 데 매우 유용한 도구를 제공한다. 이 도구를 사용하여, 다양한 환경 조건에서 로봇의 성능을 테스트하거나, 특정 동작을 시뮬레이션 할 수 있다.

**로봇 모델 생성**

Isaac Sim에서 로봇 모델은 `Prim` 객체를 사용하여 생성된다. `Prim`은 시뮬레이션 환경에서 물체를 정의하는 기본 단위이며, 이를 통해 로봇이나 환경 요소를 모델링할 수 있다. 예를 들어, `DynamicCuboid`나 `DynamicSphere`를 사용하여 로봇의 구조나 장애물을 생성할 수 있다.

```python
from omni.isaac.core.objects import DynamicCuboid

# 로봇의 기본 구조로 큐브 객체 생성
robot_body = DynamicCuboid(prim_path="/World/Robot/Body", size=(1, 0.5, 0.5))
world.scene.add_object(robot_body)
```

위의 코드에서는 `DynamicCuboid` 객체를 사용하여 로봇의 몸체를 생성한다. 시뮬레이션 환경 내에서 다양한 크기와 형태의 로봇을 모델링할 수 있으며, 이를 통해 실제 로봇의 동작을 시뮬레이션할 수 있다.

**시뮬레이션 환경 설정**

Isaac Sim의 시뮬레이션 환경은 물리적 현실을 그대로 반영하는 데 필요한 다양한 설정을 제공한다. 환경을 설정할 때, 충돌 처리, 물리 엔진 설정, 중력 등을 정의할 수 있다. 이러한 설정은 로봇의 동작과 환경 상호작용을 현실적으로 만드는데 필수적이다.

```python
from omni.isaac.core import World

# 환경 설정 및 물리 엔진 초기화
world = World(stage)
world.render()

# 중력 설정
world.scene.gravity = (0, 0, -9.81)
```

이 코드에서는 `World` 객체를 사용하여 시뮬레이션 환경을 설정하고, 중력을 정의한다. 중력 외에도 마찰, 반발력, 그리고 기타 물리적인 특성들을 설정하여, 환경을 세밀하게 제어할 수 있다.

#### 사용자 인터페이스와 실시간 상호작용

Isaac Sim은 직관적인 사용자 인터페이스를 통해 실시간으로 시뮬레이션을 제어하고 데이터를 모니터링할 수 있는 기능을 제공한다. 사용자 인터페이스는 로봇의 동작을 제어하는 데 필요한 모든 도구를 제공하며, 이를 통해 로봇의 성능을 실시간으로 분석할 수 있다.

**UI에서 로봇 제어**

Isaac Sim의 GUI에서는 버튼, 슬라이더, 또는 3D 뷰어와 같은 인터페이스 요소를 사용하여 로봇을 제어할 수 있다. 이를 통해 로봇의 위치나 속도를 조정하거나, 환경 요소를 변경할 수 있다.

**3D 뷰어와 상호작용**

Isaac Sim의 3D 뷰어는 시뮬레이션 환경을 실시간으로 시각화할 수 있다. 사용자는 이 뷰어를 통해 로봇의 동작을 모니터링하거나, 시뮬레이션의 진행 상태를 확인할 수 있다. 3D 뷰어를 통해 로봇의 센서 데이터를 시각화하거나, 환경에 추가된 물체와의 상호작용을 직관적으로 확인할 수 있다.

#### 고급 기능: 환경 변수와 동적 설정

Isaac Sim에서는 환경 변수를 동적으로 조정할 수 있는 기능도 제공한다. 예를 들어, 시뮬레이션 도중에 환경의 조명, 날씨, 장애물 등의 변수를 실시간으로 변경하여 로봇의 동작을 테스트할 수 있다. 이를 통해 다양한 상황에서 로봇의 성능을 평가할 수 있으며, 이를 바탕으로 로봇의 제어 알고리즘을 개선할 수 있다.

**환경 변수 동적 설정 예시**

```python
import omni

# 환경 변수 설정
omni.usd.get_context().set_stage_up_axis('Y')

# 날씨 설정
world.scene.weather.set_conditions(rainfall=True, wind_speed=10)
```

위의 예시는 Isaac Sim에서 환경 설정을 동적으로 조정하는 방법을 보여준다. `set_stage_up_axis`를 통해 환경의 기준축을 설정할 수 있으며, 날씨 조건을 설정하여 로봇이 다양한 환경에서 어떻게 반응하는지 실험할 수 있다.