智能机器人在医疗领域的应用

    from dronekit import connect, VehicleMode, LocationGlobalRelative, Command
    import time
    
    # Connect to the vehicle
    vehicle = connect('udp:192.168.10.2:14550', wait_ready=True)
    
    def arm_and_takeoff(aTargetAltitude):
    """
    Arms vehicle and fly to aTargetAltitude.
    """
    
    print("Basic pre-arm checks")
    # Don't try to arm until autopilot is ready
    while not vehicle.is_armable:
        print(" Waiting for vehicle to initialise...")
        time.sleep(1)
    
    print("Arming motors")
    # Copter should arm in GUIDED mode
    vehicle.mode = VehicleMode("GUIDED")
    vehicle.armed = True
    
    # Confirm vehicle armed before attempting to take off
    while not vehicle.armed:
        print(" Waiting for arming...")
        time.sleep(1)
    
    print("Taking off!")
    vehicle.simple_takeoff(aTargetAltitude)  # Take off to target altitude
    
    # Wait until the vehicle reaches a safe height before processing the goto (otherwise the command 
    #  after Vehicle.simple_takeoff will execute immediately).
    while True:
        print(" Altitude: ", vehicle.location.global_relative_frame.alt)
        if vehicle.location.global_relative_frame.alt >= aTargetAltitude * 0.95:  # Trigger just below target alt.
            print("Reached target altitude")
            break
        time.sleep(1)
    
    
    # Arm and take of to altitude of 5 meters
    arm_and_takeoff(5)
    
    # Send a sequence of commands to control the drone
    commands = vehicle.commands
    cmds = vehicle.message_factory.command_long_encode(
    0, 0,    # target system, target component
    mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,       # frame
    0,       # confirmation
    1, 0.0, 0.0,   # param 1 ~ 3 - latitude, longitude, altitude (in decimal degrees)
    10.0, 0.0, 0.0,  # param 4 ~ 7 - x, y, z velocity in m/s
    0.0, 0.0, 0.0,  # param 8 ~ 10 - x, y, z acceleration (not used)
    1,          # param 11 - heading offset (0.0 means no change)
    0.0         # param 12 - yaw angle (0.0 means no change)
    )
    # Add new command to list
    commands.add(Command(0, 0, 0, cmds))
    # Upload new command list to vehicle
    vehicle.send_mavlink(commands)
    
    # Close vehicle object before exiting script
    print("Close vehicle object")
    vehicle.close()

    pip install pyserial pymavlink dronekit

    conda create --name myenv python=3.8 pip
    conda activate myenv
    conda install -c conda-forge dronekit

    #include <iostream>
    #include <chrono> // std::chrono library for sleep function
    #include "mavsdk/mavsdk.h"
    
    using namespace mavsdk;
    using namespace std::chrono; // for sleep duration objects
    
    // Variables for setting up connection with MAVSDK
    const uint8_t sys_id = 1;
    const uint8_t comp_id = 1;
    std::string connection_url{"udp://:14540"};
    
    int main()
    {
    const double default_altitude = 5.0f; // in meters
    
    Mavsdk mavsdk;
    ConnectionResult conn_result = mavsdk.add_any_connection(connection_url);
    
    // If connection fails, terminate program
    if (conn_result!= ConnectionResult::Success) {
        std::cout << "Connection failed:" << conn_result << "
    ";
        return 1;
    }
    
    System &system = mavsdk.systems().at(0);
    auto action = Action(system);
    auto mission = Mission(system);
    
    std::cout << "Waiting for system to be ready...
    ";
    bool is_ready = false;
    for (int i = 0;!is_ready && i < 10; ++i) {
        const auto result = system.is_connected();
        if (result) {
            is_ready = true;
            std::cout << "System is ready!
    ";
        } else {
            std::cout << "." << std::flush;
            std::this_thread::sleep_for(seconds(1));
        }
    }
    
    // Check that all systems are ready
    while (!system.has_autopilot()) {
        std::cout << "Waiting for system to have an autopilot...
    ";
        std::this_thread::sleep_for(seconds(1));
    }
    
    // Set up the callback for state changes
    StateCallback callback = [](const State& state) {
        if (state.flight_mode == FlightMode::Ready) {
            std::cout << "Armed
    ";
        }
    };
    system.register_state_callback(callback);
    
    // Print some basic information about the autopilot
    Autopilot autopilot = system.get_autopilot();
    std::cout << "Autopilot: " << AutopilotInfo{autopilot}.str() << '
    ';
    VersionInfo version = system.get_version_info();
    std::cout << "Version: " << version.to_string() << '
    ';
    
    // Try to arm the drone
    std::cout << "Attempting to arm the drone...
    ";
    while (!action.arm()) {
        std::cout << "Failed to arm. Trying again..." << std::endl;
        std::this_thread::sleep_for(seconds(1));
    }
    std::cout << "Disarming.
    ";
    action.disarm();
    
    // Set initial setpoint
    PositionNed position{};
    position.north_m = 0.0f; // relative north position in metres
    position.east_m = 0.0f;  // relative east position in metres
    position.down_m = default_altitude;  // absolute altitude in metres
    
    // Send waypoint as first command to the drone
    std::cout << "Sending set-position command...
    ";
    mission.upload_mission_async({MissionItem{0.0f, nullptr, 0, position, 25}});
    bool sent_first_waypoint = false;
    do {
        std::this_thread::sleep_for(milliseconds(100));
        const auto current_mission_items = mission.get_mission_progress().current;
        if (current_mission_items > 0) {
            sent_first_waypoint = true;
            std::cout << "First waypoint sent." << std::endl;
        }
    } while (!sent_first_waypoint);
    
    // Wait until the waypoint has been reached
    while (true) {
        std::this_thread::sleep_for(milliseconds(100));
        const auto progress = mission.get_mission_progress();
    
        if (progress.current == progress.total) {
            std::cout << "All waypoints reached." << std::endl;
            break;
        }
    
        const auto last_mission_item = progress.mission_items[progress.current];
        std::cout << "Mission item "
                  << progress.current + 1
                  << "/" << progress.total
                  << ": "
                  << Position{last_mission_item.latitude_deg,
                               last_mission_item.longitude_deg}
                  << std::endl;
    }
    
    // Disarm the drone when done
    std::cout << "Landing the drone...
    ";
    while (!action.land()) {
        std::cout << ".
    ";
        std::this_thread::sleep_for(milliseconds(100));
    }
    std::cout << "Landed!" << std::endl;
    
    // Give some time to observe landing behavior on ground station side
    std::this_thread::sleep_for(seconds(5));
    
    // Shut down the connection with the drone
    mavsdk.shutdown();
    
    return 0;
    }