💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

1. 로보틱스 기초

자유도 (DOF: Degrees of Freedom)

로봇의 **자유도**란 로봇이 독립적으로 움직일 수 있는 축의 수입니다. 6-DOF 로봇팔은 3차원 공간에서 임의의 위치와 자세를 표현하기에 충분한 최소 자유도를 갖습니다. 손가락을 포함한 전신 휴머노이드 로봇은 50-DOF 이상을 가질 수 있습니다.

| 자유도 | 표현 가능한 운동 | 예시 |

| ------ | --------------------- | ----------------------- |

| 1-DOF | 단일 축 회전/병진 | 컨베이어 벨트 |

| 3-DOF | 3차원 위치 | 델타 로봇 |

| 6-DOF | 위치 + 자세 완전 제어 | 산업용 로봇팔 |

| 7-DOF | 여유 자유도 포함 | KUKA iiwa, Franka Panda |

좌표계 변환: 동차 변환 행렬

3D 공간에서 강체의 위치와 방향을 표현하기 위해 **동차 변환 행렬(Homogeneous Transformation Matrix)**을 사용합니다. 4x4 행렬로 회전(R)과 평행이동(t)을 동시에 표현합니다.

$$T = \begin{bmatrix} R_{3\times3} & t_{3\times1} \\ 0_{1\times3} & 1 \end{bmatrix}$$

여러 좌표계 간의 변환은 행렬 곱으로 연쇄적으로 적용할 수 있습니다.

$$T_{base \to end} = T_{base \to 1} \cdot T_{1 \to 2} \cdots T_{n-1 \to end}$$

순기구학 (Forward Kinematics)

**순기구학**은 각 관절의 각도(joint angles)가 주어졌을 때 엔드이펙터(end-effector)의 위치와 자세를 계산하는 문제입니다. 각 관절에 해당하는 변환 행렬을 곱하여 구합니다.

def dh_transform(a, d, alpha, theta):

"""Denavit-Hartenberg 변환 행렬 계산"""

ct, st = np.cos(theta), np.sin(theta)

ca, sa = np.cos(alpha), np.sin(alpha)

return np.array([

[ct, -st*ca, st*sa, a*ct],

[st, ct*ca, -ct*sa, a*st],

[0, sa, ca, d ],

[0, 0, 0, 1 ]

])

def forward_kinematics(joint_angles, dh_params):

"""

순기구학: 관절 각도 -> 엔드이펙터 위치/자세

dh_params: [(a, d, alpha, theta_offset), ...]

"""

T = np.eye(4)

for i, theta in enumerate(joint_angles):

a, d, alpha, theta_off = dh_params[i]

T = T @ dh_transform(a, d, alpha, theta + theta_off)

return T

2-DOF 평면 로봇팔 예시 (링크 길이 각 1.0m)

dh_params_2dof = [

(1.0, 0, 0, 0),

]

joint_angles = [np.pi/4, np.pi/4]

T_end = forward_kinematics(joint_angles, dh_params_2dof)

print("엔드이펙터 위치:", T_end[:3, 3])

역기구학 (Inverse Kinematics)

**역기구학**은 원하는 엔드이펙터의 위치/자세에서 필요한 관절 각도를 계산합니다. 해석적 방법(Analytical IK)과 수치적 방법(Numerical IK, 야코비안 기반)이 있습니다.

수치적 역기구학의 핵심은 **야코비안(Jacobian) 행렬** $J$를 이용한 반복 계산입니다.

$$\Delta \theta = J^+ \cdot \Delta x$$

여기서 $J^+$는 야코비안의 의사역행렬(pseudoinverse)입니다.

2. ROS2 (Robot Operating System 2)

ROS1 vs ROS2 핵심 차이

ROS2는 ROS1의 단점을 극복하기 위해 **DDS(Data Distribution Service)** 기반 통신으로 재설계되었습니다.

| 항목 | ROS1 | ROS2 |

| ------------- | ------------ | ------------------- |

| 통신 미들웨어 | 자체 TCP/UDP | DDS (OMG 표준) |

| 실시간 지원 | 미흡 | 지원 (rclcpp rt) |

| Python 버전 | Python 2/3 | Python 3 전용 |

| 보안 | 없음 | SROS2 (TLS/DDS) |

| 멀티 로봇 | 어려움 | 네임스페이스로 용이 |

| 수명주기 노드 | 없음 | LifecycleNode 지원 |

핵심 개념: 노드, 토픽, 서비스, 액션

- **노드(Node)**: 독립적인 실행 단위. 하나의 프로세스 또는 여러 노드 포함 가능

- **토픽(Topic)**: 발행(publish)/구독(subscribe) 비동기 메시지 통신

- **서비스(Service)**: 요청/응답(request/response) 동기 통신

- **액션(Action)**: 장기 실행 작업용 비동기 통신 (피드백 포함)

ROS2 Python 퍼블리셔/서브스크라이버 예제

from rclpy.node import Node

from std_msgs.msg import String

class TalkerNode(Node):

def __init__(self):

super().__init__('talker')

self.publisher = self.create_publisher(String, 'chatter', 10)

self.timer = self.create_timer(0.5, self.publish_msg)

self.count = 0

def publish_msg(self):

msg = String()

msg.data = f'Hello ROS2: {self.count}'

self.publisher.publish(msg)

self.get_logger().info(f'Published: {msg.data}')

self.count += 1

class ListenerNode(Node):

def __init__(self):

super().__init__('listener')

self.subscription = self.create_subscription(

String, 'chatter', self.callback, 10

)

def callback(self, msg):

self.get_logger().info(f'Received: {msg.data}')

def main():

rclpy.init()

talker = TalkerNode()

rclpy.spin(talker)

rclpy.shutdown()

런치 파일 예제

launch/my_robot.launch.py

from launch import LaunchDescription

from launch_ros.actions import Node

def generate_launch_description():

return LaunchDescription([

Node(

package='my_robot',

executable='talker',

name='talker_node',

output='screen',

parameters=[{'use_sim_time': False}],

Node(

package='my_robot',

executable='listener',

name='listener_node',

output='screen',

])

실행: `ros2 launch my_robot my_robot.launch.py`

3. 센서 처리

LiDAR: Point Cloud 처리

LiDAR(Light Detection And Ranging)는 레이저를 이용해 3D 포인트 클라우드를 생성합니다. 자율주행 및 3D 매핑에 필수적입니다.

def process_pointcloud(pcd_path):

포인트 클라우드 로드

pcd = o3d.io.read_point_cloud(pcd_path)

통계적 이상치 제거

pcd_clean, _ = pcd.remove_statistical_outlier(

nb_neighbors=20, std_ratio=2.0

)

Voxel downsampling (해상도 축소)

pcd_down = pcd_clean.voxel_down_sample(voxel_size=0.05)

법선 추정

pcd_down.estimate_normals(

search_param=o3d.geometry.KDTreeSearchParamHybrid(

radius=0.1, max_nn=30

)

RANSAC 평면 분할 (지면 제거)

plane_model, inliers = pcd_down.segment_plane(

distance_threshold=0.01,

ransac_n=3,

num_iterations=1000

)

[a, b, c, d] = plane_model

print(f"지면 평면 방정식: {a:.2f}x + {b:.2f}y + {c:.2f}z + {d:.2f} = 0")

지면 제외 객체만 추출

objects_pcd = pcd_down.select_by_index(inliers, invert=True)

return objects_pcd

IMU와 칼만 필터

IMU(관성 측정 장치)는 가속도계와 자이로스코프를 포함하며, 로봇의 방향과 속도를 추정합니다. **칼만 필터**를 이용해 노이즈를 줄이고 정확한 상태 추정을 수행합니다.

칼만 필터의 두 단계:

1. **예측(Predict)**: 이전 상태와 모션 모델로 현재 상태 예측

2. **업데이트(Update)**: 센서 측정값으로 예측값 보정

$$\hat{x}_{k|k} = \hat{x}_{k|k-1} + K_k(z_k - H\hat{x}_{k|k-1})$$

여기서 $K_k$는 칼만 이득(Kalman Gain), $z_k$는 측정값입니다.

4. SLAM (Simultaneous Localization and Mapping)

SLAM이란?

**SLAM**은 로봇이 미지의 환경에서 동시에 지도를 작성하고 자신의 위치를 추정하는 기술입니다. 로봇 탐색과 자율주행의 핵심 문제입니다.

SLAM의 핵심 과제:

- **Data Association**: 현재 관측이 어떤 랜드마크에 해당하는지 매칭

- **Loop Closure**: 이전에 방문한 장소를 인식하여 누적 오차 보정

- **Map Representation**: 특징점 맵, 격자 맵, 위상 맵 등

EKF-SLAM

**확장 칼만 필터(EKF)**를 이용한 SLAM. 비선형 로봇 운동/관측 모델을 1차 테일러 전개로 선형화합니다.

상태 벡터: 로봇 포즈 + 모든 랜드마크 위치

$$x = [x_r, y_r, \theta_r, x_{l1}, y_{l1}, x_{l2}, y_{l2}, \ldots]^T$$

계산 복잡도가 랜드마크 수 $n$에 대해 $O(n^2)$이므로 대규모 환경에서는 한계가 있습니다.

실제 SLAM 라이브러리

| 라이브러리 | 방법 | 센서 | 특징 |

| ------------ | --------------- | ------------ | ---------------------- |

Cartographer ROS2 설치 및 실행

sudo apt install ros-humble-cartographer-ros

Cartographer 실행 (예: TurtleBot3)

ros2 launch turtlebot3_cartographer cartographer.launch.py

5. 모션 플래닝

경로 계획 알고리즘 개요

모션 플래닝은 장애물을 피하면서 시작점에서 목표점까지의 경로를 찾는 문제입니다.

- **Grid-based**: A\*, Dijkstra - 격자 맵에서 최적 경로

- **Sampling-based**: RRT, PRM - 고차원 구성 공간에 효율적

- **Optimization-based**: CHOMP, STOMP - 비용 함수 최적화

RRT\* 구현

**RRT\*(Rapidly-exploring Random Tree Star)**는 점근적 최적성을 보장하는 샘플링 기반 알고리즘입니다.

def rrt_star(start, goal, obstacles, max_iter=1000, step=0.5, goal_radius=0.5):

"""

간단한 2D RRT* 구현

start, goal: np.array([x, y])

obstacles: [(cx, cy, radius), ...]

"""

nodes = [start]

parents = [-1]

costs = [0.0]

def is_collision(p1, p2):

"""선분 p1-p2가 장애물과 충돌하는지 검사"""

for (cx, cy, r) in obstacles:

center = np.array([cx, cy])

d = p2 - p1

t = np.clip(np.dot(center - p1, d) / (np.dot(d, d) + 1e-9), 0, 1)

closest = p1 + t * d

if np.linalg.norm(closest - center) < r:

return True

return False

for _ in range(max_iter):

rand = goal if np.random.random() < 0.05 else np.random.uniform(-10, 10, 2)

dists = [np.linalg.norm(np.array(n) - rand) for n in nodes]

nearest_idx = int(np.argmin(dists))

nearest = np.array(nodes[nearest_idx])

direction = rand - nearest

norm = np.linalg.norm(direction)

if norm < 1e-9:

continue

new_node = nearest + step * direction / norm

if is_collision(nearest, new_node):

continue

nodes.append(new_node)

parents.append(nearest_idx)

costs.append(costs[nearest_idx] + step)

if np.linalg.norm(new_node - goal) < goal_radius:

print(f"목표 도달! 총 노드 수: {len(nodes)}")

return nodes, parents

실행 예시

start = np.array([0.0, 0.0])

goal = np.array([9.0, 9.0])

obstacles = [(5.0, 5.0, 1.5), (3.0, 7.0, 1.0)]

nodes, parents = rrt_star(start, goal, obstacles)

MoveIt2와 로봇팔 모션 플래닝

MoveIt2는 ROS2에서 로봇팔 모션 플래닝을 위한 표준 프레임워크입니다.

MoveIt2 Python API 예시

from moveit.planning import MoveItPy

from moveit.core.robot_state import RobotState

rclpy.init()

moveit = MoveItPy(node_name='moveit_py_planning')

panda_arm = moveit.get_planning_component('panda_arm')

목표 포즈 설정

from geometry_msgs.msg import PoseStamped

goal_pose = PoseStamped()

goal_pose.header.frame_id = 'panda_link0'

goal_pose.pose.position.x = 0.5

goal_pose.pose.position.y = 0.0

goal_pose.pose.position.z = 0.5

goal_pose.pose.orientation.w = 1.0

panda_arm.set_goal_state(pose_stamped_msg=goal_pose, pose_link='panda_hand')

경로 계획 및 실행

plan_result = panda_arm.plan()

if plan_result:

moveit.execute(plan_result.trajectory)

6. 컴퓨터 비전과 로봇

물체 감지 (Object Detection)

로봇이 환경을 인식하기 위해 **YOLO(You Only Look Once)** 계열 모델이 실시간 물체 감지에 널리 사용됩니다.

from ultralytics import YOLO

YOLOv11 로드

model = YOLO('yolo11n.pt')

def detect_objects(frame):

"""카메라 프레임에서 물체 감지"""

results = model(frame, conf=0.5)

annotated = results[0].plot()

for box in results[0].boxes:

cls_id = int(box.cls[0])

label = model.names[cls_id]

conf = float(box.conf[0])

x1, y1, x2, y2 = map(int, box.xyxy[0])

print(f"{label}: {conf:.2f} at ({x1},{y1})-({x2},{y2})")

return annotated

웹캠 실시간 감지

cap = cv2.VideoCapture(0)

while cap.isOpened():

ret, frame = cap.read()

if not ret:

break

annotated_frame = detect_objects(frame)

cv2.imshow('Robot Vision', annotated_frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cap.release()

6D 포즈 추정

로봇 파지(grasping)를 위해 물체의 6D 포즈(위치 3D + 방향 3D)를 추정합니다. **PnP(Perspective-n-Point)** 알고리즘을 이용합니다.

def estimate_pose(object_points, image_points, camera_matrix, dist_coeffs):

"""

PnP 알고리즘으로 6D 포즈 추정

object_points: 3D 점 (물체 좌표계)

image_points: 2D 점 (이미지 좌표)

"""

success, rvec, tvec = cv2.solvePnP(

object_points, image_points,

camera_matrix, dist_coeffs,

flags=cv2.SOLVEPNP_ITERATIVE

)

if success:

R, _ = cv2.Rodrigues(rvec)

print(f"위치: {tvec.flatten()}")

print(f"회전 행렬:\n{R}")

return R, tvec

return None, None

7. 강화학습 기반 로봇 제어

로봇 강화학습 환경

| 시뮬레이터 | 개발사 | 특징 | 용도 |

| ---------- | --------------- | ---------------------------- | -------------- |

SAC를 이용한 연속 제어 학습

**SAC(Soft Actor-Critic)**는 엔트로피 정규화를 통해 탐색과 활용을 균형 있게 유지하는 오프-정책 강화학습 알고리즘입니다.

from stable_baselines3 import SAC

from stable_baselines3.common.callbacks import EvalCallback

MuJoCo Ant 환경에서 SAC 학습

env = gym.make('Ant-v4', render_mode=None)

eval_env = gym.make('Ant-v4', render_mode=None)

최적 모델 저장 콜백

eval_callback = EvalCallback(

eval_env,

best_model_save_path='./logs/best_model',

log_path='./logs/',

eval_freq=10000,

deterministic=True,

render=False

)

SAC 모델 생성

model = SAC(

'MlpPolicy',

env,

verbose=1,

learning_rate=3e-4,

buffer_size=1_000_000,

batch_size=256,

ent_coef='auto',

gamma=0.99,

tau=0.005,

tensorboard_log='./tb_logs/'

)

학습

model.learn(total_timesteps=1_000_000, callback=eval_callback)

model.save('ant_sac_final')

추론 (배포)

obs, _ = env.reset()

total_reward = 0

for _ in range(1000):

action, _ = model.predict(obs, deterministic=True)

obs, reward, done, truncated, info = env.step(action)

total_reward += reward

if done or truncated:

print(f"에피소드 종료, 총 보상: {total_reward:.2f}")

obs, _ = env.reset()

total_reward = 0

Sim-to-Real 전이

시뮬레이션에서 학습한 정책을 실제 로봇에 적용할 때 발생하는 **Reality Gap** 문제를 해결하는 기법들:

1. **도메인 랜덤화(Domain Randomization)**: 시뮬레이션에서 물리 파라미터(마찰, 질량, 관절 강성)를 무작위로 변화시켜 실제 환경 변이에 강인한 정책 학습

2. **도메인 적응(Domain Adaptation)**: 실제 환경 데이터로 정책을 미세 조정

3. **시스템 식별(System Identification)**: 실제 로봇의 물리 파라미터를 정확히 측정하여 시뮬레이터에 반영

8. 자율주행

SAE 자율주행 레벨

| 레벨 | 이름 | 설명 | 예시 |

| ---- | ------------- | ------------------- | -------------------- |

| L5 | 완전 자동화 | 모든 조건 자율 | (미실현) |

인식-예측-계획-제어 파이프라인

class AutonomousDrivingSystem:

"""자율주행 시스템의 기본 파이프라인"""

def __init__(self, perception, prediction, planning, control):

self.perception = perception # 인식 모듈

self.prediction = prediction # 예측 모듈

self.planning = planning # 계획 모듈

self.control = control # 제어 모듈

def run_step(self, sensor_data):

1. 인식: 센서 데이터에서 객체 감지 및 추적

detected_objects = self.perception.detect(sensor_data)

ego_state = self.perception.localize(sensor_data)

2. 예측: 주변 차량/보행자 미래 궤적 예측

predicted_trajectories = self.prediction.predict(

detected_objects, horizon=3.0 # 3초 예측

)

3. 계획: 목표까지 안전한 경로 계획

trajectory = self.planning.plan(

ego_state, predicted_trajectories, goal=self.goal

)

4. 제어: 계획된 경로 추종

steering, throttle, brake = self.control.compute(

ego_state, trajectory

)

return steering, throttle, brake

9. 휴머노이드 로봇 2026

2026년 휴머노이드 로봇 시장은 급격히 성장하고 있습니다. 주요 플레이어들의 최신 현황을 살펴봅니다.

주요 휴머노이드 로봇 비교

| 로봇 | 회사 | 높이/무게 | 주요 특징 |

| ------------- | ---------------- | ------------ | ---------------------------- |

로봇 파운데이션 모델

**RT-2(Robotics Transformer 2)**는 Google DeepMind가 개발한 비전-언어-행동 모델로, 웹 데이터에서 학습한 지식을 로봇 제어에 직접 활용합니다. 자연어 명령을 이해하고 새로운 객체에도 일반화할 수 있습니다.

**OpenVLA**는 오픈소스 VLA(Vision-Language-Action) 모델로, 연구자들이 자체 로봇 데이터로 파인튜닝하여 사용할 수 있습니다.

OpenVLA 추론 예시 (개념 코드)

from transformers import AutoModelForVision2Seq, AutoProcessor

model_name = "openvla/openvla-7b"

processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)

model = AutoModelForVision2Seq.from_pretrained(

model_name,

torch_dtype=torch.bfloat16,

device_map='auto',

trust_remote_code=True

)

비전-언어 명령으로 행동 생성

image = get_camera_image() # 로봇 카메라 이미지

instruction = "pick up the red block and place it in the box"

inputs = processor(instruction, image).to('cuda:0', dtype=torch.bfloat16)

action = model.predict_action(**inputs, unnorm_key='bridge_orig', do_sample=False)

action: [dx, dy, dz, droll, dpitch, dyaw, gripper]

robot.execute_action(action)

임베디드 AI와 온디바이스 추론

휴머노이드 로봇의 두뇌는 클라우드 의존 없이 실시간으로 동작해야 합니다. NVIDIA Jetson Orin, Qualcomm Robotics RB5 같은 엣지 AI 칩이 핵심입니다.

- **NVIDIA Jetson AGX Orin**: 275 TOPS, 로봇 AI 추론 표준

- **양자화(Quantization)**: INT8/FP16으로 모델 경량화

- **TensorRT**: NVIDIA GPU 추론 최적화 엔진

10. 퀴즈: 로보틱스 & AI 핵심 개념

**정답**: 로봇이 이전에 방문했던 장소를 인식하여 누적된 위치 추정 오류를 보정하기 위해서입니다.

**설명**: 장기간 탐색 시 작은 오차가 누적되어 큰 위치 오류가 발생합니다. Loop Closure가 감지되면 그래프 최적화(예: g2o, iSAM2)를 통해 전체 궤적의 오차를 수정합니다. 이 과정 없이는 지도가 점점 왜곡됩니다.

**정답**: 표준화된 미들웨어, 실시간 지원, 멀티 로봇 환경에서의 네트워크 유연성, 보안(SROS2) 지원입니다.

**설명**: ROS1은 단일 roscore에 의존해 단일 장애점이 존재했습니다. DDS 기반 ROS2는 분산형 아키텍처로 roscore 없이 노드 간 직접 통신이 가능하며, QoS(Quality of Service) 정책으로 통신 신뢰성을 세밀하게 제어할 수 있습니다.

**정답**: 정책의 무작위성(탐색 수준)을 보상의 일부로 포함시켜, 에이전트가 과도하게 결정론적인 행동에 수렴하지 않고 다양한 행동을 유지하도록 합니다.

**설명**: SAC의 목표 함수는 기대 보상과 정책 엔트로피의 합입니다. 엔트로피 계수(alpha)가 클수록 탐색을 더 강조하며, auto 설정 시 목표 엔트로피에 맞게 자동 조정됩니다. 이를 통해 지역 최적해 함정에 빠지는 것을 방지합니다.

**정답**: IK는 해가 존재하지 않거나, 하나가 아닌 복수의 해가 존재하는 비선형 방정식 시스템이기 때문입니다.

**설명**: FK는 관절 각도가 주어지면 유일한 엔드이펙터 포즈를 계산하는 단방향 함수입니다. 반면 IK는 목표 포즈에서 역산하는 과정으로, 7-DOF 이상의 여유 자유도 로봇은 무한히 많은 해를 가지며(redundancy), 작업 공간 경계에서는 해가 없을 수 있습니다. 특이점(singularity) 근처에서는 야코비안이 singular해져 수치적 불안정성이 발생합니다.

**정답**: 다양한 시뮬레이션 환경에서 학습함으로써 실제 환경의 불확실성과 변동성에 강인한(robust) 정책을 학습하기 때문입니다.

**설명**: 단일 시뮬레이션 파라미터로 학습하면 실제 환경의 마찰, 액추에이터 지연, 센서 노이즈 등의 차이로 인해 성능이 급격히 저하됩니다. 도메인 랜덤화는 이러한 파라미터를 학습 중 무작위로 변화시켜 정책이 다양한 물리 조건에 적응하도록 강제합니다. OpenAI의 Dextrous Hand 연구가 이 방법의 대표적 성공 사례입니다.

참고 자료

- [ROS2 공식 문서](https://docs.ros.org/en/humble/)

- [MuJoCo 문서](https://mujoco.readthedocs.io/)

- [OpenAI Spinning Up](https://spinningup.openai.com/)

- [RT-2 논문 (Google DeepMind)](https://arxiv.org/abs/2307.15818)

- [MoveIt2 문서](https://moveit.picknik.ai/)

- [Open3D 문서](http://www.open3d.org/docs/)

- [Stable Baselines3](https://stable-baselines3.readthedocs.io/)