- Altair Silent
Autonomous drone system for precision window navigation using LiDAR-based SLAM and computer vision
Altair Silent is a fully autonomous drone navigation system designed to detect, approach, and navigate through indoor window openings using LiDAR-based perception and advanced motion planning. The system combines real-time SLAM mapping, Nav2 path planning, PID-based altitude control, obstacle avoidance, and multi-stage window detection to enable safe autonomous flight in GPS-denied environments.
Built on ROS2 Humble, the project integrates Google Cartographer for mapping, ArduPilot for flight control, and custom perception algorithms for robust corner detection and window traversal. The entire software stack runs on a Raspberry Pi-based drone platform with a 360° LiDAR scanner and communicates with ArduPilot over MAVLink.
Technical Highlights:
- Real-time 2D SLAM with loop closure optimization
- Multi-phase window detection (horizontal + vertical scanning)
- Lifecycle-managed controller architecture with composable modules
- Sector-based obstacle avoidance with repulsive force fields
- Autonomous exploration with corner-based room navigation
- Nav2 integration with custom behavior trees and recovery actions
Altair Silent was developed by Team Altair for the Teknofest 2025 International UAV Competition, one of the world's largest aerospace and technology festivals held in Türkiye. The competition challenges teams to design fully autonomous drones capable of navigating complex indoor environments, including:
- Flying through narrow rectangular openings (windows)
- Mapping unknown spaces without GPS
- Avoiding dynamic and static obstacles
- Executing precise altitude and position control
- Completing autonomous exploration missions
Traditional drone navigation systems rely heavily on GPS, which becomes unavailable in indoor or GPS-denied environments. Detecting and safely traversing narrow openings like windows requires:
- Robust LiDAR-based perception to detect corners and edges in 3D space
- Real-time mapping to build navigable maps without prior knowledge
- Precision control to align with window openings within centimeter accuracy
- Intelligent planning to calculate safe approach trajectories and execute multi-stage maneuvers
Altair Silent addresses these challenges through:
- Corner detection algorithms that identify window boundaries using range discontinuities
- Vertical altitude scanning to measure window height dynamically
- PID-controlled altitude and lateral velocity for stable flight
- Integration with Nav2 for autonomous waypoint navigation
- Modular controller architecture enabling composable flight behaviors
- Robotics researchers developing autonomous indoor navigation systems
- Competition teams participating in UAV challenges requiring precision flight
- Drone developers building perception and control systems for GPS-denied environments
- ROS2 community seeking reference implementations of lifecycle-managed aerial systems
Altair Team Projects for Teknofest 2025:
- Altair Silent (this project) - Autonomous window navigation
- Altair GUI - Ground control station interface
- Google Cartographer SLAM with 2D LiDAR and IMU fusion
- Real-time occupancy grid generation at 5cm resolution
- Loop closure optimization with pose graph constraints
- 30m LiDAR range with 2.5cm voxel filtering
- Nav2 stack with A* global planner and DWB local controller
- Layered costmaps: static map, voxel layer, inflation layer
- Behavior tree-based navigation with recovery actions (spin, backup, wait)
- 0.25 m/s max velocity with acceleration limits for safe flight
- LiDAR corner detection identifying range discontinuities (>0.5m threshold)
- Multi-stage detection:
- Horizontal scan: detect left/right corners, calculate approach waypoints
- Vertical scan: measure window height by altitude sweeping
- Center alignment: position drone at optimal traversal altitude
- Waypoint generation perpendicular to window plane
- Autonomous exploration after window passage
- Lifecycle-managed controllers (altitude, Nav2, obstacle avoidance, window)
- PID-based altitude control with low-pass filtering
- Sector-based obstacle avoidance (4-quadrant detection)
- Velocity command fusion at 20Hz
- MAVROS integration for ArduPilot communication over MAVLink
- Hardware agnostic design with simulation support (Gazebo Harmonic)
- Serial/UDP MAVLink connection with auto-configuration
- Custom ROS2 messages and services for window operations
- Parameter-based runtime configuration
- RViz visualization for markers and costmaps
┌──────────────────────────────────────────────────────────────┐
│ Altair Silent Stack │
├──────────────────────────────────────────────────────────────┤
│ silent_bringup → System integration & launch files │
│ silent_controllers → Flight control (altitude, nav2, │
│ obstacle avoidance, window pass) │
│ silent_window_detector → Window detection & mission planner │
│ silent_explorer → Autonomous corner-based exploration│
│ silent_slam → Cartographer 2D SLAM integration │
│ silent_nav2 → Nav2 navigation stack config │
│ silent_msgs → Custom ROS2 message/service defs │
│ silent_utils → Geometry & state management utils │
│ silent_description → Robot URDF models & transforms │
├──────────────────────────────────────────────────────────────┤
│ External: MAVROS, Nav2, Cartographer, ArduPilot, Gazebo │
└──────────────────────────────────────────────────────────────┘
- Takeoff → Drone lifts to initial altitude (1.4m)
- Width Detection → LiDAR scans detect horizontal window corners
- Approach Outside → Navigate to waypoint facing window
- Height Scan → Sweep altitude up/down to measure window height
- Center Alignment → Move to optimal altitude for traversal
- Window Pass (Outbound) → Navigate through window opening
- Exploration → Autonomous corner detection and room mapping
- Return Pass (Inbound) → Navigate back through window
- Return to Launch → Return to starting position
- NixOS or Nix package manager (for reproducible development environment)
- NVIDIA GPU + drivers (for Gazebo simulation with GPU acceleration)
- Docker (optional, for containerized simulation)
nix develop . --accept-flake-configThis will automatically provision:
- ROS2 Humble
- Google Cartographer
- Nav2 navigation stack
- MAVROS + MAVROS Extras
- RPLIDAR/SLLIDAR ROS2 drivers
- Python 3.12 with NumPy
colcon buildsource install/local_setup.bashFlight Controller:
- ArduPilot-compatible board (Pixhawk, Cube, etc.)
- Firmware: ArduCopter 4.3+
Onboard Computer:
- Raspberry Pi 4/5 (8GB recommended)
- Ubuntu 22.04 or compatible OS
- Serial UART enabled (GPIO 14/15)
Sensors:
- 360° 2D LiDAR scanner (RPLIDAR A1/A2, YDLIDAR X2/X4, etc.)
- IMU (provided by flight controller)
xhost +SI:localuser:rootsudo docker build .docker/ardupilot-sim/. -t gazebo_rossudo docker run --rm -it \
--device nvidia.com/gpu=all \
-v /tmp/.X11-unix:/tmp/.X11-unix:rw \
-v $(pwd)/.gazebo:/root/buildings \
-e DISPLAY=$DISPLAY \
gazebo_rosThis launches Gazebo Harmonic with ArduPilot SITL and custom world models. When MAVProxy console bringup, run
setorigin 1 1 0
ros2 launch silent_bringup mavros.launch fcu_url:=tcp://172.17.0.2:5770@
ros2 param set /mavros/mavros use_sim_time trueYou may need change the IP address of the container
172.17.0.2
This starts:
- MAVROS connection to ArduPilot
- Configure /mavros/mavros node to use simulation time.
ros2 launch silent_nav2 nav2_tf.launch.py use_sim_time:=True use_rviz:=False
This starts:
- Robot Description Publisher
- Cartographer
- Navigation Stack 2
ros2 launch silent_bringup silent_system.launch.py use_sim_time:=TrueThis starts:
- Vehicle controllers (altitude, obstacle avoidance, Nav2, window)
- Vehicle state watcher (handles takeoff/landing)
- Window detector nodes (width, height, planner)
- Explorer node for autonomous exploration
Run commands below inside MAVProxy console:
mode GUIDED
arm throttle
ros2 launch silent_nav2 nav2.launch.py use_rviz:=True use_sim_time:=True # Includes RViz configNOTE: RViz tools is not included in flake.nix, you must install it manually
View:
- Real-time costmaps (local + global)
- SLAM-generated occupancy grid
- Planned paths and trajectories
- Window detection markers
- Obstacle avoidance zones
| File | Package | Purpose |
|---|---|---|
nav2_params.yaml |
silent_nav2 | Nav2 stack configuration (planner, controller, costmaps) |
drone_2d.lua |
silent_slam | Cartographer SLAM parameters |
apm_config.yaml |
silent_bringup | MAVROS/ArduPilot connection settings |
controller_params.yaml |
silent_controllers | PID gains, filter coefficients, timeouts |
window_detector_params.yaml |
silent_window_detector | Detection thresholds, safety margins |
Edit src/silent_controllers/config/controller_params.yaml:
vehicle_controller:
ros__parameters:
ac_initial_altitude: 1.45 # Initial target altitude (m)
ac_kp: 0.4 # Proportional gain
ac_ki: 0.065 # Integral gain
ac_kd: 0.0 # Derivative gain
ac_alpha: 0.55 # Low-pass filter coefficient
ac_output_min: -1.0 # Min vertical velocity (m/s)
ac_output_max: 1.0 # Max vertical velocity (m/s)Edit src/silent_window_detector/config/window_detector_params.yaml:
width_detector:
ros__parameters:
safety_corner_range: 0.5 # Min range change for corner (m)
safety_area: 1.0 # Min clearance for passage (m)
targets_length: 1.0 # Distance of waypoints from window (m)Enable UART on Raspberry Pi:
Edit /boot/firmware/config.txt:
enable_uart=1
dtoverlay=disable-btSet permissions:
sudo usermod -aG dialout $USER
sudo chmod 666 /dev/serial0MAVROS Connection:
Edit src/silent_bringup/params/apm_config.yaml:
fcu_url: /dev/serial0:57600 # Serial connection
# or
fcu_url: udp://:14550@ # UDP connection for simulationaltair-silent/
├── .docker/ # Docker simulation environment
│ └── ardupilot-sim/ # ArduPilot SITL + Gazebo Harmonic
├── .gazebo/ # Custom Gazebo world models (Ev, Ev2, EvReal)
├── src/
│ ├── silent_bringup/ # System launch files & MAVROS config
│ ├── silent_controllers/ # Flight control modules (5+ controllers)
│ ├── silent_description/ # URDF robot models
│ ├── silent_explorer/ # Autonomous exploration with corner detection
│ ├── silent_msgs/ # Custom ROS2 messages/services
│ ├── silent_nav2/ # Nav2 configuration & behavior trees
│ ├── silent_slam/ # Cartographer 2D SLAM integration
│ ├── silent_utils/ # Shared utilities (geometry, state factories)
│ └── silent_window_detector/ # Window detection pipeline (3 nodes)
├── flake.nix # Nix development environment
├── LICENSE # MIT License
└── README.md # This file
~5,850 lines of Python code across 8 packages (excluding tests).
Contributions are welcome!
- Fork the repository
- Create a feature branch:
git checkout -b feature/your-feature - Make changes following the code style guidelines in
AGENTS.md - Commit changes:
git commit -m "feat: add your feature" - Push to branch:
git push origin feature/your-feature - Open a Pull Request
This project is licensed under the MIT License - see the LICENSE file for details
Core Developers:
- VKWHM - Project lead, system architecture, control systems
- Wueenzy - LiDAR perception, corner detection algorithms, exploration logic
- ROS2 Community - For the Humble distribution and comprehensive documentation
- ArduPilot Team - For the robust open-source flight controller firmware
- Google Cartographer Team - For the excellent SLAM implementation
- Nav2 Contributors - For the flexible navigation stack
- Teknofest Organizers - For hosting the International UAV Competition and inspiring innovation
- Team Repositories:
- Altair Silent - Autonomous window navigation (this project)
- Altair GUI - ROS2 Ground control interface
- Competition: Teknofest 2025 - International UAV Competition
Built with ❤️ by Team Altair for Teknofest 2025