Complete Documentation

Everything you need to know about FLYQ Air & FLYQ Vision
From unboxing to autonomous flight programming

Hardware Guides Programming Tutorials Flight Training

Call Us

+91 9137361474

WhatsApp

Chat Now

Quick Start Guide

From unboxing to your first flight in 30 minutes

1

Unbox Your FLYQ Drone

Carefully open your FLYQ package and verify all components are present:

  • 1x Assembled drone frame with PCB
  • 4x Coreless DC motors (720 type)
  • 4x Propellers (2 CW + 2 CCW)
  • 2x Spare propellers
  • 1x 3.7V LiPo battery (600mAh)
  • 1x USB-C charging cable
  • 4x Propeller guards (optional)
  • 1x Screwdriver tool
  • 1x Quick start guide
  • 1x Safety card

Important: Keep propellers away from motors until you're ready to fly. Store battery safely at room temperature.

2

Charge the Battery

Before your first flight, fully charge the LiPo battery:

  1. 1. Connect USB-C cable to the battery charging port
  2. 2. Plug into 5V USB power source (computer, phone charger, power bank)
  3. 3. LED indicator will turn RED while charging
  4. 4. LED turns GREEN when fully charged (~45 minutes)
  5. 5. Disconnect once complete to preserve battery life

DON'T:

  • • Use fast chargers (>5V)
  • • Leave unattended while charging
  • • Charge damaged battery
  • • Overcharge beyond 4.2V

DO:

  • • Use 5V 1A USB charger
  • • Charge on fireproof surface
  • • Monitor during charging
  • • Store at 50% if not flying
3

Install Development Tools

Choose your preferred programming environment:

Option 1: Arduino IDE (Recommended for Beginners)

Easy-to-use IDE with extensive libraries

  1. 1. Download from arduino.cc/downloads
  2. 2. Install ESP32 board support: Tools → Board → Boards Manager → Search "ESP32"
  3. 3. Select board: ESP32S3 Dev Module
  4. 4. Install FLYQ library from GitHub
  5. 5. Open Examples → FLYQ → BasicFlight

Option 2: Python SDK (For Autonomous Flight)

Crazyflie-compatible Python library

$ pip install cflib
$ pip install flyq-python
# Verify installation
$ python -c "import cflib; print('Success!')"

Option 3: ESP-IDF (Advanced Firmware Development)

Professional development framework

  1. 1. Follow ESP-IDF setup guide
  2. 2. Clone FLYQ firmware: git clone https://github.com/passion3d/flyq-firmware
  3. 3. Configure project: idf.py menuconfig
  4. 4. Build & flash: idf.py build flash
4

Connect & Calibrate

Establish connection and calibrate sensors:

Wi-Fi Connection

  1. 1. Power on drone by connecting battery
  2. 2. Wait for LED to blink blue (AP mode)
  3. 3. On your device, connect to Wi-Fi: FLYQ-XXXX
  4. 4. Default password: flyq1234
  5. 5. Open browser to: http://192.168.4.1

IMU Calibration (Critical!)

  1. 1. Place drone on flat, level surface
  2. 2. In web interface, click "Calibrate IMU"
  3. 3. Keep drone perfectly still for 10 seconds
  4. 4. LED will turn solid green when complete
  5. 5. Recalibrate if LED blinks red (failed)

Tip: Calibrate IMU before every flight session for best stability

5

Your First Flight! 🚀

Ready for takeoff? Follow these safety steps:

Pre-Flight Checklist:

  • Battery fully charged
  • Propellers secured correctly
  • IMU calibrated
  • Clear 3m radius around drone
  • Indoors, no wind
  • Propeller guards installed

Flight Controls:

  • Throttle (Up/Down): W/S keys
  • Yaw (Rotate): A/D keys
  • Pitch (Forward/Back): ↑/↓ arrows
  • Roll (Left/Right): ←/→ arrows
  • Emergency Stop: SPACE key

Watch First Flight Tutorial

Follow along with our step-by-step video guide for a successful maiden flight

Watch on YouTube
6

Begin Your Learning Journey

Congratulations on your first flight! Now continue learning with our comprehensive documentation and project ideas below.

Programming Tutorials

Arduino, Python, and ESP-IDF examples with step-by-step guides

Hardware & Troubleshooting

Complete hardware specs, firmware flashing, and problem solutions

Project Ideas

Beginner to advanced projects with examples and inspiration

You're All Set! 🎉

Your FLYQ drone is ready to fly. Start with basic flights, then progress to autonomous missions. Join our community for support!

Hardware Architecture

Complete technical reference for FLYQ Air & FLYQ Vision drone hardware

ESP32-S3 Processor

Core Specifications

  • Dual-Core Xtensa LX7: 240MHz max frequency
  • SRAM: 512KB on-chip memory
  • Flash: 4MB external flash
  • PSRAM: 8MB (FLYQ Vision only)
  • FPU: Single-precision floating point unit
  • Vector Instructions: AI acceleration support

Wireless Connectivity

  • Wi-Fi 802.11 b/g/n: 2.4GHz, up to 150Mbps
  • Bluetooth 5.0 LE: Long range mode
  • Range: Up to 50m (line of sight)
  • Security: WPA2/WPA3, AES encryption
  • Antenna: PCB trace antenna + U.FL connector

FLYQ Air

Basic Programmable Drone

Processor & Memory

CPU ESP32-S3 Dual-Core Xtensa LX7 @ 240MHz
SRAM 512KB on-chip
Flash 4MB external
Architecture 32-bit with FPU

Connectivity

Wi-Fi 802.11 b/g/n 2.4GHz
Bluetooth BLE 5.0 Long Range
Range 50m (open space)
USB Type-C (data + charging)

Sensors & IMU

IMU MPU6050 6-axis (Gyro + Accel)
Gyroscope ±250/500/1000/2000 °/s
Accelerometer ±2/4/8/16 g
Sample Rate 1kHz max

Motor System

Motors 4x 720 coreless DC motors
Max RPM 38,000 RPM
Voltage 3.7V nominal
Control PWM via MOSFET H-bridge

Power System

Battery 1S LiPo 3.7V 600mAh
Flight Time 8-10 minutes
Charge Time ~45 minutes (5V 1A)
Protection Over-charge, over-discharge

Physical Dimensions

Size 92 x 92 x 20mm
Weight ~45g (w/o battery)
Propellers 4 x 45mm diameter
Frame Lightweight plastic + PCB

Expansion I/O

Connector 24-pin 2.54mm header
GPIO 18 available pins
I2C 1x bus (sensors)
SPI 1x bus (expansion modules)
UART 2x serial ports
ADC 6x channels, 12-bit

FLYQ Vision

Camera & Vision AI Drone

Camera Module

Sensor OV2640 2MP CMOS
Resolution 1280 x 720 (HD 720p)
Frame Rate 30 FPS
FOV 120° wide angle
Streaming Real-time Wi-Fi MJPEG

Vision Processing

PSRAM 8MB for frame buffers
AI Accelerator Vector instructions
Gesture Recognition Hand tracking, poses
Latency < 200ms streaming

Enhanced Processor

CPU ESP32-S3 Dual-Core @ 240MHz
SRAM 512KB on-chip
PSRAM 8MB external
Flash 4MB SPI flash

Gesture Control Features

  • Takeoff/landing hand gestures
  • Direction control with hand movements
  • Photo/video capture triggers
  • Follow-me mode via hand tracking
  • Emergency stop gesture

Enhanced Connectivity

Wi-Fi 802.11 b/g/n dual antenna
Video Streaming HD 720p @ 30fps
Range 50m with video
Protocols UDP, WebSocket, RTSP

SDK & Programming

Arduino IDE ✓ Full support + camera libs
Python SDK ✓ OpenCV integration
ESP-IDF ✓ Advanced firmware
Mobile App iOS & Android (WebRTC)

Power & Performance

Battery 1S LiPo 3.7V 600mAh
Flight Time 7-9 min (with camera)
Weight ~52g (w/ camera)
Power Draw Higher due to camera

Need Hardware Support?

Our technical team is here to help with any hardware questions

Design Philosophy

Professional drone engineering made accessible for education and development

Beginner Friendly

Easy Assembly &
Affordable Pricing

FLYQ drones are designed with education in mind. Unlike expensive commercial drones, FLYQ provides professional-grade hardware at student-friendly prices. All components are clearly labeled, and assembly takes just 30 minutes with our step-by-step guide.

Modular Design

Snap-together components with clear markings - no soldering required for basic assembly

Budget-Friendly

Starting at ₹8,999 - 10x cheaper than commercial alternatives like DJI Tello

Complete Documentation

Video tutorials, illustrated guides, and 24/7 community support

What's Included

  • Pre-assembled flight controller PCB
  • 4x Brushless motors (pre-mounted)
  • 4x Propellers with spare set
  • LiPo battery with charger
  • USB-C cable for programming
  • Frame kit (pre-cut carbon fiber)
  • Quick start guide & stickers

Assembly Time: 30 minutes for beginners

Control Methods

Web-Based Controller

Control from any device with a web browser - no app installation required

Python Scripts

Write autonomous flight programs using CrazyFlie Python API

Joystick/Controller

Connect any USB gamepad for manual flight control

Custom Applications

Build your own control apps using WebSocket API

No Radio Controller Required

WiFi-Based
Smart Control

FLYQ uses WiFi for control - eliminating the need for expensive radio transmitters. Connect your smartphone, tablet, or laptop to the drone's WiFi hotspot and control it through a web interface or Python scripts.

Low Latency

20-30ms response time - fast enough for manual flight and real-time control

50m Range

Reliable 2.4GHz WiFi connection up to 50 meters (line of sight)

Live Video Streaming

FLYQ Vision streams 720p video @ 30fps directly to your device (WiFi Vision model only)

Expansion & Compatibility

24-Pin Expansion Header

FLYQ features a professional expansion connector supporting multiple communication protocols:

I²C 2x I²C buses for sensors (barometer, ToF, compass)
SPI High-speed SPI for displays, SD cards, optical flow
UART 2x UART for GPS, telemetry, external MCU
GPIO 10x GPIO pins with PWM, ADC, DAC support
POWER 5V & 3.3V regulated power (500mA max)

Compatible Sensors & Modules

Expand your FLYQ with professional-grade sensors:

Altitude & Position
  • • VL53L1X ToF sensor (accurate height hold)
  • • MS5611 barometer (altitude measurement)
  • • PMW3901 optical flow (position lock indoors)
  • • GPS module (outdoor navigation)
Vision & Display
  • • ESP32-CAM (additional camera angles)
  • • OLED displays (status information)
  • • WS2812 LED strips (visual effects)
Environmental
  • • BME280 (temperature, humidity, pressure)
  • • Air quality sensors (gas detection)

CrazyFlie Python API Compatible

Use existing CrazyFlie Python scripts with FLYQ

Same API

Compatible with CrazyFlie Python library - no code changes needed

Autonomous Flight

Run waypoint navigation, formations, and advanced maneuvers

Large Community

Access thousands of example projects and tutorials

Programming Tutorials

Complete guides for Arduino, Python, and ESP-IDF development

Arduino IDE Tutorial

Perfect for beginners • Rapid prototyping • Extensive libraries

Setup & Installation

  1. 1
    Download Arduino IDE: Visit arduino.cc/downloads and download for your OS (Windows/Mac/Linux)
  2. 2
    Install ESP32 Board Support:
    • • Open Arduino IDE → File → Preferences
    • • Add board manager URL: https://espressif.github.io/arduino-esp32/package_esp32_index.json
    • • Tools → Board → Boards Manager → Search "ESP32" → Install
  3. 3
    Select Board: Tools → Board → ESP32 Arduino → ESP32S3 Dev Module
  4. 4
    Connect Drone: USB-C cable → Tools → Port → Select COM port (e.g., COM3, /dev/ttyUSB0)

Example 1: Blink LED

Simple program to blink the onboard LED. Perfect first test!

// FLYQ Air - Blink LED Example
#define LED_PIN 2  // Onboard LED on GPIO2

void setup() {
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(115200);
  Serial.println("FLYQ Air - LED Blink Test");
}

void loop() {
  digitalWrite(LED_PIN, HIGH);   // Turn LED on
  Serial.println("LED ON");
  delay(1000);                    // Wait 1 second
  
  digitalWrite(LED_PIN, LOW);    // Turn LED off
  Serial.println("LED OFF");
  delay(1000);                    // Wait 1 second
}

Upload: Click the Upload button (→) in Arduino IDE. LED should blink once upload completes!

Example 2: Read IMU Sensor

Read gyroscope and accelerometer data from MPU6050 IMU

// FLYQ Air - IMU Reader
#include 
#include 

MPU6050 mpu;

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);  // SDA=21, SCL=22
  
  Serial.println("Initializing IMU...");
  mpu.initialize();
  
  if (mpu.testConnection()) {
    Serial.println("MPU6050 connected!");
  } else {
    Serial.println("MPU6050 connection failed!");
  }
}

void loop() {
  // Read accelerometer (in g)
  int16_t ax, ay, az;
  mpu.getAcceleration(&ax, &ay, &az);
  
  // Read gyroscope (in degrees/sec)
  int16_t gx, gy, gz;
  mpu.getRotation(&gx, &gy, &gz);
  
  // Print values
  Serial.print("Accel: ");
  Serial.print(ax/16384.0); Serial.print("g, ");
  Serial.print(ay/16384.0); Serial.print("g, ");
  Serial.print(az/16384.0); Serial.println("g");
  
  Serial.print("Gyro: ");
  Serial.print(gx/131.0); Serial.print("°/s, ");
  Serial.print(gy/131.0); Serial.print("°/s, ");
  Serial.print(gz/131.0); Serial.println("°/s");
  
  delay(100);
}

Library Required: Install "MPU6050" library via Library Manager (Sketch → Include Library → Manage Libraries)

Example 3: Basic Motor Control

Control motor speed using PWM signals

// FLYQ Air - Motor Control
#define MOTOR1_PIN 25  // Front-left motor
#define MOTOR2_PIN 26  // Front-right motor  
#define MOTOR3_PIN 27  // Rear-left motor
#define MOTOR4_PIN 33  // Rear-right motor

// PWM settings
const int freq = 20000;      // 20 kHz
const int resolution = 8;     // 8-bit (0-255)

void setup() {
  Serial.begin(115200);
  
  // Configure PWM channels
  ledcSetup(0, freq, resolution);
  ledcSetup(1, freq, resolution);
  ledcSetup(2, freq, resolution);
  ledcSetup(3, freq, resolution);
  
  // Attach pins to channels
  ledcAttachPin(MOTOR1_PIN, 0);
  ledcAttachPin(MOTOR2_PIN, 1);
  ledcAttachPin(MOTOR3_PIN, 2);
  ledcAttachPin(MOTOR4_PIN, 3);
  
  Serial.println("Motor control ready!");
}

void setMotorSpeed(int motor, int speed) {
  // Speed: 0-255
  ledcWrite(motor, speed);
}

void loop() {
  // Gradual speed test
  for(int speed = 0; speed <= 255; speed += 5) {
    setMotorSpeed(0, speed);  // Motor 1
    setMotorSpeed(1, speed);  // Motor 2
    setMotorSpeed(2, speed);  // Motor 3
    setMotorSpeed(3, speed);  // Motor 4
    
    Serial.print("Speed: ");
    Serial.println(speed);
    delay(100);
  }
  
  // Stop motors
  for(int i = 0; i < 4; i++) {
    setMotorSpeed(i, 0);
  }
  
  delay(2000);
}

Safety Warning: Remove propellers before testing motors! Never test with propellers attached to bench.

Python SDK Tutorial

Autonomous flight • Advanced missions • Crazyflie-compatible

Setup & Installation

# Install Python 3.8+ (check version)
python --version

# Install cflib (Crazyflie library)
pip install cflib

# Install additional dependencies
pip install numpy matplotlib

# Verify installation
python -c "import cflib; print('cflib version:', cflib.__version__)"

Example 1: Connect to Drone

# connect_drone.py
import cflib.crtp
from cflib.crazyflie import Crazyflie
import time

# Initialize drivers
cflib.crtp.init_drivers()

# URI of the drone (radio://0/80/2M/E7E7E7E7E7)
URI = 'radio://0/80/2M'

def connected(link_uri):
    print(f'Connected to {link_uri}')

def disconnected(link_uri):
    print(f'Disconnected from {link_uri}')

def connection_failed(link_uri, msg):
    print(f'Connection failed: {msg}')

# Create Crazyflie object
cf = Crazyflie()

# Add callbacks
cf.connected.add_callback(connected)
cf.disconnected.add_callback(disconnected)
cf.connection_failed.add_callback(connection_failed)

print('Connecting to drone...')
cf.open_link(URI)

# Keep connection alive
time.sleep(5)

# Disconnect
cf.close_link()
print('Connection closed')

Example 2: Autonomous Flight

# autonomous_flight.py
import cflib.crtp
from cflib.crazyflie import Crazyflie
from cflib.crazyflie.syncCrazyflie import SyncCrazyflie
from cflib.positioning.motion_commander import MotionCommander
import time

cflib.crtp.init_drivers()
URI = 'radio://0/80/2M'

def simple_flight():
    with SyncCrazyflie(URI, cf=Crazyflie(rw_cache='./cache')) as scf:
        with MotionCommander(scf) as mc:
            print('Taking off...')
            time.sleep(1)
            
            print('Moving forward 0.5m')
            mc.forward(0.5)
            time.sleep(1)
            
            print('Moving left 0.5m')
            mc.left(0.5)
            time.sleep(1)
            
            print('Moving back 0.5m')
            mc.back(0.5)
            time.sleep(1)
            
            print('Moving right 0.5m')
            mc.right(0.5)
            time.sleep(1)
            
            print('Turning 360°')
            mc.turn_right(360)
            time.sleep(1)
            
            print('Landing...')
            # MotionCommander auto-lands on exit

if __name__ == '__main__':
    simple_flight()
    print('Flight complete!')

Run: python autonomous_flight.py

ESP-IDF Tutorial

Professional firmware • RTOS • Advanced features

Setup & Installation

# Linux/macOS
# Install prerequisites
sudo apt-get install git wget flex bison gperf python3 python3-pip \
  python3-setuptools cmake ninja-build ccache libffi-dev libssl-dev \
  dfu-util libusb-1.0-0

# Download ESP-IDF
mkdir -p ~/esp
cd ~/esp
git clone --recursive https://github.com/espressif/esp-idf.git

# Install tools
cd ~/esp/esp-idf
./install.sh esp32s3

# Setup environment (add to ~/.bashrc)
. $HOME/esp/esp-idf/export.sh

# Verify installation
idf.py --version

Example: FreeRTOS Task

// main.c - FreeRTOS Task Example
#include 
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#define LED_PIN GPIO_NUM_2

void blink_task(void *pvParameter) {
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
    
    while(1) {
        gpio_set_level(LED_PIN, 1);
        printf("LED ON\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
        
        gpio_set_level(LED_PIN, 0);
        printf("LED OFF\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void) {
    printf("FLYQ Air - FreeRTOS Example\n");
    xTaskCreate(&blink_task, "blink_task", 2048, NULL, 5, NULL);
}

Build & Flash: idf.py build flash monitor

Firmware Flashing Guide

Step-by-step guide to flash firmware on your FLYQ drone

Method 1: Arduino IDE (Easiest)

  1. 1
    Connect drone via USB-C

    Connect your FLYQ to computer. LED should turn on.

  2. 2
    Select board and port
    • • Tools → Board → ESP32S3 Dev Module
    • • Tools → Port → COM3 (or /dev/ttyUSB0)
  3. 3
    Open example sketch

    File → Examples → FLYQ → BasicFlight

  4. 4
    Click Upload (→)

    Wait for "Done uploading" message

Method 2: esptool (Advanced)

# Install esptool
pip install esptool

# Download firmware.bin from GitHub releases
wget https://github.com/passion3d/flyq-firmware/releases/latest/download/firmware.bin

# Flash firmware
esptool.py --chip esp32s3 --port /dev/ttyUSB0 write_flash 0x0 firmware.bin

# Verify
esptool.py --chip esp32s3 --port /dev/ttyUSB0 verify_flash 0x0 firmware.bin

Common Issues

  • Port not found: Install CH340/CP210x USB drivers
  • Failed to connect: Hold BOOT button while connecting USB
  • Timeout error: Try different USB cable or port
  • Permission denied: Run sudo usermod -a -G dialout $USER (Linux)

Flight Manual

Complete safety procedures and flight operations guide

Safety First!

❌ Never:

  • • Fly near people, animals, or buildings
  • • Fly outdoors in wind or rain
  • • Touch spinning propellers
  • • Fly with damaged propellers
  • • Leave battery charging unattended
  • • Fly with low battery warning

✅ Always:

  • • Inspect drone before flight
  • • Use propeller guards indoors
  • • Keep clear 3m safety zone
  • • Calibrate IMU before flying
  • • Have emergency stop ready
  • • Land with 20% battery remaining

Pre-Flight Checklist

Hardware Check

  • Battery fully charged
  • Propellers secure (correct direction)
  • Frame intact, no cracks
  • Motors spin freely
  • Propeller guards attached

Software Check

  • Wi-Fi connection stable
  • IMU calibrated
  • Control app responsive
  • Firmware up to date
  • Emergency stop tested

Environment Check

  • Indoor or calm weather
  • 3m clear radius
  • No obstacles overhead
  • Good lighting
  • No people/pets nearby

Flight Procedures

Takeoff

  1. 1. Place drone on flat surface
  2. 2. Power on drone, wait for solid LED
  3. 3. Connect controller/app
  4. 4. Arm motors (throttle down + yaw right)
  5. 5. Gradually increase throttle to hover

In-Flight

  • • Maintain visual line of sight
  • • Keep within 50m range
  • • Monitor battery level
  • • Smooth control inputs
  • • Stay below 3m altitude indoors

Landing

  1. 1. Position over landing zone
  2. 2. Gradually reduce throttle
  3. 3. Keep level during descent
  4. 4. Cut throttle when touching ground
  5. 5. Disarm motors immediately

Troubleshooting Guide

Solutions to common issues and problems

Hardware Issues

Drone won't power on

  • • Check battery charge level
  • • Verify battery connection
  • • Try different battery
  • • Check power switch

Motors not spinning

  • • Check propeller installation
  • • Verify motor connections
  • • Test with motor control code
  • • Check MOSFET drivers

Unstable flight/drifting

  • • Recalibrate IMU on flat surface
  • • Check propeller balance
  • • Verify motor speeds are equal
  • • Tune PID parameters

Battery not charging

  • • Try different USB cable
  • • Use 5V 1A charger
  • • Check charging LED
  • • Battery may be dead (< 3.0V)

Software Issues

Can't connect to Wi-Fi

  • • Wait 30s after power on
  • • Check SSID: FLYQ-XXXX
  • • Default password: flyq1234
  • • Reset Wi-Fi in firmware

Upload failed in Arduino

  • • Hold BOOT button during upload
  • • Select correct COM port
  • • Install CH340 USB drivers
  • • Reduce upload speed: 115200

IMU calibration fails

  • • Place on perfectly flat surface
  • • Keep absolutely still during cal
  • • No vibration or movement
  • • Retry 3 times if needed

Python script errors

  • • Check cflib version: pip install --upgrade cflib
  • • Verify URI format: radio://0/80/2M
  • • Check Crazyradio dongle connection
  • • Run as administrator (Windows)

Still Need Help?

Our technical support team is ready to assist you

API Reference

Complete function library documentation

Arduino API

FLYQ.init()

Initialize FLYQ drone system

Returns: bool - true if successful

FLYQ.init(); // Initialize all sensors and motors

FLYQ.calibrateIMU()

Calibrate IMU on flat surface

Returns: bool - true if successful

FLYQ.setMotorSpeed(motor, speed)

Set individual motor speed

Parameters: motor (0-3), speed (0-255)

FLYQ.setMotorSpeed(0, 150); // Motor 1 at 60% speed

FLYQ.setThrottle(value)

Set all motors to same speed

Parameters: value (0-255)

FLYQ.getIMU()

Get IMU sensor data

Returns: IMUData struct with gyro and accel

IMUData data = FLYQ.getIMU();
Serial.print("Gyro X: "); Serial.println(data.gyro.x);

Python API (cflib)

MotionCommander.take_off(height)

Take off to specified height

Parameters: height (meters, default 0.3)

mc.take_off(0.5) # Take off to 0.5m

MotionCommander.forward(distance)

Fly forward specified distance

Parameters: distance (meters)

MotionCommander.turn_right(angle)

Turn right by angle in degrees

Parameters: angle (degrees, 0-360)

mc.turn_right(90) # Turn 90° right

MotionCommander.land()

Land drone at current position

Returns: None

Project Ideas

Inspiration and examples for your drone projects

BEGINNER

LED Patterns

Create custom LED light shows synchronized with flight

Arduino • 1 hour

Basic Obstacle Avoidance

Use ToF sensor to detect and avoid obstacles

Arduino • 2 hours

Altitude Hold

Implement barometer-based altitude stabilization

Arduino • 3 hours

INTERMEDIATE

Waypoint Navigation

Program autonomous flight to GPS waypoints

Python • 1 day

Follow Me Mode

Track and follow a moving target automatically

Python • 2 days

Swarm Control

Coordinate multiple drones in formation flight

Python • 3 days

ADVANCED

SLAM Mapping

Build 3D maps using camera and sensors

ESP-IDF • 1 week

Computer Vision Landing

Precision landing on visual markers

Python + OpenCV • 1 week

AI Object Detection

Real-time object recognition and tracking

TensorFlow Lite • 2 weeks

Featured Project: Autonomous Room Mapper

Overview

Program your FLYQ to autonomously navigate a room, avoiding obstacles and creating a 2D floor plan map.

What You'll Learn

  • • Sensor fusion (ToF + IMU)
  • • Path planning algorithms
  • • Real-time mapping
  • • Data visualization

Requirements

  • • FLYQ Air + ToF sensor
  • • Python with matplotlib
  • • 3x3m clear space
  • • 2-3 hours

Community & Support

Join our growing community of makers, developers, and educators

Ready to Start Building?

Get your FLYQ drone and start learning today