Struct tello_edu::TelloOptions

pub struct TelloOptions { /* private fields */ }

Tello drone connection and other usage options.

Implementations

impl TelloOptions

pub fn with_state(&mut self) -> TelloStateReceiver

Request state updates from the drone.

nb As messages are sent to the UDP broadcast address 0.0.0.0 this only works in AP mode, ie using the drone’s own WiFi network

Returns the receiver end of the channel used to pass on updates

Examples found in repository

examples/drone_state.rs (line 17)

async fn fly() -> Result<()> {
    let drone = Tello::new()
        .wait_for_wifi().await?;

    let mut options = TelloOptions::default();

    // we want state updates...
    let mut state_receiver = options.with_state();

    // ...so spawn task to receive them
    tokio::spawn(async move {
        loop {
            let state = state_receiver.recv().await.unwrap();
            println!("STATE {state:#?}");
        }
    });

    // connect using these options
    let drone = drone.connect_with(options).await?;

    // go!
    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}

pub fn with_video(&mut self) -> TelloVideoReceiver

Request video from the drone as a stream of h264-encoded 720p YUV frames.

nb As messages are sent to the UDP broadcast address 0.0.0.0 this only works in AP mode, ie using the drone’s own WiFi network

Returns the receiver end of the channel used to pass on frames

Examples found in repository

examples/receive_video.rs (line 11)

async fn main() {
    let mut options = TelloOptions::default();

    // we want video...
    let mut video_receiver = options.with_video();

    tokio::spawn(async move {
        loop {
            let frame = video_receiver.recv().await;
            println!("video frame: {frame:?}");
        }
    });

    fly(options).await.unwrap();

}

examples/show_video.rs (line 17)

fn main() {
    let mut options = TelloOptions::default();

    // we want video...
    let video_receiver = options.with_video();

    // run async Tokio runtime in a thread...
    std::thread::spawn(move || {
        let tokio_runtime = tokio::runtime::Builder::new_multi_thread()
            .enable_all()
            .build()
            .unwrap();

        tokio_runtime.block_on(async {
            fly(options).await.unwrap();
        });
    });

    // ...because SDL must run on the main thread
    run_gui(video_receiver).unwrap();
}

pub fn with_command(&mut self) -> TelloCommandSender

Returns the sender end of a channel for issuing commands to the drone, eg for a remote control application.

Examples found in repository

examples/remote_control.rs (line 33)

fn main() {
    let mut options = TelloOptions::default();

    // we want to send commands...
    let command_sender = options.with_command();

    // run async Tokio runtime in a thread...
    std::thread::spawn(move || {
        let tokio_runtime = tokio::runtime::Builder::new_multi_thread()
            .enable_all()
            .build()
            .unwrap();

        tokio_runtime.block_on(async {
            fly(options).await.unwrap();
        });
    });

    run_control(command_sender).expect("failed to run control");
}

Trait Implementations

impl Default for TelloOptions

fn default() -> TelloOptions

Returns the “default value” for a type.