## 목차
1. [프로젝트 개요](#1-프로젝트-개요)
2. [시스템 아키텍처](#2-시스템-아키텍처)
3. [프로젝트 구조](#3-프로젝트-구조)
4. [핵심 기능 및 모듈](#4-핵심-기능-및-모듈)
5. [빌드 시스템](#5-빌드-시스템)
6. [모듈 개발 가이드](#6-모듈-개발-가이드)
7. [사용법 가이드](#7-사용법-가이드)
8. [결론 및 평가](#8-결론-및-평가)
---
## 1. 프로젝트 개요
### 1.1 PX4란?
**PX4**는 드론(무인항공기) 및 다양한 무인 이동체를 위한 **오픈소스 비행 제어 소프트웨어**이다.
**주요 특징:**
- **라이선스**: BSD 3-clause (상용/학술 용도 모두 자유롭게 사용 가능)
- **플랫폼**: Linux, NuttX RTOS, macOS (크로스 플랫폼)
- **지원 기체**:
- 멀티콥터 (쿼드콥터, 헥사콥터 등)
- 고정익 항공기
- VTOL (수직이착륙기)
- 헬리콥터
- 지상 로버
- 수중 잠수함
- 우주선
- **개발 언어**: 주로 C++, 일부 C
- **실시간성**: 하드 실시간 요구사항 지원
- **확장성**: 모듈화된 아키텍처로 새로운 기능 추가 용이
### 1.2 활용 분야
- **상용 드론**: DJI, Auterion 등 상용 제품에 적용
- **연구 개발**: 대학 및 연구소의 무인기 연구
- **산업용 드론**: 농업, 측량, 감시, 배송 등
- **교육용**: 드론 개발 학습 플랫폼
- **취미용**: DIY 드론 제작
---
## 2. 시스템 아키텍처
### 2.1 전체 아키텍처 개요
PX4는 **마이크로서비스 아키텍처**를 기반으로 하며, 각 모듈이 독립적으로 동작하면서 **uORB**[^1]라는 통신 시스템을 통해 데이터를 주고받는다.
```
┌─────────────────────────────────────────────────────────┐
│ Ground Control Station │
│ (QGroundControl) │
└───────────────────────┬─────────────────────────────────┘
│ MAVLink Protocol
┌───────────────────────▼─────────────────────────────────┐
│ PX4 Autopilot │
│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │
│ │ Commander │ │ Navigator │ │ Flight Mode │ │
│ │ Module │ │ Module │ │ Manager │ │
│ └─────────────┘ └──────────────┘ └─────────────────┘ │
│ │ │ │ │
│ ┌────────▼───────────────▼───────────────────▼──────┐ │
│ │ uORB (통신 버스) │ │
│ └────────┬───────────────┬───────────────────┬──────┘ │
│ ┌────────▼──┐ ┌─────────▼──┐ ┌─────────────▼─────┐ │
│ │ Sensor │ │ Estimator │ │ Controllers │ │
│ │ Drivers │ │ (EKF2) │ │(Attitude/Position)│ │
│ └───────────┘ └────────────┘ └───────────────────┘ │
│ │ │ │ │
│ ┌────────▼───────────────▼───────────────────▼──────┐ │
│ │ Hardware Abstraction Layer │ │
│ └───────────────────────────────────────────────────┘ │
└─────────────┬───────────────────────────────────────────┘
│
┌─────────────▼───────────────┐
│ Hardware │
│ (Sensors, Actuators) │
└─────────────────────────────┘
```
### 2.2 uORB (Micro Object Request Broker)
**uORB**는 PX4의 핵심 통신 시스템으로, 모든 모듈 간 데이터 교환을 담당한다.
**주요 특징:**
- **발행-구독 패턴**: 데이터 생산자와 소비자 분리
- **비동기 통신**: 모듈 간 독립성 보장
- **타입 안전성**: 구조체 기반 메시지 정의
- **멀티 인스턴스**: 동일 토픽의 여러 인스턴스 지원
- **실시간성**: 우선순위 기반 메시지 처리
**데이터 흐름:**
```
센서 드라이버 → uORB → 센서 모듈 → uORB → 추정기(EKF2) → uORB → 제어기 → uORB → 믹서 → 액추에이터
↓ ↓ ↓ ↓
[센서 데이터] [보정된 데이터] [상태 추정] [제어 명령]
```
### 2.3 주요 메시지 토픽
| 토픽 | 설명 | 발행자 | 구독자 |
|------|------|--------|--------|
| `sensor_combined` | 통합 센서 데이터 | sensors 모듈 | EKF2, 제어기 |
| `vehicle_attitude` | 기체 자세 | EKF2 | 자세 제어기 |
| `vehicle_local_position` | 로컬 위치 | EKF2 | 위치 제어기 |
| `actuator_outputs` | 액추에이터 출력 | 제어 할당기 | PWM/CAN 드라이버 |
| `vehicle_command` | 기체 명령 | MAVLink | Commander |
| `parameter_update` | 파라미터 업데이트 | param 시스템 | 모든 모듈 |
---
## 3. 프로젝트 구조
### 3.1 전체 디렉토리 구조
```
PX4-Autopilot/
├── boards/ # 하드웨어 보드 설정
│ ├── px4/ # PX4 공식 보드
│ ├── cuav/ # CUAV 제조사 보드
│ ├── holybro/ # Holybro 제조사 보드
│ └── ... # 기타 제조사
├── cmake/ # CMake 빌드 스크립트
├── docs/ # 문서 소스
├── msg/ # uORB 메시지 정의
├── platforms/ # 플랫폼별 구현
│ ├── nuttx/ # NuttX RTOS 플랫폼
│ ├── posix/ # POSIX (Linux/macOS) 플랫폼
│ └── qurt/ # Qualcomm QURT 플랫폼
├── ROMFS/ # 런타임 파일 시스템
│ ├── px4fmu_common/ # 공통 초기화 스크립트
│ └── px4fmu_test/ # 테스트용 스크립트
├── src/ # 소스 코드
│ ├── drivers/ # 하드웨어 드라이버
│ ├── examples/ # 예제 코드
│ ├── lib/ # 공통 라이브러리
│ ├── modules/ # 핵심 비행 제어 모듈
│ ├── systemcmds/ # 시스템 명령어
│ └── templates/ # 모듈 개발 템플릿
├── test/ # 테스트 코드
└── Tools/ # 개발 도구 및 스크립트
├── setup/ # 개발 환경 설정 스크립트
└── simulation/ # 시뮬레이션 설정
```
### 3.2 핵심 디렉토리 상세 설명
#### 3.2.1 src/modules/ - 핵심 비행 제어 모듈
```
src/modules/
├── commander/ # 시스템 상태 관리 및 안전 감시
├── control_allocator/ # 제어 할당 (모터 믹싱)
├── dataman/ # 데이터 관리 (미션, 매개변수)
├── ekf2/ # Extended Kalman Filter 상태 추정
├── flight_mode_manager/ # 비행 모드 관리
├── fw_att_control/ # 고정익 자세 제어
├── fw_pos_control/ # 고정익 위치 제어
├── land_detector/ # 착륙 감지
├── mc_att_control/ # 멀티콥터 자세 제어
├── mc_pos_control/ # 멀티콥터 위치 제어
├── mavlink/ # MAVLink 프로토콜 통신
├── navigator/ # 미션/네비게이션 관리
├── sensors/ # 센서 데이터 처리 및 보정
└── vtol_att_control/ # VTOL 자세 제어
```
#### 3.2.2 src/drivers/ - 하드웨어 드라이버
```
src/drivers/
├── imu/ # IMU(관성측정장치) 드라이버
│ ├── invensense/ # InvenSense (MPU6000, ICM20602 등)
│ └── bosch/ # Bosch (BMI160 등)
├── magnetometer/ # 자력계 드라이버
├── barometer/ # 기압계 드라이버
├── gps/ # GPS 드라이버
├── pwm_out/ # PWM 출력 드라이버
├── uavcan/ # UAVCAN/DroneCAN 드라이버
├── camera_capture/ # 카메라 트리거 드라이버
└── telemetry/ # 무선 통신 드라이버
```
#### 3.2.3 msg/ - uORB 메시지 정의
```
msg/
├── sensor_accel.msg # 가속도계 데이터
├── sensor_gyro.msg # 자이로스코프 데이터
├── sensor_mag.msg # 자력계 데이터
├── sensor_baro.msg # 기압계 데이터
├── vehicle_attitude.msg # 기체 자세
├── vehicle_local_position.msg # 로컬 위치
├── vehicle_global_position.msg # GPS 위치
├── actuator_outputs.msg # 액추에이터 출력
├── mission.msg # 미션 데이터
└── vehicle_command.msg # 기체 명령
```
### 3.3 설정 파일 시스템
#### 3.3.1 보드 설정 (.px4board)
각 하드웨어 보드는 Kconfig 기반 설정 파일을 가진다.
```bash
# boards/px4/fmu-v5/default.px4board 예시
CONFIG_PLATFORM_NUTTX=y
CONFIG_BOARD_TOOLCHAIN="arm-none-eabi"
# 필수 모듈
CONFIG_MODULES_COMMANDER=y
CONFIG_MODULES_EKF2=y
CONFIG_MODULES_MC_ATT_CONTROL=y
# 드라이버
CONFIG_DRIVERS_IMU_INVENSENSE_ICM20602=y
CONFIG_DRIVERS_BAROMETER_MS5611=y
CONFIG_DRIVERS_GPS=y
```
#### 3.3.2 기체 설정 (Airframe)
ROMFS에 기체별 설정 파일이 저장됩니다:
```bash
ROMFS/px4fmu_common/init.d/
├── airframes/
│ ├── 4001_quad_x # X형 쿼드콥터
│ ├── 4010_quad_x_sim # 시뮬레이션용 쿼드콥터
│ ├── 4020_quad_h # H형 쿼드콥터
│ └── 1000_plane_aert # AERT 고정익
└── rc.mc_apps # 멀티콥터 앱 시작 스크립트
```
---
## 4. 핵심 기능 및 모듈
### 4.1 센서 및 데이터 처리
#### 4.1.1 Sensors 모듈
**역할**: 하드웨어 센서로부터 원시 데이터를 수집하고 보정
**주요 기능:**
- 센서 보정 (온도 보상, 스케일/오프셋 적용)
- 다중 센서 투표 시스템 (Sensor Voting)
- 센서 고장 감지 (Failure Detection)
- 센서 데이터 융합
**입력**: 센서 드라이버의 원시 데이터
**출력**: 보정된 센서 데이터 (`vehicle_acceleration`, `vehicle_angular_velocity`, `vehicle_magnetometer` 등)
#### 4.1.2 EKF2 추정기
**역할**: 확장 칼만 필터를 사용한 기체 상태 추정
**추정 항목:**
- 위치 및 속도 (3차원)
- 자세 (쿼터니언)
- 바람 속도 (2차원)
- 센서 바이어스
- 지형 높이
**융합 센서:**
- IMU (가속도계, 자이로스코프)
- 자력계
- 기압계
- GPS
- 광학 플로우
- 비전 위치 추정
- 거리 센서
### 4.2 비행 제어 시스템
#### 4.2.1 제어 구조
PX4는 **계층적 제어 구조**를 사용한다.
```
위치 제어기 → 자세 제어기 → 각속도 제어기 → 모터 믹서 → PWM 출력
```
#### 4.2.2 멀티콥터 제어
**자세 제어기 (mc_att_control)**:
- 입력: 자세 명령 (`vehicle_attitude_setpoint`)
- 출력: 각속도 명령 (`vehicle_rates_setpoint`)
- 알고리즘: PID 제어
**위치 제어기 (mc_pos_control)**:
- 입력: 위치/속도 명령 (`vehicle_local_position_setpoint`)
- 출력: 자세/추력 명령 (`vehicle_attitude_setpoint`)
- 알고리즘: PID 제어 + 피드포워드
#### 4.2.3 제어 할당 (Control Allocation)
**역할**: 제어 명령을 개별 액추에이터 명령으로 변환
**지원 기체:**
- 멀티콥터: 4/6/8 로터 등
- 고정익: 에일러론, 엘리베이터, 러더
- VTOL: 틸트로터, 테일시터 등
- 헬리콥터: 스와시플레이트 믹싱
### 4.3 미션 및 네비게이션
#### 4.3.1 Navigator 모듈
**지원 비행 모드:**
- **미션 모드**: 웨이포인트 기반 자율 비행
- **RTL (Return to Launch)**: 자동 귀환
- **로이터**: 특정 위치에서 선회 비행
- **팔로우 미**: 특정 대상 추종
- **정밀 착륙**: ArUco 마커 기반 정밀 착륙
#### 4.3.2 미션 관리
**미션 포맷**: MAVLink 미션 명령어 지원
- `MAV_CMD_NAV_WAYPOINT`: 웨이포인트 이동
- `MAV_CMD_NAV_TAKEOFF`: 이륙
- `MAV_CMD_NAV_LAND`: 착륙
- `MAV_CMD_DO_CHANGE_SPEED`: 속도 변경
- `MAV_CMD_DO_SET_SERVO`: 서보 제어
### 4.4 안전 및 페일세이프
#### 4.4.1 Commander 모듈
**안전 검사 항목:**
- 배터리 전압/잔량
- GPS 신호 품질
- 센서 상태 (IMU, 자력계, 기압계)
- RC 링크 품질
- 데이터링크 품질
- 지오펜스 위반
**페일세이프 동작:**
- **배터리 부족**: 강제 RTL 또는 착륙
- **RC 손실**: Hold 모드 또는 RTL
- **데이터링크 손실**: 설정에 따른 동작
- **GPS 손실**: 자세 모드로 전환
---
## 5. 빌드 시스템
### 5.1 빌드 시스템 구조
PX4는 **CMake + Makefile** 조합을 사용한다.
- **Makefile**: 사용자 인터페이스 (래퍼)
- **CMake**: 실제 빌드 시스템
- **Ninja**: 빠른 빌드 엔진 (옵션)
### 5.2 주요 빌드 명령어
#### 5.2.1 SITL (Software In The Loop) 빌드
```bash
# 기본 SITL 빌드
make px4_sitl_default
# Gazebo와 함께 실행
make px4_sitl gz_x500
# JMAVSim과 함께 실행
make px4_sitl jmavsim
# 특정 기체 모델로 실행
make px4_sitl gz_rover # 로버
make px4_sitl gz_vtol # VTOL
```
#### 5.2.2 하드웨어 빌드
```bash
# Pixhawk 4 빌드
make px4_fmu-v5_default
# Pixhawk 6X 빌드
make px4_fmu-v6x_default
# Cube Orange 빌드
make cubepilot_cubeorange_default
# 빌드 후 업로드
make px4_fmu-v5_default upload
```
### 5.3 개발 환경 설정
#### 5.3.1 Ubuntu Linux
```bash
# 개발 도구 설치
bash ./Tools/setup/ubuntu.sh
# Python 패키지 설치
pip3 install --user -r Tools/setup/requirements.txt
# ARM 컴파일러 설치 (하드웨어 타겟용)
sudo apt install gcc-arm-none-eabi
```
#### 5.3.2 macOS
```bash
# 개발 도구 설치
bash ./Tools/setup/macos.sh
# Homebrew 통해 ARM 컴파일러 설치
brew install armmbed/formulae/arm-none-eabi-gcc
```
### 5.4 고급 빌드 옵션
#### 5.4.1 디버그 빌드
```bash
# 디버그 심볼 포함
make px4_sitl_default PX4_CMAKE_BUILD_TYPE=Debug
# Address Sanitizer 활성화
make px4_sitl_default PX4_ASAN=1
# 커버리지 측정
make px4_sitl_default PX4_CMAKE_BUILD_TYPE=Coverage
```
#### 5.4.2 외부 모듈 빌드
```bash
# 외부 모듈 경로 지정
make px4_sitl_default EXTERNAL_MODULES_LOCATION=/path/to/modules
# 환경변수로 설정
export EXTERNAL_MODULES_LOCATION=/path/to/modules
make px4_sitl_default
```
### 5.5 모듈 설정 (Kconfig)
#### 5.5.1 모듈 활성화/비활성화
```bash
# menuconfig 실행 (대화형 설정)
make px4_sitl_default menuconfig
# 설정 업데이트
make updateconfig
```
#### 5.5.2 보드별 모듈 설정
`.px4board` 파일 수정:
```bash
# 모듈 활성화
CONFIG_MODULES_MY_MODULE=y
# 모듈 비활성화
CONFIG_MODULES_UNUSED_MODULE=n
```
---
## 6. 모듈 개발 가이드
### 6.1 기본 모듈 구조
#### 6.1.1 모듈 클래스 정의
```cpp
#include <px4_platform_common/module.h>
#include <px4_platform_common/module_params.h>
class MyModule : public ModuleBase<MyModule>, public ModuleParams
{
public:
MyModule(int example_param, bool example_flag);
virtual ~MyModule() = default;
// ModuleBase 인터페이스 구현 (필수)
static int task_spawn(int argc, char *argv[]);
static MyModule *instantiate(int argc, char *argv[]);
static int custom_command(int argc, char *argv[]);
static int print_usage(const char *reason = nullptr);
// 메인 실행 함수 (필수)
void run() override;
// 상태 출력 (옵션)
int print_status() override;
private:
void parameters_update(bool force = false);
// 파라미터 정의
DEFINE_PARAMETERS(
(ParamInt<px4::params::SYS_AUTOSTART>) _param_sys_autostart
)
// uORB 구독
uORB::SubscriptionInterval _parameter_update_sub{ORB_ID(parameter_update), 1_s};
};
```
#### 6.1.2 uORB 통신 구현
**데이터 구독:**
```cpp
#include <uORB/Subscription.hpp>
#include <uORB/topics/sensor_combined.h>
class MyModule : public ModuleBase<MyModule>
{
private:
uORB::Subscription _sensor_sub{ORB_ID(sensor_combined)};
public:
void run() override
{
while (!should_exit()) {
sensor_combined_s sensor_data;
if (_sensor_sub.update(&sensor_data)) {
// 새로운 센서 데이터 처리
processData(sensor_data);
}
px4_usleep(10000); // 10ms
}
}
};
```
**데이터 발행:**
```cpp
#include <uORB/Publication.hpp>
#include <uORB/topics/vehicle_attitude.h>
class MyModule : public ModuleBase<MyModule>
{
private:
uORB::Publication<vehicle_attitude_s> _attitude_pub{ORB_ID(vehicle_attitude)};
public:
void publishAttitude()
{
vehicle_attitude_s attitude{};
attitude.timestamp = hrt_absolute_time();
attitude.q[0] = 1.0f; // w (쿼터니언)
attitude.q[1] = 0.0f; // x
attitude.q[2] = 0.0f; // y
attitude.q[3] = 0.0f; // z
_attitude_pub.publish(attitude);
}
};
```
### 6.2 드라이버 개발
#### 6.2.1 I2C 드라이버 예제
```cpp
#include <lib/drivers/device/i2c.h>
#include <px4_platform_common/module.h>
class MyI2CDriver : public device::I2C, public ModuleBase<MyI2CDriver>
{
public:
MyI2CDriver(const I2CSPIDriverConfig &config);
static int task_spawn(int argc, char *argv[]);
static MyI2CDriver *instantiate(int argc, char *argv[]);
private:
int init() override;
int probe() override;
void RunImpl();
uint8_t read_reg(uint8_t reg);
void write_reg(uint8_t reg, uint8_t value);
uORB::Publication<sensor_gyro_s> _sensor_pub{ORB_ID(sensor_gyro)};
static constexpr uint8_t DEVICE_ADDRESS = 0x68;
static constexpr uint8_t WHO_AM_I_REG = 0x0F;
static constexpr float SCALE_FACTOR = 0.001f;
};
int MyI2CDriver::init()
{
int ret = I2C::init();
if (ret != PX4_OK) {
return ret;
}
// 센서 초기화
write_reg(0x20, 0x0F); // 설정 레지스터
return PX4_OK;
}
uint8_t MyI2CDriver::read_reg(uint8_t reg)
{
uint8_t data = 0;
transfer(®, 1, &data, 1);
return data;
}
void MyI2CDriver::RunImpl()
{
// 센서 데이터 읽기
uint8_t raw_data[6];
if (transfer(&read_cmd, 1, raw_data, 6) != PX4_OK) {
return;
}
// 데이터 변환 및 발행
sensor_gyro_s report{};
report.timestamp = hrt_absolute_time();
report.device_id = get_device_id();
report.x = (int16_t)((raw_data[1] << 8) | raw_data[0]) * SCALE_FACTOR;
report.y = (int16_t)((raw_data[3] << 8) | raw_data[2]) * SCALE_FACTOR;
report.z = (int16_t)((raw_data[5] << 8) | raw_data[4]) * SCALE_FACTOR;
_sensor_pub.publish(report);
}
```
### 6.3 외부 모듈 개발
#### 6.3.1 디렉토리 구조
```
my_external_modules/
├── src/
│ └── my_custom_module/
│ ├── CMakeLists.txt
│ ├── my_custom_module.h
│ └── my_custom_module.cpp
└── msg/
├── CMakeLists.txt
└── my_custom_message.msg
```
#### 6.3.2 커스텀 메시지 정의
**my_custom_message.msg:**
```
uint64 timestamp # 타임스탬프 (마이크로초)
float32 temperature # 온도 (섭씨)
float32 pressure # 압력 (Pa)
float32[3] position # 3차원 위치 [m]
uint8 status # 상태 플래그
```
#### 6.3.3 외부 모듈 빌드
```bash
# 외부 모듈과 함께 빌드
make px4_sitl_default EXTERNAL_MODULES_LOCATION=/path/to/my_external_modules
```
### 6.4 모듈 테스트 및 디버깅
#### 6.4.1 로깅 시스템
```cpp
#include <px4_platform_common/log.h>
// 로그 레벨별 출력
PX4_INFO("정보 메시지");
PX4_WARN("경고 메시지");
PX4_ERR("에러 메시지");
PX4_DEBUG("디버그 메시지"); // 디버그 빌드에서만 출력
```
#### 6.4.2 성능 측정
```cpp
#include <perf/perf_counter.h>
class MyModule {
private:
perf_counter_t _sample_perf;
perf_counter_t _interval_perf;
public:
MyModule() {
_sample_perf = perf_alloc(PC_ELAPSED, MODULE_NAME": sample");
_interval_perf = perf_alloc(PC_INTERVAL, MODULE_NAME": interval");
}
void run() {
while (!should_exit()) {
perf_begin(_sample_perf);
perf_count(_interval_perf);
// 작업 수행
doWork();
perf_end(_sample_perf);
}
}
};
```
---
## 7. 사용법 가이드
### 7.1 초보자용 빠른 시작
#### 7.1.1 개발 환경 설정
**1단계: 저장소 클론**
```bash
git clone https://github.com/PX4/PX4-Autopilot.git --recursive
cd PX4-Autopilot
```
**2단계: 개발 도구 설치 (Ubuntu)**
```bash
bash ./Tools/setup/ubuntu.sh
```
**3단계: Python 패키지 설치**
```bash
pip3 install --user -r Tools/setup/requirements.txt
```
#### 7.1.2 첫 번째 시뮬레이션
**SITL 시뮬레이션 실행:**
```bash
make px4_sitl gz_x500
```
**PX4 콘솔에서 기본 명령어:**
```bash
# 시스템 상태 확인
px4> commander status
# 모듈 상태 확인
px4> mc_pos_control status
# 이륙
px4> commander takeoff
# 착륙
px4> commander land
# 시스템 종료
px4> shutdown
```
### 7.2 QGroundControl 연동
#### 7.2.1 QGroundControl 설치
1. [QGroundControl 웹사이트](https://qgroundcontrol.com)에서 다운로드
2. 설치 후 실행
3. SITL 실행 시 자동으로 연결됨
#### 7.2.2 기본 미션 설정
**미션 계획 단계:**
1. QGC에서 "Plan" 탭 선택
2. 지도에서 웨이포인트 클릭하여 추가
3. 각 웨이포인트 고도 및 속도 설정
4. "Upload" 버튼으로 PX4에 업로드
5. "Fly" 탭에서 미션 실행
### 7.3 하드웨어 연동
#### 7.3.1 Pixhawk 설정
**1단계: 펌웨어 빌드 및 업로드**
```bash
# Pixhawk 4용 빌드
make px4_fmu-v5_default
# USB로 연결 후 업로드
make px4_fmu-v5_default upload
```
**2단계: 센서 보정**
- QGroundControl에서 "Vehicle Setup" → "Sensors"
- 가속도계, 자이로스코프, 자력계 순서로 보정
- 각 보정 과정의 지시사항 따라서 수행
**3단계: RC 설정**
- "Radio" 탭에서 송신기 설정
- 채널 매핑 및 보정 수행
**4단계: 비행 모드 설정**
- "Flight Modes" 탭에서 스위치별 모드 할당
- 안전을 위해 Kill Switch 설정 권장
### 7.4 고급 사용법
#### 7.4.1 파라미터 조정
**QGroundControl을 통한 조정:**
1. "Vehicle Setup" → "Parameters"
2. 카테고리별로 파라미터 검색
3. 값 변경 후 "Upload" 클릭
**콘솔을 통한 조정:**
```bash
# 파라미터 값 확인
px4> param show MC_ROLL_P
# 파라미터 값 변경
px4> param set MC_ROLL_P 0.8
# 모든 변경사항 저장
px4> param save
```
**중요 파라미터들:**
| 파라미터 | 설명 | 기본값 | 범위 |
|----------|------|--------|------|
| `MC_ROLL_P` | 멀티콥터 롤 비례 게인 | 6.5 | 0.0-12.0 |
| `MC_PITCH_P` | 멀티콥터 피치 비례 게인 | 6.5 | 0.0-12.0 |
| `MPC_Z_P` | Z축 위치 비례 게인 | 1.0 | 0.1-1.5 |
| `MPC_XY_P` | XY축 위치 비례 게인 | 0.95 | 0.1-2.0 |
| `COM_DISARM_LAND` | 착륙 후 자동 시동 해제 시간 | 2.0s | 0.0-20.0s |
#### 7.4.2 로그 분석
**로그 다운로드:**
```bash
# microSD 카드에서 로그 복사
cp /fs/microsd/log/*.ulg ./
# 또는 MAVLink로 다운로드
mavlink_loghandler
```
**FlightPlot을 사용한 분석:**
1. [FlightPlot](https://github.com/PX4/FlightPlot) 다운로드
2. .ulg 파일 열기
3. 관심있는 신호 선택하여 그래프 생성
**주요 분석 항목:**
- 자세 추적 성능 (`vehicle_attitude_setpoint` vs `vehicle_attitude`)
- 위치 추적 성능 (`vehicle_local_position_setpoint` vs `vehicle_local_position`)
- 진동 레벨 (`sensor_accel` 고주파 성분)
- 제어 출력 (`actuator_outputs`)
### 7.5 시뮬레이션 환경
#### 7.5.1 Gazebo 시뮬레이션
**기본 환경:**
```bash
# 표준 쿼드콥터 (X500)
make px4_sitl gz_x500
# 고정익
make px4_sitl gz_standard_plane
# VTOL
make px4_sitl gz_standard_vtol
# 로버
make px4_sitl gz_r1_rover
```
**커스텀 월드:**
```bash
# 특정 월드 파일 사용
PX4_SIM_MODEL=gz_x500 PX4_GZ_WORLD=windy make px4_sitl
```
#### 7.5.2 jMAVSim 시뮬레이션
```bash
# 간단한 멀티콥터 시뮬레이션
make px4_sitl jmavsim
# 특정 IP로 연결
make px4_sitl jmavsim___192.168.1.100
```
---
## 8. 결론 및 평가
### 8.1 PX4의 장점
#### 8.1.1 기술적 장점
**모듈화된 아키텍처:**
- 각 기능이 독립된 모듈로 구현되어 유지보수 용이
- uORB 통신 시스템으로 모듈 간 깔끔한 인터페이스
- 새로운 기능 추가나 기존 기능 수정이 비교적 쉬움
**뛰어난 확장성:**
- 다양한 기체 타입 지원 (멀티콥터, 고정익, VTOL 등)
- 풍부한 센서 지원 (IMU, GPS, 광학플로우, 라이다 등)
- 다양한 하드웨어 플랫폼 지원
**실시간 성능:**
- NuttX RTOS 기반으로 하드 실시간 보장
- 우선순위 기반 스케줄링
- 안정적인 제어 루프 실행
**풍부한 개발 도구:**
- 시뮬레이션 환경 (Gazebo, jMAVSim)
- 로그 분석 도구
- 파라미터 조정 도구
- 자동 테스트 프레임워크
#### 8.1.2 생태계 장점
**활발한 커뮤니티:**
- 오픈소스로 전 세계 개발자들이 기여
- 정기적인 릴리스와 지속적인 개선
- 풍부한 문서와 예제
**산업 표준:**
- 많은 상용 제품에서 사용
- MAVLink 프로토콜 지원
- QGroundControl과의 완벽한 연동
### 8.2 PX4의 한계
#### 8.2.1 기술적 한계
**복잡성:**
- 초보자가 이해하기에는 복잡한 구조
- 다양한 설정 옵션으로 인한 혼란 가능성
- 디버깅이 어려울 수 있음
**하드웨어 의존성:**
- 특정 하드웨어에 최적화된 부분들
- 새로운 센서나 하드웨어 추가 시 드라이버 개발 필요
**메모리 사용량:**
- 임베디드 시스템 기준으로는 상당한 메모리 요구
- 저사양 MCU에서는 모든 기능 사용 어려움
#### 8.2.2 사용상 한계
**학습 곡선:**
- C++ 및 임베디드 프로그래밍 지식 필요
- 비행 제어 이론에 대한 이해 필요
- 다양한 도구 체인 숙지 필요
### 8.3 활용 권장 분야
#### 8.3.1 적합한 프로젝트
**연구 개발:**
- 대학 및 연구소의 무인기 연구
- 새로운 제어 알고리즘 개발
- 센서 융합 알고리즘 연구
**상용 제품 개발:**
- 전문용 드론 개발
- 산업용 무인기 시스템
- 대량 생산 제품의 펌웨어 기반
**교육 목적:**
- 무인기 제어 시스템 학습
- 임베디드 시스템 개발 교육
- 로보틱스 교육 플랫폼
#### 8.3.2 비권장 경우
**간단한 취미용 프로젝트:**
- ArduPilot이나 BetaFlight가 더 적합할 수 있음
- 학습 비용 대비 효과가 낮을 수 있음
**극도로 제한된 하드웨어:**
- 32KB 미만 RAM을 가진 마이크로컨트롤러
- 실시간 OS 없는 단순한 환경
### 8.4 향후 전망
#### 8.4.1 기술 발전 방향
**인공지능 통합:**
- 머신러닝 기반 제어 알고리즘
- 컴퓨터 비전과의 통합
- 자율 비행 능력 향상
**클라우드 연동:**
- 지상 제어 시스템과의 클라우드 연동
- 원격 모니터링 및 제어
- 대규모 드론 군집 관리
**표준화 진전:**
- DroneCAN/UAVCAN v1.0 완전 지원
- ROS 2와의 더 깊은 통합
- 다른 오토파일럿 시스템과의 상호 운용성
#### 8.4.2 시장 전망
PX4는 다음과 같은 이유로 계속해서 중요한 위치를 차지할 것으로 예상됩니다:
- **오픈소스의 장점**: 투명성, 커뮤니티 지원, 비용 효율성
- **기업 지원**: Auterion, NXP 등 주요 기업들의 지원
- **표준화**: 드론 산업의 사실상 표준으로 자리잡음
- **확장성**: 다양한 플랫폼과 애플리케이션 지원
### 8.5 최종 평가
PX4 Autopilot은 **전문적인 드론 개발을 위한 최고 수준의 오픈소스 플랫폼** 중 하나이다. 복잡하고 강력한 기능을 제공하지만, 그만큼 높은 학습 비용을 요구한다.
**추천 대상:**
- 전문적인 드론 개발자
- 연구 목적의 사용자
- 상용 제품 개발팀
- 체계적인 학습을 원하는 학생/엔지니어
**성공적인 활용을 위한 조건:**
- C++ 프로그래밍 능력
- 임베디드 시스템 개발 경험
- 비행 제어 이론에 대한 기본 이해
- 인내심과 지속적인 학습 의지
PX4는 단순히 드론을 날리는 것을 넘어서, **드론 기술의 깊이 있는 이해**와 **혁신적인 애플리케이션 개발**을 가능하게 하는 플랫폼이다.
---
*이 보고서는 PX4 Autopilot v1.14 기준으로 작성되었으며, 지속적으로 업데이트되는 프로젝트의 특성상 일부 내용은 변경될 수 있음!!!!!.*
---
## 부록
### A. 유용한 링크
- **공식 웹사이트**: https://px4.io/
- **개발자 가이드**: https://docs.px4.io/main/en/
- **GitHub 저장소**: https://github.com/PX4/PX4-Autopilot
- **커뮤니티 포럼**: https://discuss.px4.io/
- **QGroundControl**: https://qgroundcontrol.com/
### B. 주요 명령어 레퍼런스
#### B.1 빌드 명령어
```bash
make px4_sitl_default # SITL 빌드
make px4_fmu-v5_default # Pixhawk 4 빌드
make clean # 빌드 정리
make distclean # 완전 정리
make px4_sitl gz_x500 # Gazebo 시뮬레이션
```
#### B.2 PX4 콘솔 명령어
```bash
help # 도움말
commander status # 시스템 상태
mc_pos_control status # 모듈 상태
param show MC_ROLL_P # 파라미터 확인
param set MC_ROLL_P 0.8 # 파라미터 설정
logger start # 로깅 시작
uorb top # uORB 토픽 모니터링
```
### C. 파라미터 참조표
| 카테고리 | 파라미터 | 설명 | 기본값 |
|----------|----------|------|--------|
| 멀티콥터 제어 | MC_ROLL_P | 롤 비례 게인 | 6.5 |
| 멀티콥터 제어 | MC_PITCH_P | 피치 비례 게인 | 6.5 |
| 멀티콥터 제어 | MC_YAW_P | 요 비례 게인 | 2.8 |
| 위치 제어 | MPC_XY_P | 수평 위치 비례 게인 | 0.95 |
| 위치 제어 | MPC_Z_P | 수직 위치 비례 게인 | 1.0 |
| 안전 | COM_DISARM_LAND | 착륙 후 시동해제 시간 | 2.0s |
| 배터리 | BAT_LOW_THR | 배터리 부족 임계값 | 0.15 |
[^1]: https://docs.px4.io/main/ko/middleware/uorb.html