RDC_Simulation/docs/drone_guide.md

DroneController Guide

Implement your GPS-denied landing algorithm in drone_controller.py.

Quick Start

1. Edit drone_controller.py
2. Find calculate_landing_maneuver()
3. Implement your algorithm
4. Test: python standalone_simulation.py

Sensors Available

Sensor	Description
IMU	Orientation, angular velocity
Altimeter	Altitude, vertical velocity
Velocity	Estimated velocity (x, y, z)
Camera	320x240 downward image
Landing Pad	Relative position (may be null!)

Function to Implement

def calculate_landing_maneuver(self, telemetry, rover_telemetry):
    # Your code here
    return (thrust, pitch, roll, yaw)

Sensor Data

# Altitude
altitude = telemetry['altimeter']['altitude']
vertical_vel = telemetry['altimeter']['vertical_velocity']

# Velocity
vel_x = telemetry['velocity']['x']
vel_y = telemetry['velocity']['y']

# Landing Pad (may be None!)
landing_pad = telemetry.get('landing_pad')
if landing_pad:
    relative_x = landing_pad['relative_x']
    relative_y = landing_pad['relative_y']

Control Output

Value	Range	Effect
thrust	±1.0	Up/down
pitch	±0.5	Forward/back
roll	±0.5	Left/right
yaw	±0.5	Rotation

Example Algorithm

def calculate_landing_maneuver(self, telemetry, rover_telemetry):
    altimeter = telemetry.get('altimeter', {})
    altitude = altimeter.get('altitude', 5.0)
    vertical_vel = altimeter.get('vertical_velocity', 0.0)
    
    velocity = telemetry.get('velocity', {})
    vel_x = velocity.get('x', 0.0)
    vel_y = velocity.get('y', 0.0)
    
    landing_pad = telemetry.get('landing_pad')
    
    # Altitude control
    thrust = 0.5 * (0 - altitude) - 0.3 * vertical_vel
    
    # Horizontal control
    if landing_pad:
        pitch = 0.3 * landing_pad['relative_x'] - 0.2 * vel_x
        roll = 0.3 * landing_pad['relative_y'] - 0.2 * vel_y
    else:
        pitch = -0.2 * vel_x
        roll = -0.2 * vel_y
    
    return (thrust, pitch, roll, 0.0)

Using the Camera

import cv2
import numpy as np
import base64

camera = telemetry.get('camera', {})
image_b64 = camera.get('image')

if image_b64:
    image_bytes = base64.b64decode(image_b64)
    nparr = np.frombuffer(image_bytes, np.uint8)
    image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
    # Process image...

Testing

# Easy - stationary
python standalone_simulation.py --pattern stationary

# Medium - circular
python standalone_simulation.py --pattern circular --speed 0.3

# Hard - random
python standalone_simulation.py --pattern random --speed 0.5

Configuration

Edit config.py:

CONTROLLER = {
    "Kp_z": 0.5,    # Altitude proportional
    "Kd_z": 0.3,    # Altitude derivative
    "Kp_xy": 0.3,   # Horizontal proportional
    "Kd_xy": 0.2,   # Horizontal derivative
}