Using Olympe asynchronously

In the basic examples above we’ve always performed actions synchronously because we were always immediately waiting for an action to complete with the .wait() method.

In this example, we will send some flying commands to the drone asynchronously. While the drone executes those commands, we will start a video recording and change the gimbal velocity target along the pitch axis. After sending those camera-related commands, we will call the .wait() method on the “flying action” and then stop the recording.

Create the following python asyncaction.py script somewhere in your home directory:

import os
import olympe
from olympe.messages.ardrone3.Piloting import TakeOff, moveBy, Landing
from olympe.messages.ardrone3.PilotingState import FlyingStateChanged
from olympe.messages.camera import start_recording, stop_recording
from olympe.messages import gimbal

DRONE_IP = os.environ.get("DRONE_IP", "10.202.0.1")


def test_asyncaction():
    with olympe.Drone(DRONE_IP) as drone:
        drone.connect()

        # Start a flying action asynchronously
        flyingAction = drone(
            TakeOff()
            >> FlyingStateChanged(state="hovering", _timeout=5)
            >> moveBy(10, 0, 0, 0)
            >> FlyingStateChanged(state="hovering", _timeout=5)
            >> Landing()
        )

        # Start video recording while the drone is flying
        if not drone(start_recording(cam_id=0)).wait().success():
            assert False, "Cannot start video recording"

        # Send a gimbal pitch velocity target while the drone is flying
        cameraAction = drone(gimbal.set_target(
            gimbal_id=0,
            control_mode="velocity",
            yaw_frame_of_reference="none",
            yaw=0.0,
            pitch_frame_of_reference="none",
            pitch=0.1,
            roll_frame_of_reference="none",
            roll=0.0,
        )).wait()

        if not cameraAction.success():
            assert False, "Cannot set gimbal velocity target"

        # Wait for the end of the flying action
        if not flyingAction.wait().success():
            assert False, "Cannot complete the flying action"

        # Stop video recording while the drone is flying
        if not drone(stop_recording(cam_id=0)).wait().success():
            assert False, "Cannot stop video recording"

        # Leaving the with statement scope: implicit drone.disconnect() but that
        # is still a good idea to perform the drone disconnection explicitly
        drone.disconnect()


if __name__ == "__main__":
    test_asyncaction()

Reset the simulation (sphinx-cli action -m world fwman world_reset_all in a terminal) and execute this script, from the same shell/terminal you have source’d the shell script:

In this example, the olympe.Drone.__call__() functor process commands and events asynchronously so that multiple commands can be sent to the drone and processed concurrently. The events associated to asynchronous actions are interleaved in an undefined order. The following sequence diagram illustrates a possible sequence of event for this script.

Asynchronous command examples