Enum Order

pub enum Order {
    HELLO = 0,
    SERVO = 1,
    MOTOR = 2,
    ALREADY_CONNECTED = 3,
    ERROR = 4,
    RECEIVED = 5,
    STOP = 6,
}

Variants

HELLO = 0

SERVO = 1

MOTOR = 2

ALREADY_CONNECTED = 3

ERROR = 4

RECEIVED = 5

STOP = 6

Implementations

impl Order

Shortcut for convert_i8_to_order

Example

use robust_arduino_serial::Order;

let order: i8 = 2;  // Order::MOTOR has the index 2 in the enum
let converted_order = Order::from_i8(order).unwrap();

assert_eq!(converted_order, Order::MOTOR);

pub fn from_i8(num: i8) -> Option<Order>

Examples found in repository

examples/arduino_serial.rs (line 42)

fn main() {

    let args: Vec<String> = env::args().skip(1).collect();

    if args.len() < 1
    {
        panic!("Please provide a serial port as argument (ex: /dev/ttyACM0)");
    }
    let serial_port = &args[0];

    println!("Opening port: {:?}", serial_port);
    let mut port = serial::open(&serial_port).unwrap();
    port.configure(&SETTINGS).unwrap();
    // timeout of 30s
    port.set_timeout(Duration::from_secs(30)).unwrap();

    loop
    {
        println!("Waiting for Arduino...");
        let order = Order::HELLO as i8;
        write_i8(&mut port, order).unwrap();
        let received_order = Order::from_i8(read_i8(&mut port).unwrap()).unwrap();
        if received_order == Order::ALREADY_CONNECTED
        {
            break;
        }
        thread::sleep(Duration::from_secs(1));
    }

    println!("Connected to Arduino");

    let motor_order = Order::MOTOR as i8;
    let motor_speed: i8 = -56;
    write_i8(&mut port, motor_order).unwrap();
    write_i8(&mut port, motor_speed).unwrap();

    write_i8(&mut port, Order::SERVO as i8).unwrap();
    write_i16(&mut port, 120_i16).unwrap();

    for _ in 0..10 {
        let order = read_i8(&mut port).unwrap();
        println!("Order received: {:?}", order);

        if let Some(received_order) = Order::from_i8(order)
        {
            println!("Known order: {:?}", received_order);
        }
        else
        {
            println!("Unknown order: {:?}", order);
        }
    }
}

examples/file_read_write.rs (line 41)

fn main() {
    let args: Vec<String> = env::args().skip(1).collect();
    if args.len() < 1
    {
        panic!("Please provide a filename as argument");
    }
    let filename = &args[0];
    // Open file and create it if it does not exist
    let mut file = match OpenOptions::new().read(true).write(true).create(true).open(filename)
                    {
                        Err(why) => panic!("Could not open file {}: {}", filename, why),
                        Ok(file) => file
                    };

    // write_order is equivalent to write_i8
    write_order(&mut file, Order::HELLO).unwrap();

    let motor_order = Order::MOTOR as i8;
    let motor_speed: i16 = -56;
    write_i8(&mut file, motor_order).unwrap();
    write_i16(&mut file, motor_speed).unwrap();
    write_i32(&mut file, 131072).unwrap();

    // Go to the beginning of the file
    file.seek(SeekFrom::Start(0)).unwrap();

    for _ in 0..2 {
        // We could have also use read_order(&mut file).unwrap()
        let order = read_i8(&mut file).unwrap();
        println!("Ordered received: {:?}", order);

        if let Some(received_order) = Order::from_i8(order)
        {
            println!("Known order: {:?}", received_order);
            match received_order
            {
                Order::MOTOR => {
                    let motor_speed = read_i16(&mut file).unwrap();
                    println!("Motor Speed = {}", motor_speed);
                    let test = read_i32(&mut file).unwrap();
                    println!("test = {}", test);
                },
                _ => ()
            }
        }
        else
        {
            println!("Unknown order: {:?}", order);
        }
    }
}

examples/arduino_threads.rs (line 46)

fn main() {

    let args: Vec<String> = env::args().skip(1).collect();

    if args.len() < 1
    {
        panic!("Please provide a serial port as argument (ex: /dev/ttyACM0)");
    }
    let serial_port = &args[0];

    println!("Opening port: {:?}", serial_port);
    let mut port = serial::open(&serial_port).unwrap();
    port.configure(&SETTINGS).unwrap();
    // timeout of 1ms
    port.set_timeout(Duration::from_millis(1)).unwrap();

    loop
    {
        println!("Waiting for Arduino...");
        write_order(&mut port, Order::HELLO).unwrap();
        let received_order = match read_i8(&mut port) {
            Ok(order) => Order::from_i8(order).unwrap(),
            Err(ref e) if e.kind() == ErrorKind::TimedOut => {
                // If we have a read timeout, wait a bit
                thread::sleep(Duration::from_secs(2));
                continue
                }
            Err(e) => {
                    panic!("An error occured reading serial port: {}", e)
                }

        };

        if received_order == Order::ALREADY_CONNECTED
        {
            break;
        }
        thread::sleep(Duration::from_secs(1));
    }

    println!("Connected to Arduino");

    // Channel to send and receive commands
    let (command_sender, command_receiver) = mpsc::channel();
    let command_queue = mpsc::Sender::clone(&command_sender);

    // Wrap the serial to use it in the threads
    let serial_arc = Arc::new(Mutex::new(port));
    let serial_command = serial_arc.clone();

    // Exit event to notify thread when they should exit
    let exit_event = false;
    // Wrap the boolean to use it in the threads
    let exit_arc = Arc::new(Mutex::new(exit_event));
    let exit_listener = exit_arc.clone();
    let exit_command = exit_arc.clone();

    // Semaphore to avoid Arduino buffer overflow:
    // Do not send new order if the Arduino did not aknowledge
    // the previous message
    let n_allowed_messages = 2;
    let semaphore = Arc::new(Semaphore::new(n_allowed_messages));
    let semaphore_command = semaphore.clone();

    let mut threads = vec![];

    // Command thread listen to the command Channel
    // and send orders to the Arduino
    let command_thread = thread::spawn(move || {
        let mut exit = false;
        while !exit
        {
            // Decrement the semaphore counter
            // each time we send an order
            semaphore.acquire();
            let (order, num) = command_receiver.recv().unwrap();

            println!("Sending: {:?}, {}", order, num);

            // Acquire lock on the buffer
            let mut buffer = serial_command.lock().unwrap();

            write_order(&mut *buffer, order).unwrap();
            match order {
                Order::MOTOR => write_i8(&mut *buffer, num as i8).unwrap(),
                Order::SERVO => write_i16(&mut *buffer, num as i16).unwrap(),
                _ => 0  // Write 0 bytes
            };
            exit = *exit_command.lock().unwrap();
        }
        println!("Command Thread exiting...");
    });

    threads.push(command_thread);

    // Listener thread listens to the Arduino
    // it release the semaphore when an aknowledgement is received
    let listener_thread = thread::spawn(move || {

        let mut exit = false;
        let mut wait = false;
        while !exit
        {
            // Wait a bit so the command thread can acquire the lock
            if wait
            {
                thread::sleep(Duration::from_millis(100));
            }

            // Acquire lock on the serial object
            let mut buffer = serial_arc.lock().unwrap();

            // Receive order from arduino
            let received_order = match read_i8(&mut *buffer) {
                Ok(order) => Order::from_i8(order).unwrap(),
                Err(_) => {
                        wait = true;
                        continue
                    }

            };
            wait = false;

            println!("Received: {:?}", received_order);

            match received_order {
                Order::RECEIVED => semaphore_command.release(),
                _ => ()
            }

            exit = *exit_listener.lock().unwrap();
        }
        println!("Listener Thread exiting...");
    });

    threads.push(listener_thread);

    thread::sleep(Duration::from_secs(1));
    // Send Orders to the Arduino
    command_queue.send((Order::MOTOR, 42_i32)).unwrap();
    command_queue.send((Order::SERVO, 120_i32)).unwrap();

    // Wait a bit before shutting down the threads
    thread::sleep(Duration::from_secs(2));

    // Stop the motor
    command_queue.send((Order::MOTOR, 0_i32)).unwrap();


    // Notify the threads that they should exit
    {
        *exit_arc.lock().unwrap() = true;
    }

    // Send dummy orders to exit the command thread
    command_queue.send((Order::HELLO, 0_i32)).unwrap();

    for t in threads
    {
        t.join().unwrap();
    }
}

Trait Implementations

impl Clone for Order

fn clone(&self) -> Order

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Order

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

Formats the value using the given formatter.

impl PartialEq for Order

fn eq(&self, other: &Order) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Order

impl StructuralPartialEq for Order