Struct tello_edu::Tello

pub struct Tello<S = NoWifi> { /* private fields */ }

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

impl Tello<NoWifi>

pub fn new() -> Self

Create a new drone in a completely unconnected state.

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

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

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

impl Tello<Disconnected>

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

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

Connect to the drone using the given options

• options Connection options

impl Tello<Connected>

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

Disconnect from the drone.

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

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

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

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

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

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

The unique drone serial number.

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

The Tello SDK version.

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

The drone battery level as a percentage.

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

The WiFi signal to noise ratio as a percentage.

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

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

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

Immediately stop all motors.

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

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

Take off and hover.

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

Land and stop motors.

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

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

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

Set the forward speed.

• speed Desired speed, 10-100 cm/s

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

Wait for the given length of time.

• duration The time to wait

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

Stop and hover in place.

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

Turn clockwise.

• degrees Angle in degrees 1-360°

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

Turn counter-clockwise.

• degrees Angle in degrees 1-360°

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

Move straight up.

• distance Distance to travel, 20-500 cm

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

Move straight down.

• distance Distance to travel, 20-500 cm

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

Move straight left.

• distance Distance to travel, 20-500 cm

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

Move straight right.

• distance Distance to travel, 20-500 cm

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

Move straight forwards.

• distance Distance to travel, 20-500 cm

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

Move straight backwards.

• distance Distance to travel, 20-500 cm

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

Flip left.

nb fails if battery is low

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

Flip right.

nb fails if battery is low

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

Flip forward.

nb fails if battery is low

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

Flip back.

nb fails if battery is low

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.

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

Stop video streaming.

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

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

Trait Implementations

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

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

Formats the value using the given formatter.