Dora Quad Robotics

🔍 Overview

Dora Quad is a distributed quadrotor autonomy framework built on Dora, providing real-time dynamics simulation, trajectory planning, and control with modern visualization capabilities.

🎯 Key Features

• 🚁 Real-time Simulation

  • High-fidelity quadrotor dynamics with configurable parameters
  • IMU and depth sensor simulation with realistic noise models
  • Optional RK4 integration for accurate dynamics

• 🎮 Advanced Control

  • PID control for position and attitude with tunable gains
  • Integral windup prevention
  • Support for different control frequencies

• 📍 Rich Trajectory Planning

  • Basic: Hover, Minimum jerk line
  • Patterns: Lissajous curves, Circular paths
  • Navigation: Waypoint following, Landing sequences
  • Advanced: Obstacle avoidance, Minimum snap trajectories
  • Optimization: QP-based polynomial trajectory generation

• 📊 Visualization & Debug

  • Real-time 3D visualization via rerun.io
  • Depth map rendering with configurable color mapping
  • State telemetry logging
  • Configurable logging frequencies

• ⚡ Performance

  • Memory-safe Rust implementation
  • Multi-threaded depth rendering
  • Efficient matrix operations via nalgebra

🏗️ Architecture

Dora Quad uses a distributed architecture powered by the Dora robotics framework, where each component runs as a separate node communicating via message passing:

nodes/
├── dora-quad-sim/       # Physics simulation node
├── dora-quad-control/   # PID controller node
├── dora-quad-planner/   # Trajectory planning node (self-contained)
├── dora-quad-camera/    # Depth camera sensor node
└── dora-quad-maze/      # Environment/obstacles node

dataflow/
└── quad_sim_full.yml    # Dora dataflow configuration

Each node runs as a separate process and communicates via message passing, enabling:

• Distributed computing across multiple machines
• Hot-reloading of individual components
• Language-agnostic node implementation
• Better fault isolation

🚀 Getting Started

Prerequisites

• Rust
• Dora installed
• rerun-cli

Installation from Source

cargo install rerun-cli
git clone https://github.com/VertexStudio/dora_quad.git
cd dora_quad

Building

Build all nodes in release mode:

cargo build --release --workspace

Running the Simulation

1. Start dora coordinator and daemon (if not already running):

dora up

2. Run the simulation:

dora run dataflow/quad_sim_full.yml

The Rerun viewer should open automatically showing the 3D visualization.

📡 Node Communication

Nodes communicate using standardized entity paths and metadata:

Entity Paths

• /world/quad/base_link - Quadrotor pose
• /world/quad/trajectory - Planned trajectory
• /world/quad/desired_position - Current target position
• /world/quad/cam - Camera pose
• /world/quad/cam/depth - Depth image
• /world/maze/obstacles - Dynamic obstacles
• /world/quad/telemetry/* - Telemetry data

Metadata Format

All visualization data includes a primitive field:

• points3d - 3D point clouds
• lines3d - 3D line strips
• boxes3d - 3D bounding boxes
• depth - Depth images
• series - Time series data

📊 Telemetry

The system publishes comprehensive telemetry under /world/quad/telemetry/:

• Position: position/x, position/y, position/z
• Velocity: velocity/x, velocity/y, velocity/z
• Acceleration: acceleration/x, acceleration/y, acceleration/z
• Orientation: orientation/x, orientation/y, orientation/z, orientation/w
• Angular Velocity: angular_velocity/x, angular_velocity/y, angular_velocity/z
• Control: control/thrust, control/torque/x, control/torque/y, control/torque/z
• Desired: desired_position/*, desired_velocity/*

🎮 Planners

The planner node supports all trajectory types:

Basic Planners

• Hover - Maintain position
• MinimumJerkLine - Smooth line trajectories

Trajectory Planners

• Circle - Circular paths
• Lissajous - Lissajous curves
• Landing - Automated landing

Advanced Planners

• ObstacleAvoidance - Potential field navigation
• MinimumSnapWaypoint - Multi-waypoint trajectories
• QPpolyTraj - QP-optimized polynomial trajectories

⚙️ Configuration

Dora Quad uses YAML configuration files to set simulation parameters. See config/quad.yaml for a complete example.

simulation:
  simulation_frequency: 1000  # Hz
  control_frequency: 100      # Hz
  duration: 20.0              # seconds
  
quadrotor:
  mass: 1.3                   # kg
  gravity: 9.81               # m/s²
  drag_coefficient: 0.01
  
pid_controller:
  pos_gains:
    kp: [7.0, 7.0, 10.0]      # Proportional gains
    kd: [4.0, 4.0, 6.0]       # Derivative gains
    ki: [0.0, 0.0, 0.0]       # Integral gains
    
planner_schedule:
  - step: 0
    planner_type: MinimumJerkLine
    params:
      start_position: [0.0, 0.0, 1.0]
      end_position: [2.0, 0.0, 1.0]
      duration: 3.0

🔧 Development

Building Individual Nodes

cd nodes/dora-quad-sim
cargo build --release

Adding New Nodes

1. Create a new node directory under nodes/
2. Define inputs/outputs in dataflow/quad_sim_full.yml
3. Use standardized entity paths and metadata
4. Follow the established message passing conventions

📝 Notes

• All nodes use Float32Array for visualization data (Float64Array for physics)
• Entity paths must be absolute (start with /world/)
• The planner node is self-contained with its own planner implementations
• Camera frustum visualization is automatic when depth metadata includes camera parameters

📄 License

• MIT License (LICENSE-MIT

📚 Citation

Based on Peng:

@software{peng_quad,
  author       = {Yang Zhou},
  title        = {Peng: A Minimal Quadrotor Autonomy Framework in Rust},
  year         = {2024},
  publisher    = {GitHub},
  journal      = {GitHub repository},
  howpublished = {\url{https://github.com/makeecat/peng}},
}