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/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/move.rs (line 11)
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 11)
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();
    println!("disconnected, drone is now: {drone:?}");

    Ok(())
}
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/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/move.rs (line 12)
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 14)
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();
    println!("disconnected, drone is now: {drone:?}");

    Ok(())
}
source§

impl Tello<Disconnected>

source

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

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/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();
    println!("disconnected, drone is now: {drone:?}");

    Ok(())
}
source§

impl Tello<Connected>

source

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

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();
    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_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 query_battery(&self) -> Result<u8>

Queries the drone battery level as a percentage.

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/move.rs (line 16)
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 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/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(())
}
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(())
}
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: i16) -> 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: i16) -> 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: i16) -> 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: i16) -> 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: i16) -> 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(())
}
source

pub async fn move_back(&self, distance: i16) -> 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(())
}

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,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

const: unstable · source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

const: unstable · 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.
const: unstable · 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.
const: unstable · source§

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

Performs the conversion.