基于AirSim的仿真代码能否直接部署到真实无人机？技术咨询

Short answer: No, you can’t directly reuse your AirSim simulation code for real drones—but a lot of your core logic can be adapted with some targeted changes. Let’s break this down and walk through what you need to do to get your code running on hardware for Game of Drones.

Why Direct Reuse Isn’t Possible #

• Hardware API Mismatch: AirSim uses its own simulated hardware layer (like MultirotorApi) that talks to virtual sensors and motors. Real drones rely on vendor-specific flight stacks (PX4, ArduPilot) or SDKs (DJI OSDK, Parrot SDK) with entirely different ways to send commands, read sensor data, and manage flight modes. Your AirSim calls won’t translate directly to these systems.
• Real-World Sensor Imperfections: Simulation gives you clean, low-latency sensor data (perfect GPS, drift-free IMU). Real sensors have noise, drift, and variable latency—your simulation code likely doesn’t handle these edge cases.
• Safety Requirements: AirSim lets you push drones to limits without risk, but real drones need critical fail-safes (low-battery return, signal-loss hover) that aren’t part of standard simulation code.

How to Adapt Your Simulation Code for Real Drones #

1. Extract Reusable Core Logic #

First, pull out the parts that don’t depend on AirSim’s APIs—these are your biggest wins:

• Path planning or trajectory generation code (e.g., waypoint following, race gate navigation logic)
• Computer vision processing (e.g., gate detection, pose estimation from camera feeds)
• Control algorithms (e.g., PID controllers for altitude, attitude, or velocity)
  These are pure logic components; you just need to feed them real sensor data instead of AirSim’s simulated output.

2. Replace AirSim Calls with Real Drone SDK/Flight Stack Code #

You’ll need to swap out AirSim-specific functions with equivalents from your drone’s SDK or flight stack. For example:

• Instead of airsim.MultirotorClient().moveByVelocityAsync(vx, vy, vz, duration), use PX4’s set_position_target_local_ned() or DJI OSDK’s flightController->setVelocity().
• Instead of airsim.MultirotorClient().getImuData(), read IMU data from your flight controller’s telemetry stream.

3. Add Real-World Robustness #

Your simulation code doesn’t need this, but real drones do:

• Sensor Filtering: Implement Kalman filters or complementary filters to clean up noisy IMU/GPS data.
• Fail-Safe Handlers: Add code to trigger emergency landings, return-to-home, or hover if sensors fail, battery drops below a threshold, or signal is lost.
• Pre-Flight Checks: Include calibration verification (IMU, compass) and hardware health checks before allowing the drone to take off.

4. Test Incrementally #

Don’t jump straight to full race tasks—build up gradually:

• Start with basic hover and position control to validate your SDK integration.
• Use a hardware-in-the-loop (HITL) simulator (like Gazebo with PX4) to test your adapted code in a realistic virtual environment before deploying to physical hardware.
• Test with a tethered drone first to avoid crashes while you work out kinks.

Quick Example: Adapting a Velocity Control Loop #

Here’s how you might convert a simple AirSim velocity command to work with a PX4 drone using MAVSDK:

AirSim Simulation Code:

import airsim

client = airsim.MultirotorClient()
client.confirmConnection()
client.moveByVelocityAsync(1.0, 0.0, 0.0, 2.0).join()

Adapted Real Drone Code:

from mavsdk import System
import asyncio

async def send_velocity(drone, vx, vy, vz):
    await drone.offboard.set_velocity_ned(vx, vy, vz, 0.0)

async def main():
    drone = System()
    await drone.connect(system_address="udp://:14540")
    
    # Wait for drone to connect and arm
    async for state in drone.core.connection_state():
        if state.is_connected:
            print("Drone connected")
            await drone.action.arm()
            await drone.offboard.start()
            break
    
    # Send velocity command
    await send_velocity(drone, 1.0, 0.0, 0.0)
    await asyncio.sleep(2.0)
    
    await drone.action.disarm()

if __name__ == "__main__":
    asyncio.run(main())

内容的提问来源于stack exchange，提问作者Nitish Jha