Struct tello_edu::Tello

source · 
pub struct Tello<S = NoWifi> { /* private fields */ }
Expand description

For interacting with the Tello EDU drone using the simple text-based UDP protocol.

The basic flow from the user’s point of view is

SEND command → drone does something → RECEIVE response when it’s finished

Messages are plain ASCII text, eg command forward 10 → response ok

use tello_edu::{Tello, Result};
 
#[tokio::main]
async fn main() {
    fly().await.unwrap();
}
 
async fn fly() -> Result<()> {
    // create a new drone in the `NoWifi` state     
    let drone = Tello::new();

    // wait until the host computer joins the drone's WiFi network
    // (joining the network is not automatic - how it happens is up to you)
    let drone = drone.wait_for_wifi().await?;
 
    // establish connection and put the drone in "command" mode
    let drone = drone.connect().await?;
 
    // fly!
    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;
 
    Ok(())
}

Implementations§

source§

impl Tello<NoWifi>

source

pub fn new() -> Self

Create a new drone in a completely unconnected state.

Examples found in repository?
examples/take_off_and_land.rs (line 11)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/remote_control.rs (line 216)
215
216
217
218
219
220
221
222
223
224

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

    let drone = drone.connect_with(options).await?;

    drone.handle_commands().await?;

    Ok(())
}
examples/clockwise_360.rs (line 11)
10
11
12
13
14
15
16
17
18
19
20
21

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/emergency_stop.rs (line 11)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.emergency_stop().await?; // warning! this will make the drone drop like a brick

    Ok(())
}
examples/receive_video.rs (line 26)
25
26
27
28
29
30
31
32
33
34
35
36
37

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
examples/show_video.rs (line 112)
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
Additional examples can be found in:
source

pub async fn wait_for_wifi(&self) -> Result<Tello<Disconnected>>

Wait until the host joins the drone’s WiFi network

nb exactly how the the network is joined is up to you

Examples found in repository?
examples/take_off_and_land.rs (line 12)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/remote_control.rs (line 217)
215
216
217
218
219
220
221
222
223
224

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

    let drone = drone.connect_with(options).await?;

    drone.handle_commands().await?;

    Ok(())
}
examples/clockwise_360.rs (line 12)
10
11
12
13
14
15
16
17
18
19
20
21

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/emergency_stop.rs (line 12)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.emergency_stop().await?; // warning! this will make the drone drop like a brick

    Ok(())
}
examples/receive_video.rs (line 27)
25
26
27
28
29
30
31
32
33
34
35
36
37

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
examples/show_video.rs (line 113)
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
Additional examples can be found in:
source

pub async fn assume_wifi(&self) -> Result<Tello<Disconnected>>

Use this if you are already in the appropriate WiFi network.

source§

impl Tello<Disconnected>

source

pub async fn connect(&self) -> Result<Tello<Connected>>

Connect to the drone using the default options, ie

  • using the drone’s own WiFi
  • drone address 192.168.10.1
  • no state updates
  • no video
Examples found in repository?
examples/take_off_and_land.rs (line 14)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/clockwise_360.rs (line 14)
10
11
12
13
14
15
16
17
18
19
20
21

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/emergency_stop.rs (line 14)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.emergency_stop().await?; // warning! this will make the drone drop like a brick

    Ok(())
}
examples/flip.rs (line 14)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    drone.flip_left().await?;
    drone.flip_right().await?;

    drone.flip_forward().await?;
    drone.flip_back().await?;
    
    drone.land().await?;

    Ok(())
}
examples/move.rs (line 14)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
examples/wifi_wait_for_connection.rs (line 17)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

async fn wifi_wait_for_connection() -> Result<()>{
    let drone = Tello::new();
    println!("Created drone: {drone:?}");

    let drone = drone.wait_for_wifi().await?;
    println!("WiFi available, drone is now: {drone:?}");

    let drone = drone.connect().await?;
    println!("connected, drone is now: {drone:?}");

    let drone = drone.disconnect().await?;
    println!("disconnected, drone is now: {drone:?}");

    Ok(())
}
Additional examples can be found in:
source

pub async fn connect_with( &self, options: TelloOptions ) -> Result<Tello<Connected>>

Connect to the drone using the given options

  • options Connection options
Examples found in repository?
examples/remote_control.rs (line 219)
215
216
217
218
219
220
221
222
223
224

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

    let drone = drone.connect_with(options).await?;

    drone.handle_commands().await?;

    Ok(())
}
More examples
Hide additional examples
examples/receive_video.rs (line 29)
25
26
27
28
29
30
31
32
33
34
35
36
37

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
examples/show_video.rs (line 115)
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/drone_state.rs (line 28)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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(())
}
source§

impl Tello<Connected>

source

pub async fn disconnect(&self) -> Result<Tello<Disconnected>>

Disconnect from the drone.

Examples found in repository?
examples/wifi_wait_for_connection.rs (line 20)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

async fn wifi_wait_for_connection() -> Result<()>{
    let drone = Tello::new();
    println!("Created drone: {drone:?}");

    let drone = drone.wait_for_wifi().await?;
    println!("WiFi available, drone is now: {drone:?}");

    let drone = drone.connect().await?;
    println!("connected, drone is now: {drone:?}");

    let drone = drone.disconnect().await?;
    println!("disconnected, drone is now: {drone:?}");

    Ok(())
}
source

pub async fn send(&self, command: &str) -> Result<String>

Sends a command to the drone using the simple Tello UDP protocol, returning the reponse.

The basic flow from the user’s point of view is

SEND command → drone does something → RECEIVE response when it’s finished

Messages are plain ASCII text, eg command forward 10 → response ok

  • command the command to send, must be a valid Tello SDK command string
source

pub async fn send_expect_ok(&self, command: &str) -> Result<()>

Sends a command, resolving to an error if the response is not “ok”

  • command the command to send, must be a valid Tello SDK command string
source

pub async fn send_value_expect_ok<T: Display>( &self, command: &str, value: T ) -> Result<()>

Sends a command with a single value, resolving to an error if the response is not “ok”

  • command the command to send, must be a valid Tello SDK command string
  • value the value to append to the command
source

pub async fn send_expect_nothing(&self, command: &str) -> Result<()>

Sends a command, expecting no response at all from the drone.

  • command the command to send, must be a valid Tello SDK command string
source

pub async fn send_expect<T: FromStr>(&self, command: &str) -> Result<T>

Sends a command, expecting a response that can be parsed as type T from the drone.

  • command the command to send, must be a valid Tello SDK command string
source

pub async fn serial_number(&self) -> Result<String>

The unique drone serial number.

source

pub async fn sdk_version(&self) -> Result<String>

The Tello SDK version.

source

pub async fn battery(&self) -> Result<u8>

The drone battery level as a percentage.

source

pub async fn wifi_signal_to_noise_ratio(&self) -> Result<u8>

The WiFi signal to noise ratio as a percentage.

source

pub async fn flight_time(&self) -> Result<u16>

The flight time in seconds, requested directly from the drone.

source

pub async fn emergency_stop(&self) -> Result<()>

Immediately stop all motors.

warning! this will make the drone drop like a brick!

Examples found in repository?
examples/emergency_stop.rs (line 17)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.emergency_stop().await?; // warning! this will make the drone drop like a brick

    Ok(())
}
source

pub async fn take_off(&self) -> Result<()>

Take off and hover.

Examples found in repository?
examples/take_off_and_land.rs (line 16)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/clockwise_360.rs (line 16)
10
11
12
13
14
15
16
17
18
19
20
21

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/emergency_stop.rs (line 16)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.emergency_stop().await?; // warning! this will make the drone drop like a brick

    Ok(())
}
examples/receive_video.rs (line 33)
25
26
27
28
29
30
31
32
33
34
35
36
37

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
examples/show_video.rs (line 119)
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/flip.rs (line 16)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    drone.flip_left().await?;
    drone.flip_right().await?;

    drone.flip_forward().await?;
    drone.flip_back().await?;
    
    drone.land().await?;

    Ok(())
}
Additional examples can be found in:
source

pub async fn land(&self) -> Result<()>

Land and stop motors.

Examples found in repository?
examples/take_off_and_land.rs (line 17)
10
11
12
13
14
15
16
17
18
19
20

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/clockwise_360.rs (line 18)
10
11
12
13
14
15
16
17
18
19
20
21

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/receive_video.rs (line 34)
25
26
27
28
29
30
31
32
33
34
35
36
37

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
examples/show_video.rs (line 121)
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/flip.rs (line 24)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    drone.flip_left().await?;
    drone.flip_right().await?;

    drone.flip_forward().await?;
    drone.flip_back().await?;
    
    drone.land().await?;

    Ok(())
}
examples/move.rs (line 23)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
Additional examples can be found in:
source

pub async fn speed(&self) -> Result<f32>

The drone speed in cm/s, requested directly from the drone.

source

pub async fn set_speed(&self, speed: u8) -> Result<()>

Set the forward speed.

  • speed Desired speed, 10-100 cm/s
Examples found in repository?
examples/speed.rs (line 19)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    // go away slowly
    drone.set_speed(25).await?;
    drone.move_forward(300).await?;

    drone.turn_clockwise(180).await?;

    // come back fast
    drone.set_speed(100).await?;
    drone.move_forward(300).await?;

    drone.turn_clockwise(180).await?;

    drone.land().await?;

    Ok(())
}
source

pub async fn wait(&self, duration: Duration) -> Result<()>

Wait for the given length of time.

  • duration The time to wait
source

pub async fn stop(&self) -> Result<()>

Stop and hover in place.

source

pub async fn turn_clockwise(&self, degrees: u16) -> Result<()>

Turn clockwise.

  • degrees Angle in degrees 1-360°
Examples found in repository?
examples/clockwise_360.rs (line 17)
10
11
12
13
14
15
16
17
18
19
20
21

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/show_video.rs (line 120)
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
examples/speed.rs (line 22)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    // go away slowly
    drone.set_speed(25).await?;
    drone.move_forward(300).await?;

    drone.turn_clockwise(180).await?;

    // come back fast
    drone.set_speed(100).await?;
    drone.move_forward(300).await?;

    drone.turn_clockwise(180).await?;

    drone.land().await?;

    Ok(())
}
examples/drone_state.rs (line 32)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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(())
}
source

pub async fn turn_counterclockwise(&self, degrees: u16) -> Result<()>

Turn counter-clockwise.

  • degrees Angle in degrees 1-360°
source

pub async fn move_up(&self, distance: u16) -> Result<()>

Move straight up.

  • distance Distance to travel, 20-500 cm
Examples found in repository?
examples/move.rs (line 17)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
source

pub async fn move_down(&self, distance: u16) -> Result<()>

Move straight down.

  • distance Distance to travel, 20-500 cm
Examples found in repository?
examples/move.rs (line 18)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
source

pub async fn move_left(&self, distance: u16) -> Result<()>

Move straight left.

  • distance Distance to travel, 20-500 cm
Examples found in repository?
examples/move.rs (line 19)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
source

pub async fn move_right(&self, distance: u16) -> Result<()>

Move straight right.

  • distance Distance to travel, 20-500 cm
Examples found in repository?
examples/move.rs (line 20)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
source

pub async fn move_forward(&self, distance: u16) -> Result<()>

Move straight forwards.

  • distance Distance to travel, 20-500 cm
Examples found in repository?
examples/move.rs (line 21)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/speed.rs (line 20)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    // go away slowly
    drone.set_speed(25).await?;
    drone.move_forward(300).await?;

    drone.turn_clockwise(180).await?;

    // come back fast
    drone.set_speed(100).await?;
    drone.move_forward(300).await?;

    drone.turn_clockwise(180).await?;

    drone.land().await?;

    Ok(())
}
source

pub async fn move_back(&self, distance: u16) -> Result<()>

Move straight backwards.

  • distance Distance to travel, 20-500 cm
Examples found in repository?
examples/move.rs (line 22)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

    let drone = drone.connect().await?;

    drone.take_off().await?;
    drone.move_up(50).await?;
    drone.move_down(50).await?;
    drone.move_left(50).await?;
    drone.move_right(50).await?;
    drone.move_forward(50).await?;
    drone.move_back(50).await?;
    drone.land().await?;

    Ok(())
}
source

pub async fn flip_left(&self) -> Result<()>

Flip left.

nb fails if battery is low

Examples found in repository?
examples/flip.rs (line 18)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    drone.flip_left().await?;
    drone.flip_right().await?;

    drone.flip_forward().await?;
    drone.flip_back().await?;
    
    drone.land().await?;

    Ok(())
}
source

pub async fn flip_right(&self) -> Result<()>

Flip right.

nb fails if battery is low

Examples found in repository?
examples/flip.rs (line 19)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    drone.flip_left().await?;
    drone.flip_right().await?;

    drone.flip_forward().await?;
    drone.flip_back().await?;
    
    drone.land().await?;

    Ok(())
}
source

pub async fn flip_forward(&self) -> Result<()>

Flip forward.

nb fails if battery is low

Examples found in repository?
examples/flip.rs (line 21)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    drone.flip_left().await?;
    drone.flip_right().await?;

    drone.flip_forward().await?;
    drone.flip_back().await?;
    
    drone.land().await?;

    Ok(())
}
source

pub async fn flip_back(&self) -> Result<()>

Flip back.

nb fails if battery is low

Examples found in repository?
examples/flip.rs (line 22)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

    let drone = drone.connect().await?;

    drone.take_off().await?;

    drone.flip_left().await?;
    drone.flip_right().await?;

    drone.flip_forward().await?;
    drone.flip_back().await?;
    
    drone.land().await?;

    Ok(())
}
source

pub async fn start_video(&self) -> Result<()>

Start video as stream of h264-encoded frames.

Use TelloOption::with_video() to set up a channel for receiving the video frames.

nb You must consume the frame data! The channel is unlimited and will eventually use up all available memory if you don’t.

Examples found in repository?
examples/receive_video.rs (line 31)
25
26
27
28
29
30
31
32
33
34
35
36
37

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.land().await?;

    Ok(())
}
More examples
Hide additional examples
examples/show_video.rs (line 117)
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

    let drone = drone.connect_with(options).await?;

    drone.start_video().await?;

    drone.take_off().await?;
    drone.turn_clockwise(360).await?;
    drone.land().await?;

    Ok(())
}
source

pub async fn stop_video(&self) -> Result<()>

Stop video streaming.

source

pub async fn remote_control( &self, left_right: i8, forwards_backwards: i8, up_down: i8, yaw: i8 ) -> Result<()>

Remote control’

All arguments are -100 to 100 (not sure what units)

  • left_right Movement sideways
  • forwards_backwards Forwards/backwards
  • up_down Vertical movement
  • yaw Turn left or right
source

pub async fn handle_commands(&self) -> Result<()>

Examples found in repository?
examples/remote_control.rs (line 221)
215
216
217
218
219
220
221
222
223
224

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

    let drone = drone.connect_with(options).await?;

    drone.handle_commands().await?;

    Ok(())
}

Trait Implementations§

source§

impl<S: Debug> Debug for Tello<S>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<S> RefUnwindSafe for Tello<S>where S: RefUnwindSafe,

§

impl<S> Send for Tello<S>where S: Send,

§

impl<S> Sync for Tello<S>where S: Sync,

§

impl<S> Unpin for Tello<S>where S: Unpin,

§

impl<S> UnwindSafe for Tello<S>where S: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.