# Structs

## Protocol::Header

헤더.

데이터 송수신 시에 사용하는 헤더입니다.

```python
namespace Protocol
{
    struct Header
    {
        u8      dataType;       // 데이터의 형식
        u8      length;         // 데이터의 길이
        u8      from;           // 데이터를 전송하는 장치의 DeviceType
        u8      to;             // 데이터를 수신하는 장치의 DeviceType
        
    };
}
```

| 변수 이름.   | 형식.                        | 크기.    | 범위.      | 설명.           |
| -------- | -------------------------- | ------ | -------- | ------------- |
| dataType | Protocol::DataType::Type   | 1 Byte | -        | 데이터의 타입.      |
| length   | uint8\_t                   | 1 Byte | 0 \~ 255 | 데이터의 길이.      |
| from     | Protocol::DeviceType::Type | 1 Byte | -        | 데이터를 전송하는 장치. |
| to       | Protocol::DeviceType::Type | 1 Byte | -        | 데이터를 수신하는 장치. |

## Protocol::Ping

Ping

특정 장치가 존재하는지를 확인할 때 사용합니다. 응답은 Ack를 받습니다.

```python
namespace Protocol
{
    struct Ping
    {
        u64     systemTime;   // Ping을 전송하는 장치의 시각
    };
}
```

| 변수 이름.     | 형식.       | 크기.    | 범위. | 설명.   |
| ---------- | --------- | ------ | --- | ----- |
| systemTime | uint64\_t | 8 Byte | -   | 시스템 시 |

## Protocol::Ack

응답.

특정한 데이터를 요청하지 않은 경우에 Ack를 응답으로 전송합니다. 수신 받은 데이터의 crc16을 포함하여 돌려보내기 때문에 데이터를 전송한 측에서 정상적으로 데이터를 전송했는지 판별하는데 사용합니다.

```python
namespace Protocol
{
    struct Ack
    {
        u64     systemTime;     // 수신 받은 시간
        u8      dataType;       // 수신 받은 데이터 타입
        u16     crc16;          // 수신 받은 데이터의 crc16
    };
}
```

| 변수 이름.     | 형식.                      | 크기.    | 범위. | 설명.                     |
| ---------- | ------------------------ | ------ | --- | ----------------------- |
| systemTime | uint64\_t                | 8 Byte | -   | 시스템 시간.                 |
| dataType   | Protocol::DataType::Type | 1 Byte | -   | 수신 받은 데이터 타입.           |
| crc16      | uint16\_t                | 2 Byte | -   | 수신 받은 헤더와 데이터의 CRC16 값. |

## Protocol::Error

오류.

드론에 문제가 생긴 경우 Error 구조체를 600ms에 한 번 RF를 통해 송신합니다.                                               errorFlagsForSensor와 errorFlagsForState는 각각의 값에 해당하는 플래그를 조합하여 여러 오류들이 동시에 발생하는 것을 표시합니다.                                                                                                                                     문제가 완전히 없어진 경우 Error 플래그를 0으로 초기화하여 추가로 5회 전송 후 전송을 중단합니다.

```python
namespace Protocol
{
    struct Error
    {
        u64     systemTime;             // 에러 메세지 송신 시각
        u32     errorFlagsForSensor;    // 센서 오류 플래그
        u32     errorFlagsForState;     // 상태 오류 플래그
    };
}
```

| 변수 이름.              | 형식.                       | 크기.    | 범위. | 설명.           |
| ------------------- | ------------------------- | ------ | --- | ------------- |
| systemTime          | uint64\_t                 | 8 Byte | -   | 시스템 시간.       |
| errorFlagsForSensor | ErrorFlagsForSensor::Type | 4 Byte | -   | 센서 오류 플래그 조합. |
| errorFlagsForState  | ErrorFlagsForState::Type  | 4 Byte | -   | 상태 오류 플래그 조합. |

## Protocol::Request

데이터 요청.

```python
namespace Protocol
{
    struct Request
    {
        u8      dataType;          // 요청할 데이터 타입
    };
}
```

| 변수 이름.   | 형식.                      | 크기.    | 범위. | 설명.         |
| -------- | ------------------------ | ------ | --- | ----------- |
| dataType | Protocol::DataType::Type | 1 Byte | -   | 요청할 데이터 타입. |

## Protocol::Address

장치 주소(고유번호).

```python
namespace Protocol
{
    struct Address
    {
        u8   address[16];
    };
}
```

| 변수 이름.  | 형식.            | 크기.     | 범위. | 설명.    |
| ------- | -------------- | ------- | --- | ------ |
| address | uint8\_t Array | 16 Byte | -   | 장치 주소. |

## Protocol::Information

펌웨어 정보.

```python
namespace Protocol
{
    struct Information
    {
        u8      modeUpdate;     // 업데이트 모드

        u32     modelNumber;    // 모델 번호
        u32     version;        // 현재 펌웨어의 버전

        u16     year;           // 빌드 년
        u8      month;          // 빌드 월
        u8      day;            // 빌드 일
    };
}
```

| 변수 이름.      | 형식.                | 크기.    | 범위. | 설명.       |
| ----------- | ------------------ | ------ | --- | --------- |
| modeUpdate  | Mode::Update::Type | 1 Byte | -   | 업데이트 모드.  |
| modelNumber | ModelNumber::Type  | 4 Byte | -   | 모델 번호.    |
| version     | Protocol::Version  | 4 Byte | -   | 펌웨어의 버전.  |
| year        | uint16\_t          | 2 Byte | -   | 펌웨어 빌드 년. |
| month       | uint8\_t           | 1 Byte | -   | 펌웨어 빌드 월. |
| day         | uint8\_t           | 1 Byte | -   | 펌웨어 빌드 일. |

## Protocol::Version

펌웨어 버전.

버전 비교 시 v값으로 비교할 수 있도록 struct 내부의 변수 배치 순서를 다른 구조체들과 다르게 역순으로 배열하였습니다.

```python
namespace Protocol
{
    union Version
    {
        struct
        {
            u16     build;      // Build Number
            u8      minor;      // Minor Number
            u8      major;      // Major Number
        };

        u32 v;
    };
}
```

| 변수 이름. | 형식.       | 크기.    | 범위.        | 설명.                            |
| ------ | --------- | ------ | ---------- | ------------------------------ |
| build  | uint16\_t | 14 bit | 0 \~ 65535 | 빌드 번호.                         |
| minor  | uint8\_t  | 1 Byte | 0 \~ 255   | 부 번호.                          |
| major  | uint8\_t  | 1 Byte | 0 \~ 255   | 주 번호.                          |
| v      | uint32\_t | 4 Byte | -          | build, minor, major를 하나로 묶은 것. |

## Control::Quad8

드론.

```
namespace Control
{
    struct Quad8
    {
        s8      roll;       // roll
        s8      pitch;      // pitch
        s8      yaw;        // yaw
        s8      throttle;   // throttle
    };
}
```

| 변수 이름.   | 형식.     | 크기.    | 범위.         | 설명.    | 음수 값(-) | 양수 값(+) |
| -------- | ------- | ------ | ----------- | ------ | ------- | ------- |
| roll     | int8\_t | 1 Byte | -100 \~ 100 | 좌우.    | 좌측.     | 우측.     |
| pitch    | int8\_t | 1 Byte | -100 \~ 100 | 전후.    | 후방.     | 전방.     |
| yaw      | int8\_t | 1 Byte | -100 \~ 100 | 좌우 회전. | 시계 방향.  | 반시계 방향. |
| throttle | int8\_t | 1 Byte | -100 \~ 100 | 승하강.   | 하강.     | 상승.     |

## Control::Quad8AndRequestData

드론 조종 및 데이터 요청.

조종 명령 시 응답 데이터로 Ack 대신 요청한 데이터를 응답으로 보내게 합니다.

```
namespace Control
{
    struct Quad8AndRequestData
    {
        s8      roll;       // roll
        s8      pitch;      // pitch
        s8      yaw;        // yaw
        s8      throttle;   // throttle

        u8      dataType;   // DataType
    };
}
```

| 변수 이름.   | 형식.                      | 크기.    | 범위.         | 설명.     | 음수 값(-) | 양수 값(+) |
| -------- | ------------------------ | ------ | ----------- | ------- | ------- | ------- |
| roll     | int8\_t                  | 1 Byte | -100 \~ 100 | 좌우.     | 좌측.     | 우측.     |
| pitch    | int8\_t                  | 1 Byte | -100 \~ 100 | 전후.     | 후방.     | 전방.     |
| yaw      | int8\_t                  | 1 Byte | -100 \~ 100 | 좌우 회전.  | 시계 방향.  | 반시계 방향. |
| throttle | int8\_t                  | 1 Byte | -100 \~ 100 | 승하강.    | 하강.     | 상승.     |
| dataType | Protocol::DataType::Type | -      | 1 Byte      | 요청할 데이터 | -       | -       |

## Control::Position16

드론 이동 .

드론에 이동 명령을 내리는 경우 사용합니다.

```
namespace Control
{
    struct Position16
    {
        s16     positionX;          // meter    x 10
        s16     positionY;          // meter    x 10
        s16     positionZ;          // meter    x 10
        s16     velocity;           // m/s      x 10
        
        s16     heading;            // degree
        s16     rotationalVelocity; // deg/s
    };
}
```

| 변수 이름.             | 형식.      | 크기.    | 범위.                        | .          | 설명.               |
| ------------------ | -------- | ------ | -------------------------- | ---------- | ----------------- |
| positionX          | int16\_t | 2 Byte | -100 \~ 100(-10.0 \~ 10.0) | meter x 10 | 앞(+), 뒤(-)        |
| positionY          | int16\_t | 2 Byte | -100 \~ 100(-10.0 \~ 10.0) | meter x 10 | 좌(+), 우(-)        |
| positionZ          | int16\_t | 2 Byte | -100 \~ 100(-10.0 \~ 10.0) | meter x 10 | 위(+), 아래(-)       |
| velocity           | int16\_t | 2 Byte | 0 \~ 50(0.0 \~ 5.0)        | m/s x 10   | 이동 속도             |
| heading            | int16\_t | 2 Byte | -360 \~ 360                | degree     | 반시계방향(+), 시계방향(-) |
| rotationalVelocity | int16\_t | 2 Byte | 10 \~ 180                  | degree/s   | 좌우 회전 속도          |

## Control::Position

드론 이동 명령.

드론에 이동 명령을 내리는 경우 사용합니.

```
namespace Control
{
    struct Position
    {
        float       positionX;              // meter
        float       positionY;              // meter
        float       positionZ;              // meter
        float       velocity;               // m/s
        
        s16         heading;                // degree
        s16         rotationalVelocity;     // deg/s
    };
}
```

| 변수 이름.             | 형식.   | 크기.    | 범위.           | .        | 설명.               |
| ------------------ | ----- | ------ | ------------- | -------- | ----------------- |
| positionX          | float | 4 Byte | -10.0 \~ 10.0 | meter    | 앞(+), 뒤(-)        |
| positionY          | float | 4 Byte | -10.0 \~ 10.0 | meter    | 좌(+), 우(-)        |
| positionZ          | float | 4 Byte | -10.0 \~ 10.0 | meter    | 위(+), 아래(-)       |
| velocity           | float | 4 Byte | 0.0 \~ 5.0    | m/s      | 앞뒤 이동 속도          |
| heading            | float | 2 Byte | -360 \~ 360   | degree   | 반시계방향(+), 시계방향(-) |
| rotationalVelocity | float | 2 Byte | 10 \~ 180     | degree/s | 좌우 회전 속도          |

## Protocol::Command::Command

설정 변경.

```
namespace Protocol
{
    namespace Command
    {
        struct Command
        {
            u8      commandType;   // 명령 타입
            u8      option;        // 명령에 대한 옵션
        };
    }
}
```

| 변수 이름.      | 형식.                         | 크기.    | 범위. | 설명.        |
| ----------- | --------------------------- | ------ | --- | ---------- |
| commandType | Protocol::CommandType::Type | 1 Byte | -   | 명령 타입      |
| option      | Mode::Control::Flight::Type | 1 Byte | -   | 좌(+), 우(-) |
|             | System::FlightEvent::Type   |        | -   |            |
|             | Headless::Type              |        | -   |            |
|             | System::Trim::Type          |        | -   |            |
|             | Mode::Controller::Type      |        | -   |            |
|             | uint8\_t                    |        |     |            |

## Protocol::Command::LightEvent

설정 변경 + LED 이벤트.

```
namespace Protocol
{
    namespace Command
    {
        struct LightEvent
        {
            Protocol::Command::Command      command;
            Protocol::Light::Event          event;
        };
    }
}
```

| 변수 이름.  | 형식.                        | 크기.    | 범위. | 설명.      |
| ------- | -------------------------- | ------ | --- | -------- |
| command | Protocol::Command::Command | 2 Byte | -   | 명령.      |
| event   | Protocol::Light::Event     | 4 Byte | -   | LED 이벤트. |

## Protocol::Command::LightEventColor

설정 변경 + LED 이벤트(RGB)

```
namespace Protocol
{
    namespace Command
    {
        struct LightEventColor
        {
            Protocol::Command::Command      command;
            Protocol::Light::Event          event;
            Light::Color                    color;
        };
    }
}
```

| 변수 이름.  | 형식.                        | 크기.    | 범위. | 설명.         |
| ------- | -------------------------- | ------ | --- | ----------- |
| command | Protocol::Command::Command | 2 Byte | -   | 명령.         |
| event   | Protocol::Light::Event     | 4 Byte | -   | LED 이벤트.    |
| color   | Light::Color               | 3 Byte | -   | LED RGB 색상. |

## Protocol::Command::LightEventColors

설정 변경 + LED 이벤트(Palette)

```
namespace Protocol
{
    namespace Command
    {
        struct LightEventColors
        {
            Protocol::Command::Command      command;
            Protocol::Light::Event          event;
            u8                              colors;
        };
    }
}
```

| 변수 이름.  | 형식.                        | 크기.    | 범위. | 설명.       |
| ------- | -------------------------- | ------ | --- | --------- |
| command | Protocol::Command::Command | 2 Byte | -   | 명령.       |
| event   | Protocol::Light::Event     | 4 Byte | -   | LED 이벤트.  |
| color   | Light::Color::Type         | 1 Byte | -   | LED 팔레트 . |

## Protocol::Pairing

페어링.

장치의 페어링 정보를 확인하거나 변경할 때 사용합니다.                                                                          address0, address1, address2를 모두 0으로 설정한 경우 RF 데이터 송신을 실행하지 않으며, 데이터 수신 시에도 해당 데이터를 무시합니다.                                                                                                          channelArray에는 모두 4개의 채널이 들어가며, 주파수 호핑(FHSS) 동작 시 지정한 모든 채널을 사용하고, 주파수 고정 동작 시 배열의 첫 번째에 있는 채널을 사용합니다.

```
namespace Protocol
{
    struct Pairing
    {
        u16     address0;
        u16     address1;
        u16     address2;
        u8      scramble;
        u8      channelArray[4];
    };
}
```

| 변수 이름.       | 형식.       | 크기.    | 범위.                  | 설명.   |
| ------------ | --------- | ------ | -------------------- | ----- |
| address0     | uint16\_t | 2 Byte | 0x0000 \~ 0xFFFF     | 주소0   |
| address1     | uint16\_t | 2 Byte | 0x0000 \~ 0xFFFF     | 주소1   |
| address2     | uint16\_t | 2 Byte | 0x0000 \~ 0xFFFF     | 주소2   |
| scramble     | uint8\_t  | 1 Byte | 0x00 \~ 0x7F(0\~127) | 스크램블. |
| channelArray | uint8\_t  | 4 Byte | 0\~81                | 채널.   |

## Protocol::Rssi <a href="#protocol-pairing" id="protocol-pairing"></a>

RSSI

Received signal strength indication                               <http://www.metageek.com/training/resources/understanding-rssi.html>                                                           현재 무선으로 연결된 장치의 신호 세기를 반환합니다.

```
namespace Protocol
{
    struct Rssi
    {
        s8     Rssi;
    };
}
```

| 변수 이름. | 형식.     | 크기.    | 범위.       | 설명.    |
| ------ | ------- | ------ | --------- | ------ |
| rssi   | int8\_t | 1 Byte | -100 \~ 0 | 신호 세기. |

## Protocol::RawMotion <a href="#protocol-pairing" id="protocol-pairing"></a>

Motion 센서 RAW 데이터.&#x20;

```
namespace Protocol
{
    struct RawMotion
    {
        s16     accX;
        s16     accY;
        s16     accZ;
        
        s16     gyroRoll;
        s16     gyroPitch;
        s16     gyroYaw;
    };
}
```

| 변수 이름.    | 형식.   | 크기.    | 범위.               | 설명.       |
| --------- | ----- | ------ | ----------------- | --------- |
| accelX    | Int16 | 2 Byte | -32,768 \~ 32,767 | 가속도 X     |
| accelY    | Int16 | 2 Byte | -32,768 \~ 32,767 | 가속도 Y     |
| accelZ    | Int16 | 2 Byte | -32,768 \~ 32,767 | 가속도 Z     |
| gyroRoll  | Int16 | 2 Byte | -32,768 \~ 32,767 | 자이로 Roll  |
| gyroPitch | Int16 | 2 Byte | -32,768 \~ 32,767 | 자이로 Pitch |
| gyroYaw   | Int16 | 2 Byte | -32,768 \~ 32,767 | 자이로 Yaw   |

## Protocol::RawFlow <a href="#protocol-pairing" id="protocol-pairing"></a>

Flow 센서 RAW 데이터.

```
namespace Protocol
{
    struct RawFlow
    {
        f32     x;
        f32     y;
    };
}
```

| 변수 이름. | 형식.   | 크기.    | 범위. | 설명. |
| ------ | ----- | ------ | --- | --- |
| x      | float | 4 Byte | -   | X축. |
| y      | float | 4 Byte | -   | Y축. |

## Protocol::State <a href="#protocol-pairing" id="protocol-pairing"></a>

드론의 현재 상태.

```
namespace Protocol
{
    struct State
    {
        u8      modeSystem;         // 시스템 모드
        u8      modeFlight;         // 비행 모드

        u8      modeControlFlight;  // 비행 제어 모드
        u8      modeMovement;       // 이동 상태
        u8      headless;           // 헤드리스 모드
        u8      controlSpeed;       // 제어 속도
        u8      sensorOrientation;  // 센서 방향
        u8      battery;            // 배터리량(0 ~ 100%)
    };
}
```

| 변수 이름.            | 형식.                         | 크기.    | 범위.      | 설명.             |
| ----------------- | --------------------------- | ------ | -------- | --------------- |
| modeSystem        | Mode::System::Type          | 1 Byte | -        | System 동작 모드.   |
| modeFlight        | Mode::Flight::Type          | 1 Byte | -        | 비행 제어기 동작 모드.   |
| modeControlFlight | Mode::Control::Flight::Type | 1 Byte | -        | 비행 제어 모드.       |
| modeMovement      | Mode::Movement::Type        | 1 Byte | -        | 이동 상태.          |
| headless          | Headless::Type              | 1 Byte | -        | Headless 설정 상태. |
| controlSpeed      | uint8\_t                    | 1 Byte | -        | 제어 속도(1,2,3)    |
| sensorOrientation | SensorOrientation:Type      | 1 Byte | -        | 센서 방향           |
| battery           | uint8\_t                    | 1 Byte | 0 \~ 100 | 드론 배터리 잔량.      |

## Protocol::StateController <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

조종의 현재 상태.

```
namespace Protocol
{
    struct StateController
    {
        u8      modeSystem;             // 시스템 동작 모드
        u8      modeController;         // 조종기 동작 모드
        u8      modeConnection;         // 연결 모드
        u8      deviceType;             // 현재 장치의 타입
        s8      rssi;                   // RSSI

        u32     systemTime;             // 시스템 시간(ms)
        u32     timeConnected;          // 연결된 이후부터의 시간(ms)
        u32     timeLostConnection;     // 연결이 끊어지고 나서의 시간(ms)

        u8      countCycleTransferRF;       // 1초당 전송 횟수 RF
        u8      countCycleReceiveRF;        // 1초당 수신 횟수 RF
        u8      countCycleTransferExternal; // 1초당 전송 횟수 External
        u8      countCycleReceiveExternal;  // 1초당 수신 횟수 External
        u8      countCycleTransferUSB;      // 1초당 전송 횟수 USB
        u8      countCycleReceiveUSB;       // 1초당 수신 횟수 USB
    };
}
```

| 변수 이름.                     | 형식.                        | 크기.    | 범위.      | 설명.                 |
| -------------------------- | -------------------------- | ------ | -------- | ------------------- |
| modeSystem                 | Mode::System::Type         | 1 Byte | -        | System 동작 모드.       |
| modeController             | Mode::Controller::Type     | 1 Byte | -        | 조종기 동작 모드.          |
| modeConnection             | Mode::Connection::Type     | 1 Byte | -        | 연결 모드.              |
| deviceType                 | Protocol::DeviceType::Type | 1 Byte | -        | 장치 타입.              |
| rssi                       | int8\_t                    | 1 Byte | -        | RSSI                |
| systemTime                 | uint32\_t                  | 4 Byte | -        | 시스템 시간(ms)          |
| timeConnected              | uint32\_t                  | 4 Byte | -        | 연결된 이후부터의 시간(ms)    |
| timeLostConnection         | uint32\_t                  | 4 Byte | 0 \~ 100 | 연결이 끊어지고 나서의 시간(ms) |
| countCycleTransferRF       | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 전송 횟수 RF        |
| countCycleReceiveRF        | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 수신 횟수 RF        |
| countCycleTransferExternal | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 전송 횟수 External  |
| countCycleReceiveExternal  | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 수신 횟수 External  |
| countCycleTransferUSB      | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 전송 횟수 USB       |
| countCycleReceiveUSB       | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 수신 횟수 USB       |

## Protocol::StateLink <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

LINK 모듈의 현재 상태.

```
namespace Protocol
{
    struct StateLink
    {
        u8      modeSystem;             // 시스템 동작 모드
        u8      modeConnection;         // 연결 모드
        u8      deviceType;             // 현재 장치의 타입
        s8      rssi;                   // RSSI

        u32     systemTime;             // 시스템 시간(ms)
        u32     timeConnected;          // 연결된 이후부터의 시간(ms)
        u32     timeLostConnection;     // 연결이 끊어지고 나서의 시간(ms)

        u8      countCycleTransferRF;       // 1초당 전송 횟수 RF
        u8      countCycleReceiveRF;        // 1초당 수신 횟수 RF
        u8      countCycleTransferExternal; // 1초당 전송 횟수 External
        u8      countCycleReceiveExternal;  // 1초당 수신 횟수 External
        u8      countCycleTransferUSB;      // 1초당 전송 횟수 USB
        u8      countCycleReceiveUSB;       // 1초당 수신 횟수 USB
    };
}
```

| 변수 이름.                     | 형식.                        | 크기.    | 범위.      | 설명.                 |
| -------------------------- | -------------------------- | ------ | -------- | ------------------- |
| modeSystem                 | Mode::System::Type         | 1 Byte | -        | System 동작 모드.       |
| modeConnection             | Mode::Connection::Type     | 1 Byte | -        | 연결 모.               |
| deviceType                 | Protocol::DeviceType::Type | 1 Byte | -        | 장치 타입.              |
| rssi                       | int8\_t                    | 1 Byte | -        | RSSI                |
| systemTime                 | uint32\_t                  | 4 Byte | -        | 시스템 시간(ms)          |
| timeConnected              | uint32\_t                  | 4 Byte | -        | 연결된 이후부터의 시간(ms)    |
| timeLostConnection         | uint32\_t                  | 4 Byte | 0 \~ 100 | 연결이 끊어지고 나서의 시간(ms) |
| countCycleTransferRF       | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 전송 횟수 RF        |
| countCycleReceiveRF        | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 수신 횟수 RF        |
| countCycleTransferExternal | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 전송 횟수 External  |
| countCycleReceiveExternal  | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 수신 횟수 External  |
| countCycleTransferUSB      | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 전송 횟수 USB       |
| countCycleReceiveUSB       | uint8\_t                   | 1 Byte | 0 \~ 255 | 1초당 수신 횟수 USB       |

## Protocol::Attitude <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

자세.

```
namespace Protocol
{
    struct Attitude
    {
        s16     roll;         // Roll
        s16     pitch;        // Pitch
        s16     yaw;          // Yaw
    };
}
```

| 변수 이름. | 형식.      | 크기.    | 범위.               | 설명.   |
| ------ | -------- | ------ | ----------------- | ----- |
| roll   | int16\_t | 2 Byte | -32,768 \~ 32,767 | Roll  |
| pitch  | int16\_t | 2 Byte | -32,768 \~ 32,767 | Pitch |
| yaw    | int16\_t | 2 Byte | -32,768 \~ 32,767 | Yaw   |

드론의 자세를 확인할 때 값의 범위는 다음과 같습니다.

| 변수 이름. | 형식.      | 크기.    | 범위.         | 설명.       |
| ------ | -------- | ------ | ----------- | --------- |
| roll   | int16\_t | 2 Byte | -90 \~ 90   | 좌우 기울기 각도 |
| pitch  | int16\_t | 2 Byte | -90 \~ 90   | 전후 기울기 각도 |
| yaw    | int16\_t | 2 Byte | -180 \~ 180 | 좌우 회전 시 각 |

## Protocol::Position <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

‌위치.

```
namespace Protocol
{
    struct Position
    {
        float       x;      // meter
        float       y;      // meter
        float       z;      // meter
    };
}
```

| 변수 이름. | 형식.   | 크기.    | 범위.             | 단위.   | 설명.        |
| ------ | ----- | ------ | --------------- | ----- | ---------- |
| x      | float | 4 Byte | -100.0 \~ 100.0 | meter | 앞(+),뒤(-)  |
| y      | float | 4 Byte | -100.0 \~ 100.0 | meter | 좌(+),우(-)  |
| z      | float | 4 Byte | -100.0 \~ 100.0 | meter | 위(+),아래(-) |

## Protocol::Altitude <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

고.

```
namespace Protocol
{
    struct Altitude
    {
        f32   temperature;
        f32   pressure;
        f32   altitude;
        f32   rangeHeight;
    };
}
```

| 변수 이름.      | 형식.   | 크기.    | 범위. | 설명.    |
| ----------- | ----- | ------ | --- | ------ |
| temperature | float | 4 Byte | -   | 온도.    |
| pressure    | float | 4 Byte | -   | 압력.    |
| altitude    | float | 4 Byte | -   | 고도.    |
| rangeHeight | float | 4 Byte | -   | 거리 센서의 |

## Protocol::Motion <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

Motion 센서 데이터와 드론의 자세.

```
namespace Protocol
{
    struct Motion
    {
        s16     accX;
        s16     accY;
        s16     accZ;

        s16     gyroRoll;
        s16     gyroPitch;
        s16     gyroYaw;

        s16     angleRoll;
        s16     anglePitch;
        s16     angleYaw;
    };
}
```

| 변수 이름.     | 형식.      | 크기.    | 범위.                                            | 단위.       | 설명.       |
| ---------- | -------- | ------ | ---------------------------------------------- | --------- | --------- |
| accelX     | int16\_t | 2 Byte | <p>-1,568 \~ 1,568</p><p>(-156.8 \~ 156.8)</p> | m/s2 x 10 | 가속도 X     |
| accelY     | int16\_t | 2 Byte | <p>-1,568 \~ 1,568</p><p>(-156.8 \~ 156.8)</p> | m/s2 x 10 | 가속도 Y     |
| accelZ     | int16\_t | 2 Byte | <p>-1,568 \~ 1,568</p><p>(-156.8 \~ 156.8)</p> | m/s2 x 10 | 가속도 Z     |
| gyroRoll   | int16\_t | 2 Byte | -2,000 \~ 2,000                                | degree/s  | 자이로 Roll  |
| gyroPitch  | int16\_t | 2 Byte | -2,000 \~ 2,000                                | degree/s  | 자이로 Pitch |
| gyroYaw    | int16\_t | 2 Byte | -2,000 \~ 2,000                                | degree/s  | 자이로 Yaw   |
| angleRoll  | int16\_t | 2 Byte | -180 \~ 180                                    | degree    | 자세 Roll   |
| angelPitch | int16\_t | 2 Byte | -180 \~ 180                                    | degree    | 자세 Pitch  |
| angleYaw   | int16\_t | 2 Byte | -180 \~ 180                                    | degree    | 자세 Yaw    |

## Protocol::Range <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

Range 센서 데이터 출력.

```
namespace Protocol
{
    struct Range
    {
        s16     left;
        s16     front;
        s16     right;
        s16     rear;
        s16     top;
        s16     bottom;
    };
}
```

| 변수 이름. | 형식.      | 크기.    | 범위.        | 단위. | 설명.                     |
| ------ | -------- | ------ | ---------- | --- | ----------------------- |
| left   | int16\_t | 2 Byte | 0 \~ 2,000 | mm  | 왼쪽을 바라보는 거리 센서의  출력 값.  |
| front  | int16\_t | 2 Byte | 0 \~ 2,000 | mm  | 정면을 바라보는 거리 센서의  출력 값.  |
| right  | int16\_t | 2 Byte | 0 \~ 2,000 | mm  | 오른쪽을 바라보는 거리 센서의  출력 값. |
| rear   | int16\_t | 2 Byte | 0 \~ 2,000 | mm  | 뒤를 바라보는 거리 센서의  출력 값.   |
| top    | int16\_t | 2 Byte | 0 \~ 2,000 | mm  | 위쪽을 바라보는 거리 센서의  출력 값.  |
| bottom | int16\_t | 2 Byte | 0 \~ 2,000 | mm  | 쪽을 바라보는 거리 센서의  출력 값.   |

## Protocol::Count <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

카운트.

비행 시간 및 관련 카운트 값을 읽을 때 사용합니다.

```
namespace Protocol
{
    struct Count
    {
        u32     timeSystem;             // 시스템 동작 시간
        u32     timeFlight;             // 비행 시간

        u16     countTakeOff;           // 이륙 횟수
        u16     countLanding;           // 착륙 횟수
        u16     countAccident;          // 충돌 횟수
    };
}
```

| 변수 이름.        | 형식.       | 크기.    | 범위.         | 설명.            |
| ------------- | --------- | ------ | ----------- | -------------- |
| timeSystem    | uint32\_t | 4 Byte | -           | 시스템 동작 시간(sec) |
| timeFlight    | uint32\_t | 4 Byte | -           | 비행 시간(sec)     |
| countTakeOff  | uint16\_t | 2 Byte | 0 \~ 65,535 | 이륙 횟수          |
| countLanding  | uint16\_t | 2 Byte | 0 \~ 65,535 | 착륙 횟수          |
| countAccident | uint16\_t | 2 Byte | 0 \~ 65,535 | 충돌             |

## Protocol::Bias <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

바이어스.

```
namespace Protocol
{
    struct Bias
    {
        s16     accelX;         // X
        s16     accelY;         // Y
        s16     accelZ;         // Z

        s16     gyroRoll;       // Roll
        s16     gyroPitch;      // Pitch
        s16     gyroYaw;        // Yaw
    };
}
```

| 변수 이름.    | 형식.      | 크기.    | 범위.               | 설명.        |
| --------- | -------- | ------ | ----------------- | ---------- |
| accelX    | int16\_t | 2 Byte | -32,768 \~ 32,767 | Accel X    |
| accelY    | int16\_t | 2 Byte | -32,768 \~ 32,767 | Accel Y    |
| accelZ    | int16\_t | 2 Byte | -32,768 \~ 32,767 | Accel Z    |
| gyroRoll  | int16\_t | 2 Byte | -32,768 \~ 32,767 | Gyro Roll  |
| gyroPitch | int16\_t | 2 Byte | -32,768 \~ 32,767 | Gyro Pitch |
| gyroYaw   | int16\_t | 2 Byte | -32,768 \~ 32,767 | Gyro Yaw   |

## Protocol::Trim <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

Trim

```
namespace Protocol
{
    struct Trim
    {
        s16     roll;         // Roll
        s16     pitch;        // Pitch
        s16     yaw;          // Yaw
        s16     throttle;     // Throttle
    };
}
```

| 변수 이름.   | 형식.      | 크기.    | 범위.         | 설명.      |
| -------- | -------- | ------ | ----------- | -------- |
| roll     | int16\_t | 2 Byte | -200 \~ 200 | Roll     |
| pitch    | int16\_t | 2 Byte | -200 \~ 200 | Pitch    |
| yaw      | int16\_t | 2 Byte | -200 \~ 200 | Yaw      |
| throttle | int16\_t | 2 Byte | -200 \~ 200 | Throttle |

## Protocol::Weight <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

무게.

```
namespace Protocol
{
    struct Weight
    {
        f32     weight;         // Weight
    };
}
```

| 변수 이름. | 형식.   | 크기.    | 범위.        | 설명. |
| ------ | ----- | ------ | ---------- | --- |
| weight | float | 4 Byte | 100 \~ 150 | 무게. |

## Protocol::LostConnection <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

연결이 끊어졌을 때 드론 동작을 처리할 시간 설정.

단위는 ms, 값을 0으로 설정할 경우 해당 항목은 무시.                                                                                           마지막으로 드론 조종 명령을 전송한 장치와의 연결이 끊어지면, 지정한 시간 후 조종 중립, 착륙, 강제 정지를 실행합니다.                                                                                                                                                                            기본으로 연결된 장치는 Rf이며, 설정값은 플래시 메모리에 저장되지 않으므로 매번 드론을 새로 시작할 때마다 설정해야 합니.

```
namespace Protocol
{
    struct LostConnection
    {
        u16     timeNeutral;        // 조종 중립
        u16     timeLanding;        // 착륙
        u32     timeStop;           // 정지
    };
}
```

| 변수 이름.      | 형식.       | 크기.    | 범위.                | 설명.                       |
| ----------- | --------- | ------ | ------------------ | ------------------------- |
| timeNeutral | uint16\_t | 2 Byte | 0 \~ 65,535        | 연결이 끊어졌을 때 조종 중립으로 변경할 시. |
| timeLanding | uint16\_t | 2 Byte | 0 \~ 65,535        | 연결이 끊어졌을 때 드론을 착륙할 시간.    |
| timeStop    | uint32\_t | 4 Byte | 0 \~ 4,294,967,295 | 연결이 끊어졌을 때 드론을 정할 시간.     |

## Protocol::Motor <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

모.

모터 4개를 동시에 작동시키거나, 현재 모터에 입력된 값을 확인할 때 사용합니다.                                                                                           아래의 구조체를 배열로 사용합니다.

```
namespace Protocol
{
    struct Motor
    {
        u8      rotation;
        s16     value;
    };
}
```

| 변수 이름.   | 형식.            | 크기.    | 범위.        | 설명.    |
| -------- | -------------- | ------ | ---------- | ------ |
| rotation | Rotation::Type | 1 Byte | -          | 회전 방향. |
| value    | uint16\_t      | 2 Byte | 0 \~ 4,095 | 회전 속도. |

## Protocol::MotorSingle <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

한 개의 모터 제어.

하나의 모터를 동작시키거나, 현재 모터에 입력된 값을 확인할 때 사용합니다.                                                                                           아래의 구조체를 배열로 사용합니다.

```
namespace Protocol
{
    struct Motor
    {
        u8      rotation;
        s16     value;
    };
}
```

| 변수 이름.   | 형식.            | 크기.    | 범위.        | 설명.    |
| -------- | -------------- | ------ | ---------- | ------ |
| rotation | Rotation::Type | 1 Byte | -          | 회전 방향. |
| value    | uint16\_t      | 2 Byte | 0 \~ 4,095 | 회전 속도. |

## Protocol::BuzzerMelody <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

한 개의 모터 제어.

```
namespace Protocol
{
    struct BuzzerMelody
    {
        u8  melody;     // 멜로디 타입
        u8  repeat;     // 반복횟수
    };
}
```

| 변수 이름. | 형식.                  | 크기.    | 범위.      | 설명.    |
| ------ | -------------------- | ------ | -------- | ------ |
| melody | Buzzer::Melody::Type | 1 Byte | -        | 멜로디.   |
| repeat | uint8\_t             | 1 Byte | 0 \~ 255 | 반복 속도. |

## Protocol::Buzzer <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

버저.

```
namespace Protocol
{
    struct Buzzer
    {
        u8      mode;   // 버저 작동 모드
        u16     value;  // Scale 또는 hz
        u16     time;   // 연주 시간(ms)
    };
}
```

| 변수 이름. | 형식.                 | 크기.    | 범위.         | 설명.            |
| ------ | ------------------- | ------ | ----------- | -------------- |
| mode   | Buzzer::Mode::Type  | 1 Byte | -           | 버저 동작 모드.      |
| value  | Buzzer::Scale::Type | 2 Byte | -           | Scale.         |
|        | uint16\_t           | 2 Byte | 0 \~ 8,000  | Hz.            |
| time   | uint16\_t           | 2 Byte | 0 \~ 65,535 | 소리를 지속할 시간(ms) |

## Protocol::Vibrator <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

.

```
namespace Protocol
{
    struct Vibrator
    {
        u8      mode;   // 모드(0은 set, 1은 reserve)
        u16     on;     // 진동을 켠 시간(ms)
        u16     off;    // 진동을 끈 시간(ms)
        u16     total;  // 전체 진행 시간(ms)
    };
}
```

| 변수 이름. | 형식.                  | 크기.    | 범위.         | 설명.           |
| ------ | -------------------- | ------ | ----------- | ------------- |
| mode   | Vibrator::Mode::Type | 1 Byte | -           | 진동 동작 모드.     |
| on     | uint16\_t            | 2 Byte | 0 \~ 65,535 | 진동을 켠 시간 (ms) |
| off    | uint16\_t            | 2 Byte | 0 \~ 65,535 | 진동을  시간 (ms   |
| total  | uint16\_t            | 2 Byte | 0 \~ 65,535 | 전체  시간(ms)    |

## Protocol::Button <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

버튼.

```
namespace Protocol
{
    struct Button
    {
        u16     button;
        u8      event;
    };
}
```

| 변수 이름. | 형식.                 | 크기.    | 범위. | 설명.     |
| ------ | ------------------- | ------ | --- | ------- |
| button | uint16\_t           | 2 Byte | -   | 버튼 입력.  |
| event  | Button::Event::Type | 1 Byte | -   | 버튼 이벤트. |

## Protocol::JoystickBlock <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

조종기 조이스틱 한 축의 입력 값 .

```
namespace Protocol
{
    struct JoystickBlock
    {
        s8      x;
        s8      y;
        u8      direction;
        u8      event;
    };
}
```

| 변수 이름.    | 형식.                       | 크기.    | 범위.         | 설명.       |
| --------- | ------------------------- | ------ | ----------- | --------- |
| x         | int8\_t                   | 1 Byte | -100 \~ 100 | 조이스틱 가로축. |
| y         | int8\_t                   | 1 Byte | -100 \~ 100 | 조이스틱 세로축. |
| direction | Joystick::Direction::Type | 1 Byte | -           | 조이스틱 향.   |
| event     | Joystick::Event::Type     | 1 Byte | -           | 이벤트.      |

## Protocol::Joystick <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

조종기 조이스틱 한 축의 입력 .

```
namespace Protocol
{
    struct Joystick
    {
        Protocol::JoystickBlock     left;
        Protocol::JoystickBlock     right;
    };
}
```

| 변수 이름. | 형식.                     | 크기.    | 범위. | 설명.       |
| ------ | ----------------------- | ------ | --- | --------- |
| left   | Protocol::JoystickBlock | 4 Byte | -   | 왼쪽 조이스틱.  |
| right  | Protocol::JoystickBlock | 4 Byte | -   | 오른쪽 조이스틱. |

## Protocol::InformationAssembledForController <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

자주 갱신되는 데이터 모음(조종기)

조종기에 표시되는 데이터의 갱신 속도를 높일 목적으로 여러 데이터를 하나로 합친 구조체.&#x20;

```
namespace Protocol
{
    struct InformationAssembledForController
    {
        s16     angleRoll;      // 자세 Roll
        s16     anglePitch;     // 자세 Pitch
        s16     angleYaw;       // 자세 Yaw

        u16     rpm;            // RPM

        s16     positionX;      // meter x 10
        s16     positionY;      // meter x 10
        s16     positionZ;      // meter x 10

        s8      speedX;         // meter x 10
        s8      speedY;         // meter x 10

        u8      rangeHeight;    // meter x 100

        s8      rssi;           // RSSI
    };
}
```

## Protocol::InformationAssembledForEntry <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

자주 갱신되는 데이터 모음(엔트리).

```
namespace Protocol
{
    struct InformationAssembledForEntry
    {
        s16     angleRoll;
        s16     anglePitch;
        s16     angleYaw;

        s16     positionX;
        s16     positionY;
        s16     positionZ;

        s16     rangeHeight;
        float   altitude;
    };
}
```

## Protocol::InformationAssembledForByblocks <a href="#protocol-pairing-4" id="protocol-pairing-4"></a>

자주 갱신되는 데이터 모음().

```
namespace Protocol
{
    struct InformationAssembledForByBlocks
    {
        s8      battery;        // 배터리 잔량
        
        s16     angleRoll;      // 자세 Roll
        s16     anglePitch;     // 자세 Pitch
        s16     angleYaw;       // 자세 Yaw
        
        s16     positionX;      // meter x 10
        s16     positionY;      // meter x 10
        s16     positionZ;      // meter x 10
        
        s16     rangeLeft;      // meter x 1000
        s16     rangeFront;     // meter x 1000
        s16     rangeRight;     // meter x 1000
        s16     rangeBottom;    // meter x 1000
    };
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://robolink.gitbook.io/codrone-mini/codrone_lib/codrone_protocol_main/structs.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.