Unity에서 C#을 이용한 로봇 제어

로봇 시뮬레이션에서 로봇의 동작을 제어하기 위해서는 프로그래밍 언어인 C#을 활용한 스크립팅이 필수적이다. Unity는 C#을 주요 스크립팅 언어로 사용하며, 이를 통해 로봇의 다양한 동작과 상호작용을 구현할 수 있다. 이 절에서는 Unity에서 C#을 이용하여 로봇을 제어하는 기본적인 방법부터 고급 제어 기법까지 다룬다.

C# 스크립트 기본 구조

Unity에서 로봇을 제어하기 위해서는 C# 스크립트를 작성하고 이를 로봇 모델에 부착해야 한다. C# 스크립트는 주로 MonoBehaviour 클래스를 상속받아 작성되며, 다음과 같은 기본 구조를 갖는다.

using UnityEngine;

public class RobotController : MonoBehaviour
{
    // 로봇의 속성 변수 선언
    public float speed = 5.0f;

    // 초기화 메서드
    void Start()
    {
        // 초기 설정
    }

    // 프레임마다 호출되는 업데이트 메서드
    void Update()
    {
        // 로봇 제어 로직
    }

    // 물리 계산과 관련된 FixedUpdate 메서드
    void FixedUpdate()
    {
        // 물리 기반 로봇 제어
    }
}

변수 선언: 로봇의 속도, 방향 등 제어에 필요한 변수들을 선언한다.
Start() 메서드: 스크립트가 활성화될 때 한 번 호출되며, 초기 설정을 수행한다.
Update() 메서드: 매 프레임마다 호출되며, 사용자 입력이나 비물리적 동작을 처리한다.
FixedUpdate() 메서드: 일정한 시간 간격으로 호출되며, 물리 계산과 관련된 로직을 처리한다.

로봇 이동 제어

로봇의 이동을 제어하기 위해서는 주로 Update() 또는 FixedUpdate() 메서드에서 로봇의 위치와 회전을 변경한다. 예를 들어, 키보드 입력을 받아 로봇을 전진, 후진, 좌우로 이동시키는 기본적인 코드는 다음과 같다.

using UnityEngine;

public class RobotController : MonoBehaviour
{
    public float moveSpeed = 5.0f;
    public float turnSpeed = 100.0f;

    void Update()
    {
        // 전진 및 후진
        float move = Input.GetAxis("Vertical") * moveSpeed * Time.deltaTime;
        transform.Translate(0, 0, move);

        // 좌우 회전
        float turn = Input.GetAxis("Horizontal") * turnSpeed * Time.deltaTime;
        transform.Rotate(0, turn, 0);
    }
}

Input.GetAxis("Vertical"): 키보드의 상하 화살표 또는 W/S 키 입력을 받아 전진과 후진을 제어한다.
Input.GetAxis("Horizontal"): 키보드의 좌우 화살표 또는 A/D 키 입력을 받아 좌우 회전을 제어한다.
transform.Translate(): 로봇의 위치를 이동시킨다.
transform.Rotate(): 로봇의 회전을 변경한다.

물리 기반 이동 제어

물리 엔진을 활용하여 로봇을 더욱 현실감 있게 제어하려면 Rigidbody 컴포넌트를 사용하여 힘과 토크를 적용해야 한다. 이를 위해서는 FixedUpdate() 메서드에서 물리 기반의 제어 로직을 작성한다.

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class RobotController : MonoBehaviour
{
    public float force = 500f;
    public float torque = 200f;
    private Rigidbody rb;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

    void FixedUpdate()
    {
        // 전진 및 후진
        float move = Input.GetAxis("Vertical");
        rb.AddForce(transform.forward * move * force);

        // 좌우 회전
        float turn = Input.GetAxis("Horizontal");
        rb.AddTorque(transform.up * turn * torque);
    }
}

Rigidbody 컴포넌트: 로봇에 물리적 속성을 부여하기 위해 Rigidbody 컴포넌트를 추가한다.
AddForce(): 로봇에 힘을 적용하여 이동을 제어한다.
AddTorque(): 로봇에 회전력을 적용하여 회전을 제어한다.

센서 데이터 활용

로봇 제어의 고도화를 위해서는 센서 데이터를 활용하는 것이 중요하다. 예를 들어, 거리 센서나 카메라 데이터를 기반으로 장애물을 피하거나 특정 목표를 향해 이동하도록 제어할 수 있다. 다음은 간단한 거리 센서를 활용한 장애물 회피 로직의 예이다.

using UnityEngine;

public class RobotController : MonoBehaviour
{
    public float moveSpeed = 5.0f;
    public float turnSpeed = 100.0f;
    public float obstacleDistance = 2.0f;

    void Update()
    {
        // 레이캐스트를 이용한 장애물 감지
        RaycastHit hit;
        if (Physics.Raycast(transform.position, transform.forward, out hit, obstacleDistance))
        {
            // 장애물이 감지되면 회전
            float turn = turnSpeed * Time.deltaTime;
            transform.Rotate(0, turn, 0);
        }
        else
        {
            // 장애물이 없으면 전진
            float move = moveSpeed * Time.deltaTime;
            transform.Translate(0, 0, move);
        }
    }
}

Physics.Raycast(): 로봇의 앞쪽으로 레이캐스트를 발사하여 장애물을 감지한다.
RaycastHit: 레이캐스트가 충돌한 객체에 대한 정보를 담는 구조체이다.
장애물 회피 로직: 장애물이 감지되면 로봇을 회전시켜 회피하고, 그렇지 않으면 전진한다.

경로 계획 및 이동 제어

로봇이 특정 경로를 따라 이동하도록 하기 위해서는 경로 계획 알고리즘을 구현해야 한다. 대표적인 알고리즘으로는 A* 알고리즘, Dijkstra 알고리즘 등이 있으며, 이를 C#으로 구현하여 로봇의 이동 경로를 결정할 수 있다. 간단한 경로 계획의 예는 다음과 같다.

using UnityEngine;
using System.Collections.Generic;

public class RobotController : MonoBehaviour
{
    public List<Vector3> path;
    public float speed = 5.0f;
    private int currentWaypoint = 0;

    void Update()
    {
        if (currentWaypoint < path.Count)
        {
            Vector3 target = path[currentWaypoint];
            Vector3 direction = target - transform.position;
            float step = speed * Time.deltaTime;

            if (direction.magnitude < step)
            {
                currentWaypoint++;
            }
            else
            {
                Vector3 move = direction.normalized * step;
                transform.Translate(move, Space.World);
            }
        }
    }
}

path: 로봇이 따라갈 경로의 웨이포인트 목록이다.
currentWaypoint: 현재 목표로 하는 웨이포인트의 인덱스이다.
경로 따라 이동: 로봇이 현재 웨이포인트로 이동하고, 도달하면 다음 웨이포인트로 넘어간다.

실시간 로봇 제어

실시간으로 로봇을 제어하기 위해서는 사용자 입력이나 외부 이벤트에 따라 로봇의 동작을 즉시 변경할 수 있어야 한다. 이를 위해 이벤트 리스너나 콜백 함수를 활용하여 실시간 제어 로직을 구현할 수 있다.

using UnityEngine;

public class RobotController : MonoBehaviour
{
    public float speed = 5.0f;
    private bool isMoving = false;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            isMoving = !isMoving;
        }

        if (isMoving)
        {
            transform.Translate(Vector3.forward * speed * Time.deltaTime);
        }
    }
}

Input.GetKeyDown(KeyCode.Space): 스페이스 키를 눌렀을 때 로봇의 이동 상태를 토글한다.
isMoving: 로봇이 이동 중인지 여부를 나타내는 변수이다.
실시간 제어: 사용자의 입력에 따라 로봇의 동작을 실시간으로 변경한다.

PID 제어를 이용한 정밀 로봇 제어

PID(Proportional-Integral-Derivative) 제어기는 로봇의 동작을 정밀하게 제어하기 위해 널리 사용되는 피드백 제어 알고리즘이다. PID 제어기는 현재 오차, 오차의 누적, 오차의 변화율을 기반으로 제어 신호를 생성하여 로봇의 움직임을 조정한다. 이 절에서는 PID 제어기의 기본 개념과 Unity에서 C#을 이용한 구현 방법을 설명한다.

PID 제어기의 구성 요소

PID 제어기는 세 가지 주요 요소로 구성된다:

비례(Proportional, P): 현재 오차에 비례하여 제어 신호를 생성한다.
적분(Integral, I): 오차의 누적에 비례하여 제어 신호를 생성한다.
미분(Derivative, D): 오차의 변화율에 비례하여 제어 신호를 생성한다.

PID 제어기의 출력 $u(t)$ 는 다음과 같이 표현된다:

$u(t) = K_p e(t) + K_i \int_{0}^{t} e(\tau) d\tau + K_d \frac{de(t)}{dt}$

여기서: - $e(t)$ 는 현재 오차 - $K_p$ 는 비례 게인 - $K_i$ 는 적분 게인 - $K_d$ 는 미분 게인

C#을 이용한 PID 컨트롤러 구현

Unity에서 PID 제어기를 구현하기 위해서는 C# 스크립트를 작성하여 로봇의 목표 위치나 속도에 도달하도록 제어 신호를 생성해야 한다. 다음은 간단한 PID 컨트롤러의 구현 예제이다.

using UnityEngine;

public class PIDController : MonoBehaviour
{
    public float Kp = 1.0f;
    public float Ki = 0.0f;
    public float Kd = 0.0f;

    private float integral = 0.0f;
    private float previousError = 0.0f;

    public float Compute(float setpoint, float actual, float deltaTime)
    {
        float error = setpoint - actual;
        integral += error * deltaTime;
        float derivative = (error - previousError) / deltaTime;
        previousError = error;

        float output = Kp * error + Ki * integral + Kd * derivative;
        return output;
    }
}

Kp, Ki, Kd: 각각 비례, 적분, 미분 게인 값을 설정한다.
Compute() 메서드: 목표값(setpoint)과 실제값(actual)의 오차를 기반으로 제어 신호를 계산한다.

로봇 이동에 PID 제어기 적용

PID 제어기를 로봇의 이동에 적용하여 목표 위치에 정밀하게 도달하도록 제어할 수 있다. 다음은 PID 컨트롤러를 이용하여 로봇의 속도를 조정하는 예제이다.

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class RobotPIDController : MonoBehaviour
{
    public Vector3 targetPosition;
    public float maxSpeed = 10.0f;

    private Rigidbody rb;
    private PIDController pid;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
        pid = new PIDController();
        pid.Kp = 2.0f;
        pid.Ki = 0.5f;
        pid.Kd = 1.0f;
    }

    void FixedUpdate()
    {
        Vector3 errorVector = targetPosition - transform.position;
        float distance = errorVector.magnitude;
        Vector3 direction = errorVector.normalized;

        // PID 컨트롤러를 사용하여 속도 계산
        float controlSignal = pid.Compute(0.0f, distance, Time.fixedDeltaTime);

        // 속도 제한
        float speed = Mathf.Clamp(controlSignal, -maxSpeed, maxSpeed);

        // 로봇에 힘을 적용하여 이동
        rb.AddForce(direction * speed);
    }
}

targetPosition: 로봇이 도달해야 할 목표 위치이다.
PIDController: 이전에 구현한 PID 컨트롤러를 사용하여 거리 오차에 기반한 제어 신호를 계산한다.
AddForce(): 계산된 속도를 방향에 따라 로봇에 적용하여 이동을 제어한다.

PID 게인 튜닝

PID 컨트롤러의 성능은 $K_p$ , $K_i$ , $K_d$ 게인의 설정에 크게 좌우된다. 적절한 게인 값을 찾기 위해서는 다음과 같은 튜닝 방법을 사용할 수 있다:

비례 게인 $K_p$ 조정: $K_p$ 를 점차 증가시키면서 시스템의 응답 속도를 높이고 과도한 진동이 발생하지 않도록 한다.
적분 게인 $K_i$ 조정: 정적 오차를 제거하기 위해 $K_i$ 를 서서히 증가시킨다. 너무 크게 설정하면 시스템이 불안정해질 수 있다.
미분 게인 $K_d$ 조정: 응답의 과도한 진동을 줄이기 위해 $K_d$ 를 조정한다. 미분 게인이 너무 크면 노이즈에 민감해질 수 있다.

PID 게인 튜닝은 경험과 실험을 통해 최적의 값을 찾아내는 과정이 필요하다. Unity의 디버깅 도구를 활용하여 오차와 제어 신호를 시각화하면 튜닝 과정을 보다 효율적으로 진행할 수 있다.

상태 머신을 이용한 로봇 행동 제어

상태 머신(State Machine)은 로봇의 다양한 행동을 체계적으로 관리하기 위한 유용한 도구이다. 상태 머신을 사용하면 로봇이 특정 조건에 따라 다양한 상태를 전환하면서 복잡한 동작을 수행할 수 있다. 이 절에서는 상태 머신의 기본 개념과 Unity에서 C#을 이용한 구현 방법을 설명한다.

상태 머신의 기본 개념

상태 머신은 다음과 같은 구성 요소로 이루어져 있다:

상태(State): 로봇이 특정 시점에 있을 수 있는 상태이다. 예를 들어, 대기 상태, 이동 상태, 장애물 회피 상태 등이 있다.
전이(Transition): 한 상태에서 다른 상태로의 전환 조건을 정의한다.
행동(Action): 각 상태에서 수행되는 동작을 정의한다.

C#을 이용한 상태 머신 구현

Unity에서 상태 머신을 구현하기 위해서는 상태 클래스를 정의하고, 현재 상태에 따라 적절한 행동을 수행하도록 스크립트를 작성해야 한다. 다음은 간단한 상태 머신의 구현 예제이다.

using UnityEngine;

// 상태 인터페이스 정의
public interface IState
{
    void Enter();
    void Execute();
    void Exit();
}

// 대기 상태
public class IdleState : IState
{
    private RobotController robot;

    public IdleState(RobotController robot)
    {
        this.robot = robot;
    }

    public void Enter()
    {
        Debug.Log("Entering Idle State");
        robot.StopMovement();
    }

    public void Execute()
    {
        // 대기 상태에서의 로직
        if (robot.HasTarget())
        {
            robot.ChangeState(new MoveState(robot));
        }
    }

    public void Exit()
    {
        Debug.Log("Exiting Idle State");
    }
}

// 이동 상태
public class MoveState : IState
{
    private RobotController robot;

    public MoveState(RobotController robot)
    {
        this.robot = robot;
    }

    public void Enter()
    {
        Debug.Log("Entering Move State");
        robot.StartMovement();
    }

    public void Execute()
    {
        // 이동 상태에서의 로직
        if (!robot.HasTarget())
        {
            robot.ChangeState(new IdleState(robot));
        }
    }

    public void Exit()
    {
        Debug.Log("Exiting Move State");
        robot.StopMovement();
    }
}

// 상태 머신을 관리하는 로봇 컨트롤러
public class RobotController : MonoBehaviour
{
    private IState currentState;

    void Start()
    {
        ChangeState(new IdleState(this));
    }

    void Update()
    {
        if (currentState != null)
        {
            currentState.Execute();
        }
    }

    public void ChangeState(IState newState)
    {
        if (currentState != null)
        {
            currentState.Exit();
        }

        currentState = newState;

        if (currentState != null)
        {
            currentState.Enter();
        }
    }

    public bool HasTarget()
    {
        // 목표 지점이 있는지 확인하는 로직
        return false;
    }

    public void StartMovement()
    {
        // 이동 시작 로직
    }

    public void StopMovement()
    {
        // 이동 정지 로직
    }
}

IState 인터페이스: 각 상태가 구현해야 할 메서드를 정의한다.
IdleState: 로봇이 대기 상태일 때의 행동을 정의한다.
MoveState: 로봇이 이동 상태일 때의 행동을 정의한다.
RobotController: 현재 상태를 관리하고 상태 전환을 수행한다.

상태 전환 조건 설정

상태 전환 조건은 로봇의 센서 데이터나 외부 이벤트에 따라 설정할 수 있다. 예를 들어, 로봇이 목표 지점에 도달했을 때 대기 상태로 전환하거나, 장애물이 감지되었을 때 회피 상태로 전환할 수 있다. 다음은 장애물 감지 시 상태를 전환하는 예제이다.

public class MoveState : IState
{
    private RobotController robot;

    public MoveState(RobotController robot)
    {
        this.robot = robot;
    }

    public void Enter()
    {
        Debug.Log("Entering Move State");
        robot.StartMovement();
    }

    public void Execute()
    {
        // 이동 상태에서의 로직
        if (!robot.HasTarget())
        {
            robot.ChangeState(new IdleState(robot));
        }

        if (robot.IsObstacleDetected())
        {
            robot.ChangeState(new AvoidObstacleState(robot));
        }
    }

    public void Exit()
    {
        Debug.Log("Exiting Move State");
        robot.StopMovement();
    }
}

IsObstacleDetected(): 장애물이 감지되었는지 여부를 반환하는 메서드이다.
AvoidObstacleState: 장애물을 회피하는 상태를 추가로 구현해야 한다.

상태 머신의 장점

유지보수 용이성: 상태별로 코드를 분리하여 관리하기 때문에 코드의 가독성과 유지보수성이 향상된다.
확장성: 새로운 상태를 추가하거나 기존 상태를 수정하기 쉽다.
명확한 로직 흐름: 상태 전환 조건을 명확히 정의하여 로봇의 행동 흐름을 체계적으로 관리할 수 있다.