AeroFlux UAV Simulator

AeroFlux UAV Simulator is a self-adaptive drone management system implementing the U-space framework for autonomous UAV operations in complex urban environments. This research artifact demonstrates key principles of self-adaptive systems through a MAPE-K (Monitor, Analyze, Plan, Execute, Knowledge) cycle that enables drones to dynamically adapt to changing environmental conditions, weather patterns, and regulatory constraints.

Artifact Overview

This artifact provides a complete implementation of a self-adaptive UAV management system that showcases:

• Real-time Adaptation: Dynamic response to changing weather conditions, air traffic, and geo-zone restrictions
• Microservices Architecture: Distributed system demonstrating scalability and fault tolerance in self-adaptive systems
• Autonomous Decision Making: Implementation of collaborative strategies for traffic management and safety

Key Self-Adaptive Features

• MAPE-K Control Loop: Continuous monitoring and adaptation to environmental changes
• Distributed Adaptation: Decentralized decision-making across multiple drone agents
• Context-Aware Navigation: Real-time adaptation to geo-zones, weather, and traffic conditions
• Dynamic Authorization: Automated rule-based adaptation to regulatory requirements
• Collaborative Behaviors: Multi-agent coordination for optimal system performance

System Architecture

The system implements a microservices architecture that demonstrates key self-adaptive system principles:

Core Services

• Geo-Awareness: Service for managing geo-zones and spatial restrictions
• Geo-Authorization: Service for managing geo-zone authorization
• Drone-Identification: Service for drone registration and identity management
• Weather: Service for managing weather conditions
• Simulator: Service for multi-agent simulation with autonomous adaptation logic
• UI: Service for real-time monitoring and control interface

Infrastructure Components

• ActiveMQ: Event-driven communication beetween microservices
• MongoDB: Persistent storage for geo-spatial and drone data
• PostgreSQL: Authorization and regulatory data management
• Nginx: Load balancing and service discovery

Project Structure

AeroFlux/
├── docker-compose.yml          # Service orchestration
├── nginx.template.conf         # Reverse proxy configuration
├── drone-identification/       # Drone identification service
├── geo-authorization/          # Authorization service
├── geo-awareness/              # Geo-zone management service
├── weather/                    # Weather service
├── simulator/                  # UAV simulator
├── ui/                         # React web interface
└── documentation/              # Documentation

Technologies Used

• Backend: Spring Boot, Java 17
• Frontend: React, Vite, JavaScript
• Database: MongoDB, PostgreSQL
• Message Broker: ActiveMQ
• Containerization: Docker, Docker Compose
• Web Server: Nginx

Getting Started

The artifact demonstrates key self-adaptive system principles through real-time drone management scenarios.

Key Elements for Evaluation

The artifact enables evaluation of the following self-adaptive system capabilities:

1. Real-time Adaptation: Monitor how drones adapt flight paths based on changing weather conditions and geo-zone restrictions
2. MAPE-K Implementation: Observe the Monitor-Analyze-Plan-Execute cycle in action through the web interface
3. Multi-agent Coordination: Evaluate collaborative decision-making between multiple drones in shared airspace
4. Dynamic Authorization: Test how the drone adapts to authorization changes

System Requirements

Software Requirements:

• Docker Desktop 4.0+ (Download)
• Docker Compose 2.0+ (included with Docker Desktop)
• Web browser (Chrome, Firefox, Safari, or Edge)

Port Requirements: The system requires the following ports to be available:

• Port 80: Main web interface
• Port 5000: Simulator API
• Ports 8080-8085: Microservices APIs
• Port 8161: ActiveMQ management console
• Ports 27017, 5432: Database connections (internal)

Expected System Behavior

When successfully running, the artifact will:

• Start 11 containerized services automatically
• Provide a web-based dashboard for real-time monitoring
• Generate continuous telemetry data from simulated drones
• Demonstrate adaptive behaviors through visual feedback
• Log all system events for post-execution analysis

Potential Side Effects and Considerations

Resource Usage:

• High CPU usage during simulation execution (expected behavior)

Known Limitations:

• Simulation performance depends on available system resources
• Some adaptation scenarios may take 30-60 seconds to fully manifest

Step-by-Step Installation and Execution

This section provides comprehensive instructions for downloading, installing, running, and evaluating the AeroFlux artifact.

Step 1: Download and Setup

1. Download the Artifact

   git clone https://github.com/alegil0206/U-space.git
   cd U-space

2. Verify Docker Installation

   docker --version
   docker-compose --version

   Expected output: Docker version 20.10+ and Docker Compose version 2.0+

3. Configure System Hosts (Required)

   For Windows (Run as Administrator):

   Add-Content -Path "C:\Windows\System32\drivers\etc\hosts" -Value "127.0.0.1   aeroflux"
   Add-Content -Path "C:\Windows\System32\drivers\etc\hosts" -Value "127.0.0.1   simulator.aeroflux"
   Add-Content -Path "C:\Windows\System32\drivers\etc\hosts" -Value "127.0.0.1   uspace.aeroflux"

   For Linux/Mac:

   echo "127.0.0.1   aeroflux" | sudo tee -a /etc/hosts
   echo "127.0.0.1   simulator.aeroflux" | sudo tee -a /etc/hosts
   echo "127.0.0.1   uspace.aeroflux" | sudo tee -a /etc/hosts

Step 2: Launch the System

1. Start All Services

   docker-compose up -d

   Expected behavior: Docker will download images (first time) and start 11 containers

2. Monitor Startup Progress

   docker-compose logs -f

   Wait for all services to show "Started" or "Ready" messages (typically 2-3 minutes)

3. Verify Service Health

   docker-compose ps

   All services should show "running" status

Step 3: Access and Validate the System

1. Access Main Interface

   • Open browser to: http://aeroflux
   • Expected: Dashboard loads with navigation menu and system status

2. Verify Core Services

   • Geo-Awareness: http://uspace.aeroflux/geo-awareness/
   • Geo-Authorization: http://uspace.aeroflux/geo-authorization/
   • Drone-Identification: http://uspace.aeroflux/drone-identification/
   • Weather: http://uspace.aeroflux/weather/
   • Simulator: http://simulator.aeroflux/

Step 4: Execute Evaluation Scenarios

Navigate to http://aeroflux. Follow these scenarios to evaluate the self-adaptive system capabilities:

Scenario 1: Basic System Operation

1. Go to "Drone Section" in the navigation menu
2. Create a new drone using the interface
3. Observe drone registration in real-time

Scenario 2: Geo-Zone Adaptation

1. Go to "GeoZone Section"
2. Create a circular or polygonal restricted zone
3. Navigate to "Drone Section" and create a flight plan that intersects the zone
4. Observe how the system adapts the flight path automatically
5. Monitor adaptation decisions in the dashboard

Scenario 3: Weather-Based Adaptation

1. Access "Weather Section"
2. Modify weather conditions (wind speed and direction, minimum and maximum cluster numbers, maximum cluster size)
3. Observe how the weather change impacts drone operations

Scenario 4: Multi-Agent Coordination

1. Create multiple drones with overlapping flight paths
2. Start simultaneous missions
3. Monitor the "Home Section" for conflict resolution
4. Observe collaborative path planning in action

Step 5: Verify Execution Results

Real-time Monitoring:

1. Dashboard shows live system status and active adaptations
2. Each section provides real-time updates of system state
3. Event history displays all adaptation decisions with timestamps

Step 6: System Shutdown

# Graceful shutdown
docker-compose down

# Remove all data (optional - for clean restart)
docker-compose down -v

Expected Outputs and Generated Files

This section describes the files and outputs generated by executing the AeroFlux artifact.

Runtime Log Files

The system generates comprehensive logs that capture all self-adaptive behaviors. Logs are available in the "Home Section" of the web interface and can be accessed directly from the service containers.

Dashboard Screenshots and Monitoring Data

The web interface generates visual evidence of system operation:

Available Screenshots:

• documentation/screenshots/homeSection.png - Main dashboard overview
• documentation/screenshots/droneSection.png - Drone management interface
• documentation/screenshots/geoZoneSection.png - Geo-zone configuration
• documentation/screenshots/weatherSection.png - Weather monitoring
• documentation/screenshots/authorizationSection.png - Authorization system
• documentation/screenshots/historySection.png - Simulation history

Test Data

Sample Input Data:

• documentation/data/DroneData.csv - Drone configurations
• documentation/data/GeoZoneData.csv - Geo-zone definitions

License

This project is licensed under the Apache License 2.0 – see the LICENSE file for details.