1
  2
  3
  4
  5
  6
  7
  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
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::net::UdpSocket;
use std::error::Error;
use hex;

pub mod drones;
pub mod traits;

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

pub mod errors {
    use std::fmt;
    
    /// Error for issues with socket connection
    pub struct ConnectionError;

    // Implement std::fmt::Display for ConnectionError
    impl fmt::Display for ConnectionError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "An Connection Error Occurred, Please confirm that you are connected to the drone's WiFi network!") // user-facing output
        }
    }

    // Implement std::fmt::Debug for ConnectionError
    impl fmt::Debug for ConnectionError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "{{ file: {}, line: {} }}", file!(), line!()) // programmer-facing output
        }
    }


    /// Error for issues with drone executing commands
    pub struct CommandError;

    // Implement std::fmt::Display for CommandError
    impl fmt::Display for CommandError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "An Command Error Occurred, Please confirm the hex values for your drone are valid") // user-facing output
        }
    }

    // Implement std::fmt::Debug for CommandError
    impl fmt::Debug for CommandError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "{{ file: {}, line: {} }}", file!(), line!()) // programmer-facing output
        }
    }
}

/// Connection of a drone
pub struct DroneUdpConnection {
    /// Ip to listen on
    bind_ip: String,
    /// Port to listen on
    bind_port: String,

    /// IP to connect to
    connect_ip: String,
    /// Port to connect to
    connect_port: String,

    /// Socket of drone
    sock: UdpSocket
}

impl DroneUdpConnection {

    /// Create a new drone connection takes in `bind_ip`, `bind_port`, `connect_ip`, and `connect_port` all as `Strings`
    pub fn new(bind_ip: String, bind_port: String, connect_ip: String, connect_port: String) -> Self {
        let mut bind_url = String::new();

        bind_url.push_str(&bind_ip);
        bind_url.push_str(":");
        bind_url.push_str(&bind_port);

        DroneUdpConnection {
            bind_ip,
            bind_port,
            connect_ip,
            connect_port,
            // Not yet connected
            sock: UdpSocket::bind(bind_url).unwrap()
        }
    }

    /// Connect DroneConnection to drone
    pub fn connect(&mut self) -> Result<(), Box<dyn Error>> {
        // // Create binding url
        // let mut bind_url = String::new();

        // bind_url.push_str(&self.bind_ip);
        // bind_url.push_str(":");
        // bind_url.push_str(&self.bind_port);


        // // Bind to port
        // self.sock = UdpSocket::bind(bind_url)?;

        // Create connection url
        let mut conn_url = String::new();
        conn_url.push_str(&self.connect_ip);
        conn_url.push_str(":");
        conn_url.push_str(&self.connect_port);

        // Connect to socket
        self.sock.connect(conn_url)?;

        Ok(())

    }

    /// Send a static command to the drone
    pub fn send_command(&mut self, hex_str: String) -> Result<(), Box<dyn Error>> {
        // Convert hex codes
        let command: &[u8] = &hex::decode(&hex_str)?;

        // Send to socket
        self.sock.send(command)?;

        // Return we're okay
        Ok(())
    }

}

/// Status of a drone 
pub struct DroneStatus{
    /// Battery charge of the drone
    bat_charge: usize,
    /// Capacity of drone battery
    bat_cap: usize
}