#include <CoDrone.h>                     // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                    // 드론 플러그의 통신 개시 (115200bps)

CoDrone.AutoConnect(NearbyDrone);   // 가장 가까운 위치의 드론과 연결

CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정 (비행 형태)

// 2초간 드론을 띄운후 착륙하기
if (PAIRING == true)                         // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);             // 이륙
delay(2000);                                    // 대기 시간
CoDrone.FlightEvent(Landing);             // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                            // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                           // 드론 플러그의 통신 개시 (115200bps)

CoDrone.AutoConnect(ConnectedDrone);     // 최근에 연결한 드론과 같은 어드레스 주소의 드론을 연결

CoDrone.DroneModeChange(Flight);           // 드론을 플라이트 모드로 설정합니다. (비행형)

// 2초간 드론을 띄운후 착륙하기
if (PAIRING == true)                                // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);                    // 이륙
delay(2000);                                           // 대기 시간
CoDrone.FlightEvent(Landing);                    // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                     // 코드론을 사용하기 위한 헤더파일
void setup()
{
CoDrone.begin(115200);                    // 드론 플러그의 통신 개시 (115200bps)

//CoDrone.PrintDroneAddress();           // 최근에 연결한 드론의 어드레스 주소를 모니터로 출력합니다.

byte droneAddress[6] = {0xFC, 0xA6, 0x61, 0x78, 0xD5, 0xA4};
// 어드레스 주소를 입력 - PrintDroneAddress() 명령으로 확인)

CoDrone.AutoConnect(AddressInputDrone, droneAddress); // 입력한 어드레스 주소와 같은 드론과 연결

CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정합니다. (비행형)

// 2초간 드론을 띄운후 착륙하기
if (PAIRING == true) // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.lightEvent(TakeOff);              // 이륙
delay(2000);                                    // 대기 시간
CoDrone.FlightEvent(Landing);             // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>            // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);          // 드론 플러그의 통신 개시 (115200bps)

CoDrone.PrintDroneAddress();   // 최근에 연결한 드론의 어드레스 주소를 시리얼 모니터로 출력
}

void loop()
{
}

#include <CoDrone.h>                      // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                     // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);    // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);      // 드론을 플라이트 모드로 설정합니다. (비행형)

if (PAIRING == true)                          // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);              // 이륙

delay(2000);                                     // 대기 시간

CoDrone.FlightEvent(Landing);              // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                     // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                    // 드론 플러그의 통신 개시
(115200bps)
CoDrone.AutoConnect(NearbyDrone);   // 가장 가까운 드론과 연결
CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정합니다. (비행형)

if (PAIRING == true)                         // 연결(페어링)이 성공한 경우에만 실행
{
THROTTLE = 100                             // THROTTLE 값 입력 100 상승 –100 하강
CoDrone.Control();                           // 조종값 전송

delay(2000);                                   // 대기 시간 입력

CoDrone.FlightEvent(Stop);                // 정지
}
}

void loop()
{
}

#include <CoDrone.h>                     // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                    // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);   // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정합니다. (비행형)

if (PAIRING == true)                         // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);             // 이륙

delay(2000);                                    // 대기 시간

PITCH = 100;                                  // PITCH 값 입력
CoDrone.Control();                           // 조종값 전송

delay(500);                                     // 대기 시간

CoDrone.FlightEvent(Landing);            // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                      // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                     // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);   // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정합니다. (비행형)

if (PAIRING == true)                          // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);              // 이륙

delay(2000);                                     // 대기 시간

ROLL = 100;                                    // Roll 값 입력
CoDrone.Control();                            // 조종값 전송
delay(1000);                                     // 대기 시간

CoDrone.FlightEvent(Landing);             // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                     // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                    // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);   // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정합니다. (비행형)

if (PAIRING == true)                         // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);             // 이륙

delay(2000);                                    // 대기 시간

YAW = 100;                                    // Yaw 값 입력
CoDrone.Control();                            // 조종값 전송

delay(1000);                                    // 대기 시간

CoDrone.FlightEvent(Landing);             // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                     // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                    // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);   // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정합니다. (비행형)

delay(300);                                      // 대기 시간

if (PAIRING == true)                         // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TurnOver);           // 뒤집기

delay(4000);                                    // 실행 시간

CoDrone.FlightEvent(Stop);                 // 멈춤
}
}

void loop()
{
}

#include <CoDrone.h> // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                    // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);   // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);     // 드론을 플라이트 모드로 설정합니다. (비행형)
}

void loop()
{
byte bt1 = digitalRead(11);       // ■ □ □ □ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt4 = digitalRead(14);       // □ □ □ ■ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt8 = digitalRead(18);       // □ □ □ □ □ □ ■ 밑면 적외선 센서를 입력으로 사용

if (bt1 && !bt4 && !bt8)          // 밑면 센서 가장 끝 11번 센서에 손을 대면 실행합니다.
{
CoDrone.FlightEvent(Stop);        // 드론을 정지시킵니다.
}

if (!bt1 && !bt4 && bt8)           // 밑면 센서 가장 끝 18번 센서에 손을 대면 실행합니다.
{
CoDrone.FlightEvent(Landing);    // 드론을 착륙시킵니다.
}

if (PAIRING == true)                 // 연결(페어링)이 성공한 경우에만 실행
{
YAW = -1 * CoDrone.AnalogScaleChange(analogRead(A3));
// 아날로그 3번 핀의 값을 YAW 값으로 사용합니다. - 좌우회전

THROTTLE = CoDrone.AnalogScaleChange(analogRead(A4));
// 아날로그 4번 핀의 값을 THROTTLE 값으로 사용합니다. - 승하강

ROLL = -1 * CoDrone.AnalogScaleChange(analogRead(A5));
// 아날로그 5번 핀의 값을 ROLL 값으로 사용합니다. - 좌우이동

PITCH = CoDrone.AnalogScaleChange(analogRead(A6));
// 아날로그 6번 핀의 값을 PITCH 값으로 사용합니다. - 전후진

CoDrone.Control(SEND_INTERVAL);
// 제어 신호를 보냅니다. 통신이 안정하게 가도록 시간을 두고 보냄 (최소 50ms)
}
}

#include <CoDrone.h>                    // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                   // 드론 플러그의 통신 개시 (115200bps)


CoDrone.AutoConnect(NearbyDrone);  // 가장 가까운 위치의 드론과 연결

CoDrone.DroneModeChange(Drive);    // 드론을 드라이브 모드로 설정합니다. (바퀴 주행형)
}

void loop()
{
byte bt1 = digitalRead(11);     // ■ □ □ □ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt4 = digitalRead(14);     // □ □ □ ■ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt8 = digitalRead(18);     // □ □ □ □ □ □ ■ 밑면 적외선 센서를 입력으로 사용

if (PAIRING == true)              // 연결(페어링)이 성공한 경우에만 실행
{
THROTTLE = CoDrone.AnalogScaleChange(analogRead(A4));
// 아날로그 4번 핀의 값을 THROTTLE 값으로 사용합니다. - 전후 이동

ROLL = -1 * CoDrone.AnalogScaleChange(analogRead(A5));
// 아날로그 5번 핀의 값을 ROLL 값으로 사용합니다. - 좌우 이동

CoDrone.Control(SEND_INTERVAL);
// 제어 신호를 보냅니다. 통신이 안정하게 가도록 시간을 두고 보냄(최소 50ms)

}
}

#include <CoDrone.h>                         // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                        // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);       // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);         // 드론을 플라이트 모드로 설정 (비행형태)

CoDrone.BattleBegin(FREE_PLAY);   // 팀 선택 : TEAM_RED/ TEAM_BLUE/ TEAM_GREEN/ TEAM_YELLOW/ FREE_PLAY
}

void loop()
{
CoDrone.BattleReceive();               // IR-Data 수신

byte bt1 = digitalRead(11);            // ■ □ □ □ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt4 = digitalRead(14);            // □ □ □ ■ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt8 = digitalRead(18);            // □ □ □ □ □ □ ■ 밑면 적외선 센서를 입력으로 사용

if (bt1 && !bt4 && !bt8)               // 밑면 센서 가장 끝 11번 센서에 손을 대면 실행합니다.
{
CoDrone.FlightEvent(Stop);             // 드론을 긴급 정지시킵니다.
}

if (!bt1 && !bt4 && bt8)               // 밑면 센서 가장 끝 18번 센서에 손을 대면 실행합니다.
{
CoDrone.BattleShooting();              // 무기를 발사합니다.
CoDrone.ButtonPreesHoldWait(18);  // 버튼을 뗄때까지 기다립니다. (연속적인 발사를 막습니다.)
}

if (!bt1 && bt4 && !bt8)                // 밑면 가운데 센서에 손을 대면 실행합니다.
{
CoDrone.FlightEvent(Landing);          // 드론을 서서히 착륙 시킵니다.
}

YAW = -1 * CoDrone.AnalogScaleChange(analogRead(A3));
// 아날로그 3번 핀의 값을 YAW 값으로 사용합니다. - 좌우회전

THROTTLE = CoDrone.AnalogScaleChange(analogRead(A4));
// 아날로그 4번 핀의 값을 THROTTLE 값으로 사용합니다. - 승하강

ROLL = -1 * CoDrone.AnalogScaleChange(analogRead(A5));
// 아날로그 5번 핀의 값을 ROLL 값으로 사용합니다. - 좌우이동

PITCH = CoDrone.AnalogScaleChange(analogRead(A6));
// 아날로그 6번 핀의 값을 PITCH 값으로 사용합니다. - 전후진

CoDrone.Control(SEND_INTERVAL);
// 제어 신호를 보냅니다. 통신이 안정하게 가도록 시간을 두고 보냄 (최소 50ms)
}

#include <CoDrone.h>                       // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                      // BLE보드의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);    // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);      // 드론을 플라이트 모드로 설정한다. (비행형)
}
void loop()
{
byte bt1 = digitalRead(11);                   // ■ □ □ □ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt4 = digitalRead(14);                   // □ □ □ ■ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt8 = digitalRead(18);                   // □ □ □ □ □ □ ■ 밑면 적외선 센서를 입력으로 사용

if ((analogRead(A4) < 50) && (analogRead(A6) < 50))   // 조이스틱 양쪽을 아래로 내리면 실행한다.
{
CoDrone.FlightEvent(Stop);                                      // 드론을 정지시킨다.
}

if (PAIRING == true)                                              // 연결(페어링)이 성공한 경우에만 실행
{
YAW = -1 * CoDrone.AnalogScaleChange(analogRead(A3));
// 아날로그 3번 핀의 값을 YAW 값으로 사용한다. - 좌우회전

THROTTLE = CoDrone.AnalogScaleChange(analogRead(A4));
// 아날로그 4번 핀의 값을 THROTTLE 값으로 사용한다. - 승·하강

ROLL = -1 * CoDrone.AnalogScaleChange(analogRead(A5));
// 아날로그 5번 핀의 값을 ROLL 값으로 사용한다. - 좌우이동

PITCH = CoDrone.AnalogScaleChange(analogRead(A6));
// 아날로그 6번 핀의 값을 PITCH 값으로 사용한다. - 전·후진

CoDrone.Control(SEND_INTERVAL);
// 제어 신호를 보낸다. 통신이 안정하게가도록 시간을 두고 보냄(최소 50ms)
}
}

#include <CoDrone.h>                       // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                      // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);    // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);      // 드론을 플라이트 모드로 설정한다. (비행형)
CoDrone.GoToHeight(800);                  // 800mm(80cm) 높이로 이동(입력 범위 : 1 ~ 2000 (단위: mm))
delay(1000);                                     // 1초 기다리기

CoDrone.FlightEvent(Landing);              // 착륙
}

void loop()
{
}

#include <CoDrone.h>                    // 코드론을 사용하기 위한 헤더파일

byte modeTime = 7;                          // 모드 시간 변수
int delayTime = 1000;                        // 대기 시간 변수

void setup()
{
CoDrone.begin(115200);                     // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);    // 가장 가까운 위치의 드론과 연결
}

void loop()
{
CoDrone.LedColor(ArmDimming, Yellow, modeTime);
// 노랑색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime); // 대기 시간 입력

CoDrone.LedColor(ArmDimming, Cyan, modeTime);
// 하늘색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime); // 대기 시간 입력
}

#include <CoDrone.h>                    // 코드론을 사용하기 위한 헤더파일

byte modeTime = 7;                          // 모드 시간 변수
int delayTime = 1000;                        // 대기 시간 변수

void setup()
{
CoDrone.begin(115200);                      // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);     // 가장 가까운 위치의 드론과 연결
}

void loop()
{
CoDrone.LedColor(ArmDimming, 255, 0, 0, modeTime);
// 입력된 R,G,B 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력

CoDrone.LedColor(ArmDimming, 0, 255, 0, modeTime);
// 입력된 R,G,B 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력

CoDrone.LedColor(ArmDimming, 0, 0, 255, modeTime);
// 입력된 R,G,B 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력

CoDrone.LedColor(ArmDimming, 0, 0, 0, modeTime);
// 입력된 R,G,B 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력
}

#include <CoDrone.h>                    // 코드론을 사용하기 위한 헤더파일

byte modeTime = 7;                          // 모드 시간 변수
int delayTime = 1000;                        // 대기 시간 변수

byte color0[] = {255, 0, 0}; //color0 색상 배열 (R,G,B)
byte color1[] = {0, 255, 0}; //color1 색상 배열 (R,G,B)
byte color2[] = {0, 0, 255}; //color2 색상 배열 (R,G,B)
byte color3[] = {0, 0, 0}; //color3 색상 배열 (R,G,B)

void setup()
{
CoDrone.begin(115200);                      // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NeardbyDrone);   // 가장 가까운 위치의 드론과 연결
}

void loop()
{
CoDrone.LedColor(ArmDimming, color0, modeTime);
// color0에 입력된 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력

CoDrone.LedColor(ArmDimming, color1, modeTime);
// color1에 입력된 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력

CoDrone.LedColor(ArmDimming, color2, modeTime);
// color2에 입력된 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력

CoDrone.LedColor(ArmDimming, color3, modeTime);
// color3에 입력된 색으로 밝기 제어하여 천천히 깜빡이며 modeTime 따라 동작합니다.

delay(delayTime);                               // 대기 시간 입력
}

#include <CoDrone.h>                    // 코드론을 사용하기 위한 헤더파일

byte mode1 = ArmHold;
byte color1[] = {0, 0, 255};                  //color1 색상 배열 (R,G,B)
byte modeTime1 = 255;                     // 모드 시간 변수

byte mode2 = EyeHold;
byte color2[] = {255, 255, 0};                //color2 색상 배열 (R,G,B)
byte modeTime2 = 255;                      // 모드 시간 변수

void setup()
{
CoDrone.begin(115200);                       // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);      // 가장 가까운 위치의 드론과 연결
CoDrone.LedColorDefault(mode1, color1, modeTime2, mode2, color2, modeTime2);
// color에 입력된 색, mode와 modeTime에 따라 동작합니다.
}

void loop()
{
}

#include <CoDrone.h>                      // 코드론을 사용하기 위한 헤더파일
byte level = 50;                                // 이곳에서 설정한 값이 배터리 기준 값이 됨

void setup()
{
CoDrone.begin(115200);                     // 드론 플러그의 기능 개시
CoDrone.AutoConnect(NearbyDrone);    // 가장 가까운 위치의 드론과 연결
CoDrone.LowBatteryCheck(level);          // 만약 배터리가 입력한 기준 값 보다 작다면 부저를 울려서 알려줌
}

void loop()
{
}

#include <CoDrone.h>

void setup()
{
CoDrone.begin(115200);
CoDrone.AutoConnect(NearbyDrone);
delay(500);
}

void loop()
{
AttitudeToSerialMonitor();
delay(500);
}

void AttitudeToSerialMonitor()
{
//---------------------------------------------------------------------------------------------//
CoDrone.Send_LinkModeBroadcast(LinkBroadcast_Active); //link module mode change => Active
delay(100);
CoDrone.Request_DroneAttitude();

long oldTime = millis();
boolean attitudeSuccess = false;
CoDrone.receiveAttitudeSuccess = 0; //receiveAttitudeSuccess flag init

while (attitudeSuccess == false) //receiveAttitudeSuccess check
{
CoDrone.Receive();
if (CoDrone.receiveAttitudeSuccess == 1) attitudeSuccess = true;
if (oldTime + 1000 < millis()) break;
}

//---------------------------------------------------------------------------------------------//
if (attitudeSuccess == true)
{
CoDrone.Send_LinkModeBroadcast(LinkModeMute); //link module mode change => Mute
delay(300);

Serial.println("");
Serial.println("--------- Now attitude -----------");
Serial.print("ROLLt");
Serial.println(AttitudeROLL);
Serial.print("PITCHt");
Serial.println(AttitudePITCH);
Serial.print("YAWt");
Serial.println(AttitudeYAW);
delay(500);
}
//---------------------------------------------------------------------------------------------//
}

#include <CoDrone.h>                      // 코드론을 사용하기 위한 헤더파일

void setup()
{

CoDrone.begin(115200);                     // 드론 플러그의 통신 개시 (115200bps)

CoDrone.AutoConnect(NearbyDrone);    // 가장 가까운 위치의 드론과 연결

CoDrone.DisplayRSSI();                       // 연결된 드론의 RSSI(신호세기) 값을 LED 불빛으로 표시
}

#include <CoDrone.h>                      // 코드론을 사용하기 위한 헤더파일

int scale = 200;                                // LED 불빛 한개의 기준 고도 200mm
int firstLEDpin = 11;                          // 스마트 보드의 LED 핀 시작 번호

void setup()
{
CoDrone.begin(115200);                     // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);    // 가장 가까운 위치의 드론과 연결

delay(500);

for (int thisPin = 11; thisPin <=1 8; thisPin++) {
pinMode(thisPin, OUTPUT);
}
for (int thisPin = 11; thisPin <=1 8; thisPin++) {
digitalWrite(thisPin, LOW);
}
}

void loop()
{
CoDrone.Request_Range();
long oldTime = millis();

while (CoDrone.receiveRangeSuccess) //receiveRangeSuccess check
{
CoDrone.Receive();
if (oldTime + 1000 < millis()) break;
}

if (CoDrone.receiveRangeSuccess == true)
{
int _sensor = CoDrone.sensorRange[5] / scale;

if (_sensor < 0 )_sensor=0 ;
if (_sensor > 7) _sensor = 7;
for (int thisPin = 11; thisPin <=1 8; thisPin++) {
digitalWrite(thisPin, LOW);
}

digitalWrite(firstLEDpin, HIGH);
for (int i = 1; i < _sensor ; i++)
{
digitalWrite(++firstLEDpin , HIGH);
}
}
}

#include <CoDrone.h>                        // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                       // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);      // 가장 가까운 위치의 드론과 연결
delay(500);
}
void loop()
{
RangeSensorToSerialMonitor();
}

void RangeSensorToSerialMonitor()
{
//---------------------------------------------------------------------------------------------//
CoDrone.Send_LinkModeBroadcast(LinkBroadcast_Active); //link module mode change => Active
delay(100);
CoDrone.Request_Range();

long oldTime = millis();
while (CoDrone.receiveRangeSuccess == false) //receiveRangeSuccess check
{
CoDrone.Receive();
if (oldTime + 1000 < millis()) break; //time out check
}
//---------------------------------------------------------------------------------------------//
if (CoDrone.receiveRangeSuccess == true)
{
CoDrone.Send_LinkModeBroadcast(LinkModeMute); //link module mode change => Mute
delay(300);

Serial.println("");
Serial.println("--------------- Sensor ---------------");
Serial.print("range tt");
Serial.print(CoDrone.sensorRange[5]);
Serial.println(" mm");
Serial.println("-------------------------------------- ");
delay(500);
}
//---------------------------------------------------------------------------------------------//
}

#include <CoDrone.h>                            // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                           // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);         // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);           // 드론을 플라이트 모드로 설정합니다. (비행형)

delay(300);                                            // 대기 시간

if (PAIRING == true)                                // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);                    // 이륙

delay(1000);                                           // 대기 시간

PITCH = 50;                                           // PITCH 값 입력
ROLL = 50;                                            // ROLL 값 입력
CoDrone.Control();                                  // 입력된 값으로 드론 동작

delay(1000);                                           // 대기 시간

PITCH = 50;                                           // PITCH 값 입력
ROLL = -50;                                           // ROLL 값 입력
CoDrone.Control();                                  // 입력된 값으로 드론 동작

delay(1000);                                           // 대기 시간

PITCH = -50;                                          // PITCH 값 입력
ROLL = -50;                                           // ROLL 값 입력
CoDrone.Control();                                  // 입력된 값으로 드론 동작

delay(1000);                                           // 대기 시간

PITCH = -50;                                          // PITCH 값 입력
ROLL = 50;                                            // ROLL 값 입력
CoDrone.Control();                                  // 입력된 값으로 드론 동작

delay(1000);                                           // 대기 시간

CoDrone.FlightEvent(Landing);                    // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                            // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                           // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);         // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);           // 드론을 플라이트 모드로 설정합니다. (비행형)

delay(300);                                            // 대기 시간

if (PAIRING == true)
{
CoDrone.FlightEvent(TakeOff);                    // 이륙
delay(1000);                                           // 대기 시간

THROTTLE = 60;                                     // THROTTLE 값 입력
                                                          //90도 반원 회전 4번 반복
for(int i=0;i<4;i++)
{
THROTTLE = THROTTLE - 10;                    // THROTTLE 값 입력
YAW = -80;                                           // YAW 값 입력
ROLL = 50;                                            // ROLL 값 입력
CoDrone.Control();                                  // 조종값 전송

delay(1500);                                           // 대기 시간
}
CoDrone.FlightEvent(Stop);                        // 멈춤
}
}

void loop()
{
}

#include <CoDrone.h>                                // 코드론을 사용하기 위한 헤더파일

void setup()
{
CoDrone.begin(115200);                              // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);             // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);               // 드론을 플라이트 모드로 설정합니다. (비행형)

if (PAIRING == true)                                    // 연결(페어링)이 성공한 경우에만 실행
CoDrone.FlightEvent(TakeOff);                        // 이륙
delay(1000);                                               // 대기 시간

PITCH = 30;                                               // PITCH 값 입력
CoDrone.Control();                                       // 조종값 전송
delay(300);                                                 // 대기 시간

CoDrone.FlightEvent(Stop);                            // 서서히 착륙
}
}

void loop()
{
}

#include <CoDrone.h>                                // 코드론을 사용하기 위한 헤더파일

void setup() {
CoDrone.begin(115200);                              // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);             // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);               // 드론을 플라이트 모드로 설정합니다. (비행형)

delay(400);                                                // 대기 시간

if (PAIRING == true)                                   // 연결(페어링)이 성공한 경우에만 실행
{
CoDrone.FlightEvent(TakeOff);                       // 이륙

delay(1000);                                               // 대기 시간
                                                              // 상승
THROTTLE = 20;                                         // THROTTLE 값 입력
CoDrone.Control();                                      // 조종값 전송

delay(500);                                                // 대기 시간
                                                              // 전진
THROTTLE = 0;                                          // THROTTLE 전송
PITCH = 100;                                            // PITCH 전송
ROLL = -10;                                              // ROLL 전송
CoDrone.Control();                                      // 조종값 전송

delay(300);                                                // 대기 시간
                                                              // 제자리 비행
THROTTLE = 0;                                          // THROTTLE 전송
PITCH = 0;                                                // PITCH 전송
ROLL = 0;                                                 // ROLL 전송
CoDrone.Control();                                      // 조종값 전송
delay(500);                                                // 대기 시간

CoDrone.FlightEvent(Landing);                       // 착륙
}
}

void loop() {
}

#include <CoDrone.h>                         // 코드론을 사용하기 위한 헤더파일
void setup()
{
CoDrone.begin(115200);                        // 드론 플러그의 통신 개시 (115200bps)
CoDrone.AutoConnect(NearbyDrone);      // 가장 가까운 위치의 드론과 연결
CoDrone.DroneModeChange(Flight);        // 드론을 플라이트 모드로 설정합니다. (비행형)
}

void loop()
{
byte bt1 = digitalRead(11);                    // ■ □ □ □ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt4 = digitalRead(14);                    // □ □ □ ■ □ □ □ 밑면 적외선 센서를 입력으로 사용
byte bt8 = digitalRead(18);                    // □ □ □ □ □ □ ■ 밑면 적외선 센서를 입력으로 사용

int analogValue0 = analogRead(A0);        // 자기가 원하는 것과 연결가능
int analogValue1 = analogRead(A1);        // 자기가 원하는 것과 연결가능
int analogValue2 = analogRead(A2);        // 자기가 원하는 것과 연결가능

if (bt1 && !bt4 && !bt8)                       // 밑면 센서 가장 끝 11번 센서에 손을 대면 실행합니다.
{
CoDrone.FlightEvent(Stop);                     // 드론을 정지시킵니다.
}

if (bt4)                                               // 밑면 센서 중앙 14번 센서에 손을 대면 실행합니다.

{
THROTTLE = map(analogValue1, 0, 1023, -50, 200);                // 승하강
ROLL = map(analogValue0, 0, 1023, 100, 0) + map(analogValue2, 0, 1023, -100, 0); // 좌우이동
CoDrone.Control(SEND_INTERVAL); //제어 신호를 보냅니다. 시간을 두고 보냄 (최소 50ms)
}

if (bt8)                                               // 밑면 센서 가장 끝 18번 센서에 손을 대면 실행합니다.
{
THROTTLE = map(analogValue1, 0, 1023, -50, 200);                // 승하강
PITCH = map(analogValue0, 0, 1023, -100, 0) + map(analogValue2, 0, 1023, 100, 0); // 전후진
CoDrone.Control(SEND_INTERVAL); // 제어 신호를 보냅니다. 시간을 두고 보냄 (최소 50ms)
}
}