FlmainGO-Light Python SDK [한국어]

1. 시작하기

1.1 로봇 움직여보기

로봇의 전원 버튼을 켠 뒤, 두 번째 부저음이 들릴 때까지 기다립니다. 두 번째 부저음은 로봇 부팅이 완료되어 조작할 준비가 되었다는 신호입니다.

부팅이 완료되면 조이스틱의 LT를 길게 눌러 로봇을 일으켜 봅니다.

로봇은 아래와 같이 조작할 수 있습니다.

입력	동작
LT 길게 누르기	로봇이 일어납니다.
RT 길게 누르기	로봇이 앉습니다.
왼쪽 조이스틱	로봇을 앞뒤 또는 좌우로 이동합니다.
LT + RT 동시에 한 번 누르기	모터가 현재 위치에 고정됩니다. 비상 정지용으로 사용할 수 있습니다.
LT + RT 동시에 한 번 더 누르기	모든 모터가 idle 상태가 됩니다.

1.2 SSH 접속

로봇의 전원을 켜면 Wi-Fi 핫스팟이 자동으로 활성화됩니다. 활성화된 Wi-Fi를 통해 로봇에 접속할 수 있습니다.

XXXX는 각 로봇마다 고유한 4자리 영문/숫자 조합 태그입니다.

# 1) Wi-Fi 연결
# COCELO_ROBOT_XXXX 네트워크에 연결합니다.

# 2) SSH 접속
ssh cocelo@XXXX    # XXXX = Wi-Fi SSID와 동일한 태그
                   # 비밀번호: 00000000

1.3 펌웨어 업그레이드

본 SDK는 로봇 펌웨어 0.1.8 버전 이상에서 사용하는 것을 권장합니다. SDK를 사용하기 전에 아래 방법으로 먼저 펌웨어를 업그레이드하세요. 로봇에 추가 LAN 포트가 있는 경우, 해당 포트에 외부 인터넷이 연결된 LAN 케이블을 꽂은 뒤 펌웨어를 설치합니다. (LAN 포트가 없거나 LAN 연결을 사용할 수 없는 경우에는 10. SDK 업데이트의 Wi-Fi 연결 방법을 참고하세요.)

펌웨어 다운로드

rm -r fx-core-release
git clone -b f4-light-core_0.1.8-1_arm64 --single-branch https://github.com/cocelo-ai/fx-core-release.git

펌웨어 설치

sudo apt install ./fx-core-release/f4-light-core_0.1.8-1_arm64.deb

1.4 SDK 다운로드

로봇에 추가 LAN 포트가 있는 경우, 해당 포트에 외부 인터넷이 연결된 LAN 케이블을 꽂은 뒤 SDK를 설치합니다.

pip install f4-light-sdk

이미 설치된 SDK를 최신 버전으로 업데이트하려면 다음 명령어를 사용합니다.

pip install -U f4-light-sdk

LAN 포트가 없거나 LAN 연결을 사용할 수 없는 경우에는 10. SDK 업데이트의 Wi-Fi 연결 방법을 참고하세요.

1.5 실행 로그 보기

cocelo log list
cocelo log show last
cocelo log show <파일명>

---

2. 기본 실행 흐름

아래 예제는 SDK를 사용해 정책을 실행하는 기본 형태입니다. 실제 프로젝트에서는 정책 파일 경로와 RlConfig 값을 학습한 정책에 맞게 수정해서 사용합니다.

from pathlib import Path
from f4_light_sdk import *


def run():
    this_dir = Path(__file__).resolve().parent
    policy_path = str(this_dir / "example_policy.onnx")

    kp = [35, 35, 0, 0]
    kd = [0.45, 0.45, 0.3, 0.3]

    rl_config = RlConfig(config={
        "stacked_obs_order": ["dof_pos", "dof_vel", "ang_vel", "proj_grav", "last_action"],
        "non_stacked_obs_order": ["command"],
        "obs_scale": {
            "dof_vel": 0.05,
            "ang_vel": 0.25,
            "command": [2.0, 0.0, 0.25, 0.0],
        },
        "action_scale": [0.25, 0.25, 40.0, 40.0],
        "history_length": 3,
        "policy_path": policy_path,
        "cmd_vector_length": 4,
        "clip_actions": False,
    })

    robot = Robot()
    robot.set_gains(kp=kp, kd=kd)

    joystick = Joystick(
        cmd_mapping=["left_y", "right_x", "left_x", "right_y"],
    )

    rl = RL()
    rl.set_config(rl_config)

    @control_rate(robot, hz=50)
    def loop():
        obs = robot.get_obs()
        cmd = joystick.get_cmd()
        state = rl.build_state(obs, cmd)
        action = rl.select_action(state)
        robot.do_action(action)

    loop()


if __name__ == "__main__":
    run()

제어 루프의 핵심 순서는 다음과 같습니다.

get_obs() → get_cmd() → build_state() → select_action() → do_action()

---

3. 핵심 컴포넌트

일반적인 정책 실행에 필요한 공개 API는 아래 5개입니다.

컴포넌트	역할
Robot	로봇 user mode 진입, 센서 관측 수신, 게인 설정, 모터 명령 전송, 종료 처리
Joystick	조이스틱 입력을 command vector로 변환
RlConfig	관측 구성, 스케일, 히스토리 길이, 정책 경로 등 RL 실행 설정 정의
RL	obs와 cmd를 정책 입력 state로 만들고, 정책 출력 action을 선택
control_rate	지정한 주기로 제어 루프를 반복 실행

---

4. Robot

robot = Robot()

Robot은 로봇의 센서 관측을 읽고 모터 명령을 전송하는 클래스입니다.

생성자

Robot()

set_gains(kp, kd)

4개 모터의 PD 게인을 설정합니다.

kp = [35, 35, 0, 0]
kd = [0.45, 0.45, 0.3, 0.3]
robot.set_gains(kp=kp, kd=kd)

kp, kd는 반드시 길이 4여야 합니다.

인덱스	대상
0	왼쪽 관절 모터
1	오른쪽 관절 모터
2	왼쪽 바퀴 모터
3	오른쪽 바퀴 모터

do_action()을 호출하기 전에는 반드시 set_gains()를 먼저 호출해야 합니다. 그렇지 않으면 런타임 에러가 발생합니다.

get_obs()

현재 센서 관측값을 가져옵니다.

obs = robot.get_obs()

get_obs()는 처음 호출될 때 user mode를 활성화합니다. 내부적으로 기존 observation queue를 비운 뒤 새 관측을 요청하므로, 오래된 관측값이 아니라 최신 snapshot을 받도록 동작합니다.

반환값은 dict[str, list[float]] 형태입니다. 기본적으로 정책 설정에서 사용할 수 있는 주요 관측 key는 다음과 같습니다.

key	길이	설명
dof_pos	2	관절 위치
dof_vel	4	관절/바퀴 속도
dof_tau	4	모터 토크 관측값
ang_vel	3	각속도
proj_grav	3	projected gravity

do_action(action, torque_ctrl=False)

4개 모터에 명령을 전송합니다.

robot.do_action([0.1, 0.2, 1.0, -1.0])
robot.do_action([0.0, 0.0, 0.0, 0.0], torque_ctrl=True)

action은 반드시 길이 4여야 합니다.

인덱스	기본 제어 의미
0	왼쪽 관절 모터 위치 명령
1	오른쪽 관절 모터 위치 명령
2	왼쪽 바퀴 모터 속도 명령
3	오른쪽 바퀴 모터 속도 명령

torque_ctrl=True이면 action 값이 토크 명령으로 전송됩니다. 이 경우 정책 학습 시의 action 정의와 실제 실행 시의 action 정의가 반드시 일치해야 합니다.

enable_user_mode()

user mode를 명시적으로 활성화합니다.

일반적으로 직접 호출할 필요는 없습니다. get_obs() 또는 do_action() 호출 시 내부적으로 user mode가 활성화됩니다.

finish()

user mode를 해제하는 종료 처리입니다.

robot.finish()

finish()는 user mode가 활성화된 경우에만 동작합니다. 예제처럼 control_rate()를 사용하면 KeyboardInterrupt나 예외 발생 시 자동으로 호출됩니다.

---

5. Joystick

joystick = Joystick(
    cmd_mapping=[],
    cmd_range=None,
)

Joystick은 조이스틱 입력을 RL에서 사용할 cmd_vector로 변환합니다.

생성자 인자

인자	기본값	설명
cmd_mapping	[]	command vector에 넣을 조이스틱 key 순서
cmd_range	None	각 key의 출력 범위

사용 가능한 command key

내부 motion command slot은 총 8개입니다.

key	설명
left_x	왼쪽 스틱 X축
left_y	왼쪽 스틱 Y축
right_x	오른쪽 스틱 X축
right_y	오른쪽 스틱 Y축
dpad_x	D-pad 좌우
dpad_y	D-pad 상하
left_btn	왼쪽 버튼
right_btn	오른쪽 버튼

기본 command 설정

cmd_mapping과 cmd_range를 생략하면 아래 설정이 사용됩니다.

command index	조이스틱 입력	기본 범위
cmd_vector[0]	left_y	(-0.5, 0.5)
cmd_vector[1]	right_x	(-1.5, 1.5)
cmd_vector[2]	left_x	(-1.0, 1.0)
cmd_vector[3]	right_y	(-1.0, 1.0)
cmd_vector[4]	dpad_x	(-1.0, 1.0)
cmd_vector[5]	dpad_y	(-1.0, 1.0)
cmd_vector[6]	left_btn	(0.0, 1.0)
cmd_vector[7]	right_btn	(0.0, 1.0)

cmd_mapping은 command vector의 순서를 정하고, cmd_range는 각 key의 출력 범위를 정합니다. 따라서 range는 index가 아니라 left_y, right_x 같은 key 이름에 적용됩니다.

사용자 지정 mapping

joystick = Joystick(
    cmd_mapping=["left_y", "right_x", "left_x", "right_y"],
)

위 설정에서는 RL이 보는 command vector가 다음처럼 구성됩니다.

command index	조이스틱 입력	기본 범위
cmd_vector[0]	left_y	(-0.5, 0.5)
cmd_vector[1]	right_x	(-1.5, 1.5)
cmd_vector[2]	left_x	(-1.0, 1.0)
cmd_vector[3]	right_y	(-1.0, 1.0)

cmd_mapping에 적은 key 순서가 그대로 cmd_vector의 순서가 됩니다. 정책을 학습할 때 사용한 command 순서와 실행 시 mapping 순서가 다르면 정책 입력 의미가 바뀌므로 반드시 일치시켜야 합니다.

cmd_mapping에 포함하지 않은 key도 내부적으로는 사용 가능한 slot에 자동 할당됩니다. 다만 get_cmd()가 반환하는 cmd_vector 길이는 사용자가 지정한 cmd_mapping 길이입니다.

mapping 검증 규칙

cmd_mapping은 다음 조건을 만족해야 합니다.

• 길이는 최대 8입니다.

• key는 위의 command key 중 하나여야 합니다.

• 같은 key를 중복해서 넣을 수 없습니다.

사용자 지정 range

joystick = Joystick(
    cmd_mapping=["left_y", "right_x", "left_x", "right_y"],
    cmd_range={
        "left_x": (-0.5, 0.5),
        "left_y": (-0.5, 0.5),
        "right_x": (-1.5, 1.5),
        "right_y": (-0.5, 0.5),
        "dpad_x": (-1.0, 1.0),   # cmd_mapping에 없기 때문에 반영 x
        "dpad_y": (-1.0, 1.0),   # cmd_mapping에 없기 때문에 반영 x
        "left_btn": (0.0, 1.0),  # cmd_mapping에 없기 때문에 반영 x
        "right_btn": (0.0, 1.0), # cmd_mapping에 없기 때문에 반영 x
        "dpad_step_x": 0.1,      # cmd_mapping에 없기 때문에 반영 x
        "dpad_step_y": 0.1,      # cmd_mapping에 없기 때문에 반영 x
    },
)

일반 command key는 (min, max) 형태의 tuple 또는 list를 사용합니다.

"left_y": (-0.5, 0.5)

dpad_step_x, dpad_step_y는 특별 key이며 단일 숫자를 사용합니다.

"dpad_step_x": 0.1
"dpad_step_y": 0.1

range 검증 규칙:

• cmd_range의 key는 valid command key이거나 dpad_step_x, dpad_step_y여야 합니다.

• 일반 key의 값은 길이 2의 tuple/list여야 합니다.

• min/max 값은 finite number여야 합니다.

• min은 max보다 클 수 없습니다.

• dpad_step_x, dpad_step_y는 0 이상의 finite number여야 합니다.

get_cmd()

cmd = joystick.get_cmd()
print(cmd)

# 예:
# {"cmd_vector": [0.0, 0.0, 0.0, 0.0]}

cmd_vector는 다음처럼 꺼내서 사용할 수 있습니다.

cmd_vector = cmd["cmd_vector"]

조이스틱 command를 제한 시간 안에 읽지 못하면, cmd_mapping 길이와 같은 zero vector를 반환합니다.

---

6. RlConfig

rl_config = RlConfig(config={...})

RlConfig는 RL 정책 실행에 필요한 설정을 정의하고 검증합니다. 정책 파일 경로, 관측 순서, 관측 길이, 히스토리 길이, 스케일, action clipping 설정을 포함합니다.

기본 예

rl_config = RlConfig(config={
    "stacked_obs_order": ["dof_pos", "dof_vel", "ang_vel", "proj_grav", "last_action"],
    "non_stacked_obs_order": ["command"],
    "obs_scale": {
        "dof_vel": 0.05,
        "ang_vel": 0.25,
        "command": [2.0, 0.0, 0.25, 0.0],
    },
    "action_scale": [0.25, 0.25, 40.0, 40.0],
    "history_length": 3,
    "policy_path": policy_path,
    "policy_type": "MLP",
    "cmd_vector_length": 4,
    "clip_actions": False,
})

config key

key	필수 여부	설명
stacked_obs_order	선택	히스토리에 쌓을 관측 key 순서
non_stacked_obs_order	선택	히스토리에 쌓지 않고 현재 값만 사용할 관측 key 순서
obs_scale	선택	관측값별 scale
action_scale	선택	정책 출력 action에 곱할 scale. 생략 시 전부 1.0
history_length	선택	stacked observation history 길이. 기본값 2
policy_path	필수	.onnx 정책 파일 경로
policy_type	선택	"MLP" 또는 "LSTM". 기본값 "MLP"
cmd_vector_length	선택	command 관측 길이. 기본값 0
clip_actions	선택	None/False이면 비활성화, 양수이면 정책 출력 clip 범위
extra_obs	선택	사용자 정의 관측 key와 길이

기본 관측 key와 길이

RlConfig가 기본으로 알고 있는 관측 key는 다음과 같습니다.

key	길이
dof_pos	2
dof_vel	4
lin_vel	3
ang_vel	3
proj_grav	3
last_action	4
command	cmd_vector_length

command의 길이는 cmd_vector_length 설정값에 따라 결정됩니다.

extra_obs

기본 관측 외에 사용자 정의 관측값을 추가할 수 있습니다.

rl_config = RlConfig(config={
    "extra_obs": {
        "latent": 8,
        "custom_sensor": 4,
    },
    "stacked_obs_order": ["dof_pos", "dof_vel", "latent"],
    "non_stacked_obs_order": ["custom_sensor"],
    "policy_path": policy_path,
})

extra_obs 규칙:

• key는 비어 있지 않은 문자열이어야 합니다.

• 길이는 1 이상의 정수여야 합니다.

• 기본 관측 key와 이름이 충돌하면 안 됩니다.

제어 루프에서는 같은 key를 obs에 추가해야 합니다.

obs = robot.get_obs()
obs["latent"] = [0.0] * 8
obs["custom_sensor"] = [0.0] * 4

history_length와 stack_size

현재 설정 key는 history_length입니다.

"history_length": 3

history_length는 1 이상이어야 합니다.

legacy key인 stack_size도 입력으로 받을 수 있지만, 내부적으로 다음처럼 변환됩니다.

history_length = stack_size + 1

history_length와 stack_size를 동시에 설정하면 에러가 발생합니다.

policy_path

policy_path는 필수입니다.

"policy_path": "weights/drive.onnx"

검증 규칙:

• 비어 있으면 안 됩니다.

• 실제 존재하는 regular file이어야 합니다.

• 확장자는 .onnx여야 합니다.

policy_type

"policy_type": "MLP"

지원 값은 다음 두 가지입니다.

• "MLP"

• "LSTM"

대소문자는 내부적으로 lower-case 비교됩니다. 일반적인 예제에서는 생략해도 되며, 기본값은 "MLP"입니다.

obs_scale

관측값에 곱할 scale을 지정합니다.

스칼라를 주면 해당 관측값 전체 요소에 같은 scale이 적용됩니다.

"obs_scale": {
    "dof_vel": 0.05,
    "ang_vel": 0.25,
}

리스트를 주면 요소별 scale이 적용됩니다. 리스트 길이는 해당 관측값 길이와 정확히 일치해야 합니다.

"obs_scale": {
    "command": [2.0, 0.0, 0.25, 0.0],
}

scale 값은 숫자여야 하며, bool은 허용되지 않습니다.

obs_scale을 지정하지 않은 관측값은 기본 scale 1.0이 사용됩니다.

action_scale

정책 출력 action에 곱할 scale입니다.

"action_scale": [0.25, 0.25, 40.0, 40.0]

action_scale은 스칼라 또는 길이 4 리스트가 될 수 있습니다. 생략하면 [1.0, 1.0, 1.0, 1.0]이 사용됩니다.

RL.select_action()은 다음 순서로 동작합니다.

raw_action = policy(state)
scaled_action = raw_action * action_scale
return scaled_action

robot.do_action()에는 scale이 적용된 action이 전달됩니다.

clip_actions

정책 출력 action을 clip할지 설정합니다.

"clip_actions": False   # 비활성화
"clip_actions": None    # 비활성화
"clip_actions": 1.0     # [-1.0, 1.0] 범위로 clip

True는 허용되지 않습니다. clip을 사용하려면 양수를 직접 넣어야 합니다.

정책 출력에 NaN 또는 Inf가 포함되면 내부적으로 0으로 정리된 뒤, clip_actions가 설정되어 있으면 지정 범위로 clip됩니다.

읽기 전용 속성

RlConfig 생성 후 다음 속성을 확인할 수 있습니다.

속성	설명
obs_lengths	관측 key별 길이
history_length	history 길이
state_length	최종 state 벡터 길이
action_length	action 길이, 일반적으로 4
policy_type	정책 타입
policy_path	정책 파일 경로
stacked_obs_order	stacked 관측 순서
non_stacked_obs_order	non-stacked 관측 순서
action_scale	정규화된 action scale
clip_actions	action clip 설정
obs_scale	정규화된 관측 scale
cmd_vector_length	command vector 길이

print(rl_config.state_length)
print(rl_config.obs_lengths)
print(rl_config.action_scale)

---

7. RL

rl = RL()
rl.set_config(rl_config)

RL은 RlConfig를 받아 state buffer를 구성하고, obs와 cmd를 정책 입력으로 변환한 뒤 action을 선택합니다.

set_config(config)

rl.set_config(rl_config)

set_config()를 호출해야 build_state()와 select_action()을 사용할 수 있습니다. 호출하지 않으면 런타임 에러가 발생합니다.

set_config() 시 내부적으로 다음 값이 준비됩니다.

• 관측 key별 길이

• stacked frame 길이

• 전체 state 길이

• history buffer

• action scale

• policy inference 함수

build_state(obs, cmd, last_action=None)

state = rl.build_state(obs, cmd)

obs와 cmd를 1D state vector로 변환합니다.

입력 형태

obs = {
    "dof_pos": [...],
    "dof_vel": [...],
    "ang_vel": [...],
    "proj_grav": [...],
}

cmd = {
    "cmd_vector": [...],
}

현재 Joystick.get_cmd()는 cmd_vector만 반환하므로 그대로 넣으면 됩니다.

cmd = joystick.get_cmd()
state = rl.build_state(obs, cmd)

command 길이 검증

stacked_obs_order 또는 non_stacked_obs_order에 "command"가 포함되어 있으면 cmd["cmd_vector"] 길이가 cmd_vector_length 이상이어야 합니다.

예를 들어 아래 설정에서는 command 길이가 최소 4여야 합니다.

"non_stacked_obs_order": ["command"],
"cmd_vector_length": 4,

state 구성 순서

state는 다음 순서로 구성됩니다.

[ stacked history | non-stacked current values ]

예를 들어 다음 설정이라면:

"stacked_obs_order": ["dof_pos", "dof_vel"],
"non_stacked_obs_order": ["command"],
"history_length": 3,

state의 개념적 순서는 다음과 같습니다.

[ dof_pos_t | dof_vel_t |
  dof_pos_t-1 | dof_vel_t-1 |
  dof_pos_t-2 | dof_vel_t-2 |
  command_t ]

첫 번째 build_state() 호출에서는 history가 아직 없으므로 현재 frame을 history 전체에 복사합니다. 두 번째 호출부터는 기존 frame을 뒤로 밀고 현재 frame을 맨 앞에 넣습니다.

last_action 처리

last_action을 직접 넘길 수 있습니다.

state = rl.build_state(obs, cmd, last_action=[0.0, 0.0, 0.0, 0.0])

직접 넘기는 경우 길이는 반드시 4여야 합니다.

last_action을 생략하면 다음 규칙이 적용됩니다.

• 첫 build_state() 호출 전에는 history가 없으므로 dof_pos, dof_vel을 이용해 초기 last_action을 구성합니다.

• 이후에는 직전 select_action()에서 나온 raw policy action을 내부 last_action으로 사용합니다.

주의할 점은 last_action에 들어가는 값이 action_scale이 곱해진 최종 모터 명령이 아니라, 정책에서 나온 raw action이라는 점입니다.

select_action(state)

action = rl.select_action(state)

정책을 실행하고, policy output에 action_scale을 곱한 action을 반환합니다.

raw_action = policy(state)
scaled_action[i] = raw_action[i] * action_scale[i]

반환 action 길이는 4입니다. 정책 출력 길이가 4가 아니면 에러가 발생합니다.

일반적인 제어 루프에서는 반환값을 바로 robot.do_action()에 전달합니다.

action = rl.select_action(state)
robot.do_action(action)

---

8. control_rate

@control_rate(robot, hz=50)
def loop():
    ...

loop()

control_rate()는 지정한 주기로 제어 루프를 반복 실행하는 decorator입니다.

인자

control_rate(robot, hz=50)

인자	설명
robot	제어할 Robot 객체
hz	제어 루프 실행 주기

예제:

@control_rate(robot, hz=50)
def loop():
    obs = robot.get_obs()
    cmd = joystick.get_cmd()
    state = rl.build_state(obs, cmd)
    action = rl.select_action(state)
    robot.do_action(action)

loop()

---

9. 예제 코드

9.1 관측값 읽기

from f4_light_sdk import *

robot = Robot()
robot.set_gains(kp=[35, 35, 0, 0], kd=[0.45, 0.45, 0.3, 0.3])

obs = robot.get_obs()
print(obs)

robot.finish()

9.2 조이스틱 command 확인

from f4_light_sdk import *

joystick = Joystick(
    cmd_mapping=["left_y", "right_x", "left_x", "right_y"],
    cmd_range={
        "left_y": (-0.5, 0.5),
        "right_x": (-1.5, 1.5),
        "left_x": (-0.5, 0.5),
        "right_y": (-0.5, 0.5),
    },
)

cmd = joystick.get_cmd()
print(cmd["cmd_vector"])

9.3 RL 정책 실행

from pathlib import Path
from f4_light_sdk import *


def run():
    this_dir = Path(__file__).resolve().parent
    policy_path = str(this_dir / "example_policy.onnx")

    rl_config = RlConfig(config={
        "stacked_obs_order": ["dof_pos", "dof_vel", "ang_vel", "proj_grav", "last_action"],
        "non_stacked_obs_order": ["command"],
        "obs_scale": {
            "dof_vel": 0.05,
            "ang_vel": 0.25,
            "command": [2.0, 0.0, 0.25, 0.0],
        },
        "action_scale": [0.25, 0.25, 40.0, 40.0],
        "history_length": 3,
        "policy_path": policy_path,
        "cmd_vector_length": 4,
        "clip_actions": False,
    })

    robot = Robot()
    robot.set_gains(kp=[35, 35, 0, 0], kd=[0.45, 0.45, 0.3, 0.3])

    joystick = Joystick(
        cmd_mapping=["left_y", "right_x", "left_x", "right_y"],
        cmd_range={
            "left_x": (-0.5, 0.5),
            "left_y": (-0.5, 0.5),
            "right_x": (-1.5, 1.5),
            "right_y": (-0.5, 0.5),
            "dpad_x": (-1.0, 1.0),
            "dpad_y": (-1.0, 1.0),
            "left_btn": (0.0, 1.0),
            "right_btn": (0.0, 1.0),
            "dpad_step_x": 0.1,
            "dpad_step_y": 0.1,
        },
    )

    rl = RL()
    rl.set_config(rl_config)

    @control_rate(robot, hz=50)
    def loop():
        obs = robot.get_obs()
        cmd = joystick.get_cmd()
        state = rl.build_state(obs, cmd)
        action = rl.select_action(state)
        robot.do_action(action)

    loop()


if __name__ == "__main__":
    run()

9.4 사용자 정의 관측값 추가

from pathlib import Path
from f4_light_sdk import *


def get_latent():
    return [0.0] * 8


this_dir = Path(__file__).resolve().parent
policy_path = str(this_dir / "custom_policy.onnx")

rl_config = RlConfig(config={
    "extra_obs": {
        "latent": 8,
    },
    "stacked_obs_order": ["dof_pos", "dof_vel", "ang_vel", "proj_grav", "last_action"],
    "non_stacked_obs_order": ["command", "latent"],
    "obs_scale": {
        "dof_vel": 0.05,
        "ang_vel": 0.25,
        "command": [2.0, 0.0, 0.25, 0.0],
        "latent": 1.0,
    },
    "action_scale": [0.25, 0.25, 40.0, 40.0],
    "history_length": 3,
    "policy_path": policy_path,
    "cmd_vector_length": 4,
})

robot = Robot()
robot.set_gains(kp=[35, 35, 0, 0], kd=[0.45, 0.45, 0.3, 0.3])

joystick = Joystick(cmd_mapping=["left_y", "right_x", "left_x", "right_y"])
rl = RL()
rl.set_config(rl_config)

@control_rate(robot, hz=50)
def loop():
    obs = robot.get_obs()
    obs["latent"] = get_latent()

    cmd = joystick.get_cmd()
    state = rl.build_state(obs, cmd)
    action = rl.select_action(state)
    robot.do_action(action)

loop()

---

10. SDK 업데이트

SDK 업데이트에는 인터넷 연결이 필요합니다. 로봇에 LAN 포트가 있는 경우에는 LAN 케이블을 연결한 뒤 바로 업데이트할 수 있습니다.

pip install -U f4-light-sdk

LAN 포트가 없거나 LAN 연결을 사용할 수 없는 경우에는 Wi-Fi로 인터넷에 연결한 뒤 업데이트합니다.

# 1. Wi-Fi 활성화
sudo nmcli radio wifi on

# 2. 주변 네트워크 검색
sudo nmcli dev wifi list

# 3. 네트워크 연결
sudo nmcli dev wifi connect "네트워크이름" password "비밀번호"

# 4. 최신 SDK 업데이트
pip install -U f4-light-sdk

# 5. Wi-Fi 비활성화
sudo nmcli radio wifi off