e_drone_sp

Struct Drone

Source 
pub struct Drone {
    pub time_start: Instant,
    pub time_transfer: Instant,
    pub time_receive: Instant,
    pub receiver: Receiver,
    pub buffer: [u8; 1024],
    pub port: Result<Box<dyn SerialPort>>,
    pub flag_show_debug_message: bool,
}

Fields§

§time_start: Instant§time_transfer: Instant§time_receive: Instant§receiver: Receiver§buffer: [u8; 1024]§port: Result<Box<dyn SerialPort>>§flag_show_debug_message: bool

Implementations§

Source§

impl Drone

Source

pub fn new(port_name: &str) -> Drone

Examples found in repository?
examples/request_controller.rs (line 9)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/button.rs (line 9)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/joystick.rs (line 9)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/uwb.rs (line 8)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM4");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyUSB0");      // linux

    if drone.is_connected() == false {
        println!("Device is NOT Connected!");
        return;
    }

    //drone.set_show_debug_message(true);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 3600 {
            break;
        }
    }
}
examples/request_drone.rs (line 9)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        println!("Is not connected!");
        return;
    }

    //drone.request(DeviceType::Controller, DataType::Information);
    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
examples/vibrator.rs (line 9)
8
9
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
37
38
39
40
41
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    println!("#1");
    drone.vibrator(200, 200, 2000);
    drone.sleep(2500);

    println!("#2");
    drone.vibrator(100, 200, 2000);
    drone.sleep(2500);

    println!("#3");
    drone.vibrator(200, 100, 2000);
    drone.sleep(2500);

    println!("#4");
    drone.vibrator(100, 100, 2000);
    drone.sleep(2500);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
Additional examples can be found in:
Source

pub fn set_show_debug_message(&mut self, flag_show_debug_message: bool)

Source

pub fn is_connected(&mut self) -> bool

Examples found in repository?
examples/request_controller.rs (line 12)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/button.rs (line 12)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/joystick.rs (line 12)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/uwb.rs (line 11)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM4");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyUSB0");      // linux

    if drone.is_connected() == false {
        println!("Device is NOT Connected!");
        return;
    }

    //drone.set_show_debug_message(true);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 3600 {
            break;
        }
    }
}
examples/request_drone.rs (line 12)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        println!("Is not connected!");
        return;
    }

    //drone.request(DeviceType::Controller, DataType::Information);
    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
examples/vibrator.rs (line 12)
8
9
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
37
38
39
40
41
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    println!("#1");
    drone.vibrator(200, 200, 2000);
    drone.sleep(2500);

    println!("#2");
    drone.vibrator(100, 200, 2000);
    drone.sleep(2500);

    println!("#3");
    drone.vibrator(200, 100, 2000);
    drone.sleep(2500);

    println!("#4");
    drone.vibrator(100, 100, 2000);
    drone.sleep(2500);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
Additional examples can be found in:
Source

pub fn check(&mut self) -> Data

Examples found in repository?
examples/request_controller.rs (line 19)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/button.rs (line 20)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/joystick.rs (line 20)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/uwb.rs (line 19)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM4");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyUSB0");      // linux

    if drone.is_connected() == false {
        println!("Device is NOT Connected!");
        return;
    }

    //drone.set_show_debug_message(true);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 3600 {
            break;
        }
    }
}
examples/request_drone.rs (line 21)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        println!("Is not connected!");
        return;
    }

    //drone.request(DeviceType::Controller, DataType::Information);
    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
examples/vibrator.rs (line 35)
8
9
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
37
38
39
40
41
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    println!("#1");
    drone.vibrator(200, 200, 2000);
    drone.sleep(2500);

    println!("#2");
    drone.vibrator(100, 200, 2000);
    drone.sleep(2500);

    println!("#3");
    drone.vibrator(200, 100, 2000);
    drone.sleep(2500);

    println!("#4");
    drone.vibrator(100, 100, 2000);
    drone.sleep(2500);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
Additional examples can be found in:
Source

pub fn get_time_passed_from_start(&self) -> u128

Examples found in repository?
examples/display.rs (line 48)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn get_time_passed_from_last_transfer(&self) -> u128

Examples found in repository?
examples/request_controller.rs (line 21)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/button.rs (line 22)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/joystick.rs (line 22)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/uwb.rs (line 21)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM4");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyUSB0");      // linux

    if drone.is_connected() == false {
        println!("Device is NOT Connected!");
        return;
    }

    //drone.set_show_debug_message(true);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 3600 {
            break;
        }
    }
}
examples/request_drone.rs (line 23)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        println!("Is not connected!");
        return;
    }

    //drone.request(DeviceType::Controller, DataType::Information);
    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
examples/vibrator.rs (line 37)
8
9
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
37
38
39
40
41
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    println!("#1");
    drone.vibrator(200, 200, 2000);
    drone.sleep(2500);

    println!("#2");
    drone.vibrator(100, 200, 2000);
    drone.sleep(2500);

    println!("#3");
    drone.vibrator(200, 100, 2000);
    drone.sleep(2500);

    println!("#4");
    drone.vibrator(100, 100, 2000);
    drone.sleep(2500);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
Additional examples can be found in:
Source

pub fn get_time_passed_from_last_receive(&self) -> u128

Source

pub fn sleep(&self, time_sleep_ms: u64)

Examples found in repository?
examples/vibrator.rs (line 20)
8
9
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
37
38
39
40
41
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    println!("#1");
    drone.vibrator(200, 200, 2000);
    drone.sleep(2500);

    println!("#2");
    drone.vibrator(100, 200, 2000);
    drone.sleep(2500);

    println!("#3");
    drone.vibrator(200, 100, 2000);
    drone.sleep(2500);

    println!("#4");
    drone.vibrator(100, 100, 2000);
    drone.sleep(2500);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/flight.rs (line 29)
8
9
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
37
38
39
40
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux
    //let mut drone: Drone = Drone::new("/dev/serial0");      // raspberry pi uart

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }

    println!("Takeoff");
    drone.takeoff();
    drone.sleep(4000);

    println!("Go Forward");
    drone.control_position(2.0, 0.0, 0.0, 1.0, 0, 0);
    drone.sleep(5000);

    println!("Landing");
    drone.landing();
    drone.sleep(4000);

    println!("Bye");
}
examples/light.rs (line 49)
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
fn show(drone: &mut Drone, title: String, sub_title: String, time_wait_sec: i32)
{
    drone.sleep(10);
    drone.draw_clear_all(Pixel::White);

    drone.sleep(10);
    drone.draw_string_align(0, 128, 32 - 4 - 8 - 4, Align::Center, Font::LM5x8, Pixel::Black, title);

    drone.sleep(10);
    drone.draw_string_align(0, 128, 32 - 4, Align::Center, Font::LM5x8, Pixel::Black, sub_title);

    if time_wait_sec == 0 {
        return;
    }

    drone.sleep(10);
    let mut time_remain = time_wait_sec;
    loop 
    {
        drone.draw_string_align(0, 128, 32 + 4 + 4, Align::Center, Font::LM5x8, Pixel::Black, format!("  {}  ", time_remain));
        drone.sleep(1000);

        time_remain = time_remain - 1;

        if time_remain <= 0 {
            break;
        }
    }
}
examples/display.rs (line 18)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
examples/buzzer.rs (line 17)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.buzzer_hz(DeviceType::Controller, 1200, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(2000);
    
    drone.buzzer_hz(DeviceType::Controller, 1000, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1200, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(2000);
}
examples/test_buzzer.rs (line 19)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    //*
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 3000);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::CS4, 3000);
    drone.sleep(1200);
    drone.buzzer_stop(DeviceType::Controller);
    drone.sleep(3200);
    // */

    /*
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::CS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::DS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::FS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::GS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::AS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 3000);
    drone.sleep(3200);
    // */
    
    /*
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 3000);
    drone.sleep(3200);
    
    drone.buzzer_hz_reserve(DeviceType::Controller, 2000, 3000);
    drone.sleep(3200);
    // */
    
    /*
    drone.buzzer_hz_reserve(DeviceType::Drone, 1000, 3000);
    drone.sleep(3200);
    
    drone.buzzer_hz_reserve(DeviceType::Drone, 2000, 3000);
    drone.sleep(3200);
    // */
}
Source

pub fn send(&mut self, slice_data: &[u8]) -> bool

Source

pub fn request(&mut self, target: DeviceType, data_type: DataType) -> bool

Examples found in repository?
examples/request_controller.rs (line 16)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/button.rs (line 16)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/joystick.rs (line 16)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.request(DeviceType::Controller, DataType::Information);
    
    loop
    {
        handler(&drone.check());
        
        if drone.get_time_passed_from_last_transfer() > 10000 {
            break;
        }
    }
}
examples/request_drone.rs (line 18)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        println!("Is not connected!");
        return;
    }

    //drone.request(DeviceType::Controller, DataType::Information);
    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
examples/vibrator.rs (line 16)
8
9
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
37
38
39
40
41
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    println!("#1");
    drone.vibrator(200, 200, 2000);
    drone.sleep(2500);

    println!("#2");
    drone.vibrator(100, 200, 2000);
    drone.sleep(2500);

    println!("#3");
    drone.vibrator(200, 100, 2000);
    drone.sleep(2500);

    println!("#4");
    drone.vibrator(100, 100, 2000);
    drone.sleep(2500);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
examples/flight.rs (line 17)
8
9
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
37
38
39
40
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux
    //let mut drone: Drone = Drone::new("/dev/serial0");      // raspberry pi uart

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }

    println!("Takeoff");
    drone.takeoff();
    drone.sleep(4000);

    println!("Go Forward");
    drone.control_position(2.0, 0.0, 0.0, 1.0, 0, 0);
    drone.sleep(5000);

    println!("Landing");
    drone.landing();
    drone.sleep(4000);

    println!("Bye");
}
Source

pub fn command( &mut self, target: DeviceType, command_type: CommandType, option: u8, ) -> bool

Source

pub fn flight_event(&mut self, event: FlightEvent) -> bool

Source

pub fn takeoff(&mut self) -> bool

Examples found in repository?
examples/flight.rs (line 28)
8
9
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
37
38
39
40
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux
    //let mut drone: Drone = Drone::new("/dev/serial0");      // raspberry pi uart

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }

    println!("Takeoff");
    drone.takeoff();
    drone.sleep(4000);

    println!("Go Forward");
    drone.control_position(2.0, 0.0, 0.0, 1.0, 0, 0);
    drone.sleep(5000);

    println!("Landing");
    drone.landing();
    drone.sleep(4000);

    println!("Bye");
}
Source

pub fn landing(&mut self) -> bool

Examples found in repository?
examples/flight.rs (line 36)
8
9
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
37
38
39
40
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux
    //let mut drone: Drone = Drone::new("/dev/serial0");      // raspberry pi uart

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }

    println!("Takeoff");
    drone.takeoff();
    drone.sleep(4000);

    println!("Go Forward");
    drone.control_position(2.0, 0.0, 0.0, 1.0, 0, 0);
    drone.sleep(5000);

    println!("Landing");
    drone.landing();
    drone.sleep(4000);

    println!("Bye");
}
Source

pub fn stop(&mut self) -> bool

Source

pub fn set_default(&mut self) -> bool

Source

pub fn set_mode_control_flight(&mut self) -> bool

Source

pub fn headless(&mut self, headless: Headless) -> bool

Source

pub fn clear_bias(&mut self) -> bool

Source

pub fn clear_trim(&mut self) -> bool

Source

pub fn trim(&mut self, roll: i16, pitch: i16, yaw: i16, throttle: i16) -> bool

Source

pub fn control(&mut self, roll: i8, pitch: i8, yaw: i8, throttle: i8) -> bool

Source

pub fn control_request( &mut self, roll: i8, pitch: i8, yaw: i8, throttle: i8, data_type: DataType, ) -> bool

Source

pub fn control_position( &mut self, x: f32, y: f32, z: f32, velocity: f32, heading: i16, rotational_velocity: i16, ) -> bool

Examples found in repository?
examples/flight.rs (line 32)
8
9
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
37
38
39
40
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux
    //let mut drone: Drone = Drone::new("/dev/serial0");      // raspberry pi uart

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Drone, DataType::Information);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }

    println!("Takeoff");
    drone.takeoff();
    drone.sleep(4000);

    println!("Go Forward");
    drone.control_position(2.0, 0.0, 0.0, 1.0, 0, 0);
    drone.sleep(5000);

    println!("Landing");
    drone.landing();
    drone.sleep(4000);

    println!("Bye");
}
Source

pub fn battle_ir_message(&mut self, ir_message: u8) -> bool

Source

pub fn battle_light_event_command( &mut self, target: DeviceType, event: u8, interval: u16, repeat: u8, r: u8, g: u8, b: u8, command_type: CommandType, option: u8, ) -> bool

Source

pub fn battle_ir_message_light_event_command( &mut self, target: DeviceType, ir_message: u8, event: u8, interval: u16, repeat: u8, r: u8, g: u8, b: u8, command_type: CommandType, option: u8, ) -> bool

Source

pub fn light_manual( &mut self, target: DeviceType, flags: u16, brightness: u8, ) -> bool

Source

pub fn light_mode( &mut self, target: DeviceType, mode: u8, interval: u16, ) -> bool

Source

pub fn light_event( &mut self, target: DeviceType, event: u8, interval: u16, repeat: u8, ) -> bool

Source

pub fn light_mode_color( &mut self, target: DeviceType, mode: u8, interval: u16, r: u8, g: u8, b: u8, ) -> bool

Examples found in repository?
examples/light.rs (line 17)
9
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
37
38
39
40
41
42
43
44
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyFlicker.into(), 200, 240, 240, 20);
    show(&mut drone, String::from("BODY FLICKER"), String::from("YELLOW"), 5);

    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyFlicker.into(), 200, 20, 240, 240);
    show(&mut drone, String::from("BODY FLICKER"), String::from("CYAN"), 5);

    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyFlicker.into(), 200, 240, 20, 240);
    show(&mut drone, String::from("BODY FLICKER"), String::from("MAGENTA"), 5);


    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyDimming.into(), 2, 240, 240, 20);
    show(&mut drone, String::from("BODY DIMMING"), String::from("YELLOW"), 5);

    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyDimming.into(), 2, 20, 240, 240);
    show(&mut drone, String::from("BODY DIMMING"), String::from("CYAN"), 5);

    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyDimming.into(), 2, 240, 20, 240);
    show(&mut drone, String::from("BODY DIMMING"), String::from("MAGENTA"), 5);


    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyRainbow.into(), 3, 0, 0, 0);
    show(&mut drone, String::from("BODY RAINBOW"), String::from(""), 12);

    drone.light_mode_color(DeviceType::Controller, light::ModeLight::BodyRainbow2.into(), 3, 0, 0, 0);
    show(&mut drone, String::from("BODY RAINBOW 2"), String::from(""), 12);

    show(&mut drone, String::from(""), String::from("BYE"), 0);
}
Source

pub fn light_event_color( &mut self, target: DeviceType, event: u8, interval: u16, repeat: u8, r: u8, g: u8, b: u8, ) -> bool

Source

pub fn light_default( &mut self, target: DeviceType, mode: u8, interval: u16, r: u8, g: u8, b: u8, ) -> bool

Source

pub fn buzzer_stop(&mut self, target: DeviceType) -> bool

Examples found in repository?
examples/test_buzzer.rs (line 20)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    //*
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 3000);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::CS4, 3000);
    drone.sleep(1200);
    drone.buzzer_stop(DeviceType::Controller);
    drone.sleep(3200);
    // */

    /*
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::CS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::DS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::FS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::GS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::AS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 3000);
    drone.sleep(3200);
    // */
    
    /*
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 3000);
    drone.sleep(3200);
    
    drone.buzzer_hz_reserve(DeviceType::Controller, 2000, 3000);
    drone.sleep(3200);
    // */
    
    /*
    drone.buzzer_hz_reserve(DeviceType::Drone, 1000, 3000);
    drone.sleep(3200);
    
    drone.buzzer_hz_reserve(DeviceType::Drone, 2000, 3000);
    drone.sleep(3200);
    // */
}
Source

pub fn buzzer_scale( &mut self, target: DeviceType, scale: Scale, time: u16, ) -> bool

Examples found in repository?
examples/buzzer.rs (line 21)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.buzzer_hz(DeviceType::Controller, 1200, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(2000);
    
    drone.buzzer_hz(DeviceType::Controller, 1000, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1200, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(2000);
}
Source

pub fn buzzer_scale_reserve( &mut self, target: DeviceType, scale: Scale, time: u16, ) -> bool

Examples found in repository?
examples/buzzer.rs (line 23)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.buzzer_hz(DeviceType::Controller, 1200, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(2000);
    
    drone.buzzer_hz(DeviceType::Controller, 1000, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1200, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(2000);
}
More examples
Hide additional examples
examples/test_buzzer.rs (line 17)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    //*
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 3000);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::CS4, 3000);
    drone.sleep(1200);
    drone.buzzer_stop(DeviceType::Controller);
    drone.sleep(3200);
    // */

    /*
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::CS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::DS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::FS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::GS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::AS4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 3000);
    drone.sleep(3200);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 3000);
    drone.sleep(3200);
    // */
    
    /*
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 3000);
    drone.sleep(3200);
    
    drone.buzzer_hz_reserve(DeviceType::Controller, 2000, 3000);
    drone.sleep(3200);
    // */
    
    /*
    drone.buzzer_hz_reserve(DeviceType::Drone, 1000, 3000);
    drone.sleep(3200);
    
    drone.buzzer_hz_reserve(DeviceType::Drone, 2000, 3000);
    drone.sleep(3200);
    // */
}
Source

pub fn buzzer_hz(&mut self, target: DeviceType, hz: u16, time: u16) -> bool

Examples found in repository?
examples/buzzer.rs (line 16)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.buzzer_hz(DeviceType::Controller, 1200, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(2000);
    
    drone.buzzer_hz(DeviceType::Controller, 1000, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1200, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(2000);
}
Source

pub fn buzzer_hz_reserve( &mut self, target: DeviceType, hz: u16, time: u16, ) -> bool

Examples found in repository?
examples/buzzer.rs (line 18)
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }
    
    drone.buzzer_hz(DeviceType::Controller, 1200, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1000, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(2000);
    
    drone.buzzer_hz(DeviceType::Controller, 1000, 100);
    drone.sleep(10);
    drone.buzzer_hz_reserve(DeviceType::Controller, 1200, 100);
    drone.sleep(500);

    drone.buzzer_scale(DeviceType::Controller, buzzer::Scale::C5, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::B4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::A4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::G4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::F4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::E4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::D4, 100);
    drone.sleep(10);
    drone.buzzer_scale_reserve(DeviceType::Controller, buzzer::Scale::C4, 100);
    drone.sleep(2000);
}
Source

pub fn buzzer_mute(&mut self, target: DeviceType, time: u16) -> bool

Source

pub fn buzzer_mute_reserve(&mut self, target: DeviceType, time: u16) -> bool

Source

pub fn vibrator(&mut self, on: u16, off: u16, time: u16) -> bool

Examples found in repository?
examples/vibrator.rs (line 19)
8
9
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
37
38
39
40
41
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.request(DeviceType::Controller, DataType::Information);

    println!("#1");
    drone.vibrator(200, 200, 2000);
    drone.sleep(2500);

    println!("#2");
    drone.vibrator(100, 200, 2000);
    drone.sleep(2500);

    println!("#3");
    drone.vibrator(200, 100, 2000);
    drone.sleep(2500);

    println!("#4");
    drone.vibrator(100, 100, 2000);
    drone.sleep(2500);

    loop {
        handler(&drone.check());

        if drone.get_time_passed_from_last_transfer() > 1200 {
            break;
        }
    }
}
Source

pub fn vibrator_reserve(&mut self, on: u16, off: u16, time: u16) -> bool

Source

pub fn draw_clear_all(&mut self, pixel: Pixel) -> bool

Examples found in repository?
examples/light.rs (line 50)
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
fn show(drone: &mut Drone, title: String, sub_title: String, time_wait_sec: i32)
{
    drone.sleep(10);
    drone.draw_clear_all(Pixel::White);

    drone.sleep(10);
    drone.draw_string_align(0, 128, 32 - 4 - 8 - 4, Align::Center, Font::LM5x8, Pixel::Black, title);

    drone.sleep(10);
    drone.draw_string_align(0, 128, 32 - 4, Align::Center, Font::LM5x8, Pixel::Black, sub_title);

    if time_wait_sec == 0 {
        return;
    }

    drone.sleep(10);
    let mut time_remain = time_wait_sec;
    loop 
    {
        drone.draw_string_align(0, 128, 32 + 4 + 4, Align::Center, Font::LM5x8, Pixel::Black, format!("  {}  ", time_remain));
        drone.sleep(1000);

        time_remain = time_remain - 1;

        if time_remain <= 0 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/display.rs (line 17)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_clear( &mut self, x: i16, y: i16, width: i16, height: i16, pixel: Pixel, ) -> bool

Examples found in repository?
examples/display.rs (line 20)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_invert(&mut self, x: i16, y: i16, width: i16, height: i16) -> bool

Examples found in repository?
examples/display.rs (line 23)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_point(&mut self, x: i16, y: i16, pixel: Pixel) -> bool

Examples found in repository?
examples/display.rs (line 26)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_line( &mut self, x1: i16, y1: i16, x2: i16, y2: i16, pixel: Pixel, line: Line, ) -> bool

Examples found in repository?
examples/display.rs (line 29)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_rect( &mut self, x: i16, y: i16, width: i16, height: i16, pixel: Pixel, fill: bool, line: Line, ) -> bool

Examples found in repository?
examples/display.rs (line 32)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_circle( &mut self, x: i16, y: i16, radius: i16, pixel: Pixel, fill: bool, ) -> bool

Examples found in repository?
examples/display.rs (line 35)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_string( &mut self, x: i16, y: i16, font: Font, pixel: Pixel, string: String, ) -> bool

Examples found in repository?
examples/display.rs (line 38)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_string_align( &mut self, x_start: i16, x_end: i16, y: i16, align: Align, font: Font, pixel: Pixel, string: String, ) -> bool

Examples found in repository?
examples/light.rs (line 53)
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
fn show(drone: &mut Drone, title: String, sub_title: String, time_wait_sec: i32)
{
    drone.sleep(10);
    drone.draw_clear_all(Pixel::White);

    drone.sleep(10);
    drone.draw_string_align(0, 128, 32 - 4 - 8 - 4, Align::Center, Font::LM5x8, Pixel::Black, title);

    drone.sleep(10);
    drone.draw_string_align(0, 128, 32 - 4, Align::Center, Font::LM5x8, Pixel::Black, sub_title);

    if time_wait_sec == 0 {
        return;
    }

    drone.sleep(10);
    let mut time_remain = time_wait_sec;
    loop 
    {
        drone.draw_string_align(0, 128, 32 + 4 + 4, Align::Center, Font::LM5x8, Pixel::Black, format!("  {}  ", time_remain));
        drone.sleep(1000);

        time_remain = time_remain - 1;

        if time_remain <= 0 {
            break;
        }
    }
}
More examples
Hide additional examples
examples/display.rs (line 45)
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
fn main() {
    let mut drone: Drone = Drone::new("COM75");             // windows
    //let mut drone: Drone = Drone::new("/dev/ttyACM0");      // linux

    if drone.is_connected() == false {
        return;
    }

    drone.draw_clear_all(Pixel::Black);
    drone.sleep(1000);

    drone.draw_clear(10, 10, 108, 44, Pixel::White);
    drone.sleep(1000);

    drone.draw_invert(5, 5, 20, 20);
    drone.sleep(1000);

    drone.draw_point(30, 30, Pixel::Black);
    drone.sleep(1000);

    drone.draw_line(108, 30, 20, 44, Pixel::Black, Line::Solid);
    drone.sleep(1000);

    drone.draw_rect(20, 10, 90, 40, Pixel::Black, true, Line::Solid);
    drone.sleep(1000);

    drone.draw_circle(64, 32, 30, Pixel::White, true);
    drone.sleep(1000);

    drone.draw_string(40, 18, Font::LM5x8, Pixel::Black, String::from("HELLO WORLD"));
    drone.sleep(1000);

    loop {
        let now = Local::now();
        let str_time: String = format!("{:02}:{:02}:{:02}", now.hour(), now.minute(), now.second());
    
        drone.draw_string_align(0, 128, 40, Align::Center, Font::LM10x16, Pixel::White, str_time);
        drone.sleep(27);
        
        if drone.get_time_passed_from_start() > 20000 {
            break;
        }
    }

    drone.draw_string(40, 20, Font::LM10x16, Pixel::White, String::from(" BYE "));
    drone.sleep(1000);
}
Source

pub fn draw_image( &mut self, x: i16, y: i16, width: i16, height: i16, vec_image: Vec<u8>, ) -> bool

Auto Trait Implementations§

§

impl Freeze for Drone

§

impl !RefUnwindSafe for Drone

§

impl Send for Drone

§

impl !Sync for Drone

§

impl Unpin for Drone

§

impl !UnwindSafe for Drone

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where 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 T
where 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 T
where U: Into<T>,

Source§

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 T
where U: TryFrom<T>,

Source§

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.